Fix critical bugs in Night-Humidity-Priority and EnvironmentGuard integration

Bug Fixes:
1. Night-Humidity-Priority now ALWAYS active in VPD modes
   - Previously only active when vpdDeviceDampening=False
   - Now integrated into process_actions_with_dampening() path
   - Ensures consistent energy-efficient behavior across all configurations

2. EnvironmentGuard now ALWAYS active in VPD modes
   - Previously only active in fallback path (vpdDeviceDampening=False)
   - Critical safety fix: prevents cold/dry air intake without protection
   - Applied AFTER Night-Humidity-Priority and Device Dampening

3. Physikalisch-aware Air-Exchange suppression
   - Air-Exchange now suppressed when it works against humidity goal
   - RH high + Temp low: Dehumidifier only (Air-Exchange would cool)
   - RH low + Temp high: Cooler only (Air-Exchange would dry)
   - Extreme temp deviation (≥5°C): Allows all actions

Changes:
- OGBDampeningActions.process_actions_with_dampening(): Added night humidity priority
- OGBActionManager.checkLimitsAndPublicateWithDampening(): Added EnvironmentGuard
- ClosedActions: Added air-mixing suppression for night humidity priority
- Tests: Added comprehensive coverage for new behavior
- Docs: Updated with integration notes and bug fix details

Test Results: All 117 tests passing

Author: Luca Azzinnaro

custom_components/opengrowbox/OGBController/actions/ClosedActions.py

@@ -612,7 +612,9 @@ async def execute_closed_environment_cycle(self, capabilities: Dict[str, Any]):
 
         # Humidity Control (only if NOT in humidity deadband)
         hum_status = "stabil"
+        hum_needs_correction = False
         if not hum_in_db:
+            hum_needs_correction = True
             hum_actions, hum_status = await self.control_humidity_closed(capabilities)
             all_actions.extend(hum_actions)
         else:
@@ -621,18 +623,21 @@ async def execute_closed_environment_cycle(self, capabilities: Dict[str, Any]):
 
         # Temperature Control (only if NOT in temp deadband)
         temp_status = "stabil"
+        temp_needs_correction = False
         if not temp_in_db:
-            if night_humidity_priority and not hum_in_db and abs(hum_dev) > 0:
-                temp_limit_dev = self.control_logic.calculate_temperature_deviation().get("deviation", 0)
-                if abs(temp_limit_dev) >= self.night_humidity_temp_guard:
+            temp_needs_correction = True
+            temp_dev_data = self.control_logic.calculate_temperature_deviation()
+            temp_limit_dev = temp_dev_data.get("deviation", 0)
+            
+            if night_humidity_priority and hum_needs_correction:
+                should_control_temp = self._should_control_temp_at_night(hum_status, temp_dev_data)
+                if should_control_temp:
                     temp_actions, temp_status = await self.control_temperature_closed(capabilities)
                     all_actions.extend(temp_actions)
                 else:
-                    temp_status = (
-                        f"nacht-priorisiert (Feuchte zuerst, Temp-Limitabweichung {abs(temp_limit_dev):.1f}°C zu klein)"
-                    )
+                    temp_status = self._get_night_suppression_reason(hum_status, temp_dev_data)
                     _LOGGER.info(
-                        f"{self.ogb.room}: Closed Environment night humidity priority active - suppressing temp control in favor of humidity"
+                        f"{self.ogb.room}: Night humidity priority - {temp_status}"
                     )
             else:
                 temp_actions, temp_status = await self.control_temperature_closed(capabilities)
@@ -642,9 +647,18 @@ async def execute_closed_environment_cycle(self, capabilities: Dict[str, Any]):
             _LOGGER.debug(f"{self.ogb.room}: Temperature in deadband ({temp_dev:.1f}°C deviation) - skipping temp actions")
 
         # Air Recirculation (only if neither temp nor humidity in deadband)
+        # But suppress at night if humidity priority active and opposing directions
         if not temp_in_db and not hum_in_db:
-            air_actions = await self.optimize_air_recirculation(capabilities)
-            all_actions.extend(air_actions)
+            if night_humidity_priority:
+                should_run_air_mixing = self._should_run_air_mixing_at_night(hum_status, temp_dev, hum_dev)
+                if should_run_air_mixing:
+                    air_actions = await self.optimize_air_recirculation(capabilities)
+                    all_actions.extend(air_actions)
+                else:
+                    _LOGGER.debug(f"{self.ogb.room}: Night humidity priority - skipping air mixing")
+            else:
+                air_actions = await self.optimize_air_recirculation(capabilities)
+                all_actions.extend(air_actions)
         else:
             _LOGGER.debug(f"{self.ogb.room}: Skipping air recirculation (deadband active)")
 
@@ -959,6 +973,65 @@ def _is_night_humidity_priority_active(self) -> bool:
             and bool(self.ogb.dataStore.getDeep("controlOptions.nightVPDHold", True))
         )
 
+    def _should_control_temp_at_night(self, hum_status: str, temp_dev_data: Dict[str, Any]) -> bool:
+        """Determine if temperature control should be active during night humidity priority.
+        
+        Physikalisch-aware Logik (Option C):
+        - Extreme Temp-Abweichung (>= 5°C): Immer erlauben (Pflanzenschutz)
+        - RH hoch + Temp niedrig: Entfeuchter reicht (wärmt dabei) → Keine Temp-Kontrolle
+        - RH niedrig + Temp hoch: Kühler reicht (erhöht RH) → Keine Temp-Kontrolle
+        - Andere Kombinationen: Keine Temp-Kontrolle bei moderate Abweichung
+        """
+        temp_status = temp_dev_data.get("status")
+        temp_deviation = abs(temp_dev_data.get("deviation", 0))
+        
+        if temp_status == "no_data" or temp_status == "invalid":
+            return False
+        
+        if temp_status == "stabil":
+            return False
+        
+        if temp_deviation >= 5.0:
+            return True
+        
+        if hum_status == "entfeuchten" and temp_status == "too_low":
+            return False
+        
+        if hum_status == "befeuchten" and temp_status == "too_high":
+            return False
+        
+        return False
+
+    def _get_night_suppression_reason(self, hum_status: str, temp_dev_data: Dict[str, Any]) -> str:
+        """Get human-readable reason for temperature suppression at night."""
+        temp_status = temp_dev_data.get("status")
+        temp_deviation = abs(temp_dev_data.get("deviation", 0))
+        
+        if hum_status == "entfeuchten" and temp_status == "too_low":
+            return f"RH-Priorität: Entfeuchter senkt RH und wärmt (Temp {temp_deviation:.1f}°C zu niedrig ignoriert)"
+        if hum_status == "befeuchten" and temp_status == "too_high":
+            return f"RH-Priorität: Kühler senkt Temp und erhöht RH (Temp {temp_deviation:.1f}°C zu hoch ignoriert)"
+        if temp_deviation < 5.0:
+            return f"RH-Priorität: Tempabweichung {temp_deviation:.1f}°C < 5°C Schwellenwert"
+        
+        return "RH-Priorität aktiv"
+
+    def _should_run_air_mixing_at_night(self, hum_status: str, temp_dev: float, hum_dev: float) -> bool:
+        """Determine if air mixing should run during night humidity priority.
+        
+        Physikalisch-aware Logik (Option C):
+        - RH hoch + Temp niedrig: Air-Exchange würde kühlen → unterdrücken
+        - RH niedrig + Temp hoch: Air-Exchange würde trocknen → unterdrücken
+        - Andere Kombinationen: Erlauben
+        """
+        if hum_status == "entfeuchten" and temp_dev < 0:
+            return False
+        
+        if hum_status == "befeuchten" and temp_dev > 0:
+            return False
+        
+        return True
+
     def _determine_co2_status(self, current_co2, min_co2, max_co2, is_light_on: bool) -> str:
         """Determine CO2 control status."""
         try:

custom_components/opengrowbox/OGBController/actions/OGBDampeningActions.py

@@ -151,6 +151,14 @@ async def process_actions_with_dampening(self, action_map: List) -> List:
             vpd_status,  # Add VPD status for context-aware enhancement
         )
 
+        # Apply night humidity priority if active (physikalisch-aware)
+        if is_night_vpd_hold:
+            enhanced_action_map = self._apply_night_humidity_priority(
+                enhanced_action_map,
+                real_temp_dev,
+                real_hum_dev,
+            )
+
         # Apply dampening filter
         dampened_actions, blocked_actions = (
             self.action_manager._filterActionsByDampening(
@@ -217,8 +225,8 @@ async def process_actions_with_dampening(self, action_map: List) -> List:
         else:
             _LOGGER.warning(f"{self.ogb.room}: No actions to execute after conflict resolution")
 
-        # Execute actions
-        await self._execute_actions(final_actions)
+        # DO NOT execute actions here - let ActionManager apply EnvironmentGuard first
+        # await self._execute_actions(final_actions)
 
         return final_actions
 
@@ -346,27 +354,72 @@ def _get_night_humidity_priority_devices(self, vpd_status: str) -> List[str]:
         return device_priority.get(vpd_status, ["canVentilate", "canIntake"])
 
     def _apply_night_humidity_priority(self, actions: List, real_temp_dev: float, real_hum_dev: float) -> List:
-        """At night, prefer humidity and air-exchange actions to smooth VPD and prevent mold."""
+        """At night, apply physikalisch-aware humidity priority to smooth VPD and prevent mold.
+        
+        Physikalisch-aware Logik (Option C):
+        - RH hoch (real_hum_dev > 0) + Temp niedrig (real_temp_dev < 0): Entfeuchter reicht (wärmt dabei), Air-Exchange unterdrückt (kühlt)
+        - RH niedrig (real_hum_dev < 0) + Temp hoch (real_temp_dev > 0): Kühler reicht (erhöht RH), Air-Exchange unterdrückt (trocknet)
+        - Andere Kombinationen: Erlaube Temp-Kontrolle bei extremer Abweichung (>= 5°C)
+        """
         if not self._is_night_vpd_hold_active():
             return actions
 
-        humidity_caps = {"canDehumidify", "canHumidify", "canExhaust", "canVentilate", "canIntake", "canWindow"}
+        humidity_device_caps = {"canDehumidify", "canHumidify"}
+        air_exchange_caps = {"canExhaust", "canVentilate", "canIntake", "canWindow"}
         temperature_caps = {"canHeat", "canCool", "canClimate"}
 
-        # Humidity out of range at night should dominate. Keep temp actions only for strong temp deviations.
+        # Check if humidity needs correction
         if abs(real_hum_dev) > 0:
-            keep_temperature = abs(real_temp_dev) >= 3.0
+            # Physikalisch-aware: check opposing directions
+            rh_high = real_hum_dev > 0
+            temp_low = real_temp_dev < 0
+            temp_high = real_temp_dev > 0
+            rh_low = real_hum_dev < 0
+            
+            # Determine if temperature actions should be kept
+            keep_temperature = True
+            keep_air_exchange = True
+            suppression_reason = None
+            air_exchange_reason = None
+            
+            if rh_high and temp_low:
+                # RH hoch + Temp niedrig: Entfeuchter wärmt → kein Heizer nötig
+                # Air-Exchange würde kühlen → unterdrücken
+                keep_temperature = abs(real_temp_dev) >= 5.0
+                keep_air_exchange = False
+                suppression_reason = f"Entfeuchter senkt RH und wärmt (Temp {abs(real_temp_dev):.1f}°C zu niedrig ignoriert)"
+                air_exchange_reason = f"Air-Exchange würde kühlen (Entfeuchter wärmt bereits)"
+            elif rh_low and temp_high:
+                # RH niedrig + Temp hoch: Kühler erhöht RH → kein Kühler nötig
+                # Air-Exchange würde trocknen → unterdrücken
+                keep_temperature = abs(real_temp_dev) >= 5.0
+                keep_air_exchange = False
+                suppression_reason = f"Kühler senkt Temp und erhöht RH (Temp {abs(real_temp_dev):.1f}°C zu hoch ignoriert)"
+                air_exchange_reason = f"Air-Exchange würde trocknen (Kühler erhöht bereits RH)"
+            elif abs(real_temp_dev) < 5.0:
+                # Moderate Temp-Abweichung ohne physikalischen Konflikt
+                keep_temperature = False
+                keep_air_exchange = True
+                suppression_reason = f"Tempabweichung {abs(real_temp_dev):.1f}°C < 5°C Schwellenwert"
+            
             prioritized = []
             for action in actions:
                 cap = getattr(action, "capability", None)
-                if cap in humidity_caps:
+                if cap in humidity_device_caps:
                     prioritized.append(dataclasses.replace(action, priority="high"))
+                elif cap in air_exchange_caps:
+                    if keep_air_exchange:
+                        prioritized.append(dataclasses.replace(action, priority="high"))
+                    else:
+                        _LOGGER.info(
+                            f"{self.ogb.room}: NightHoldVPD suppressing {cap} - {air_exchange_reason}"
+                        )
                 elif cap in temperature_caps:
                     if keep_temperature:
                         prioritized.append(dataclasses.replace(action, priority="low"))
                     else:
-                        _LOGGER.debug(
-                            f"{self.ogb.room}: NightHoldVPD suppressing {cap} in favor of humidity-first control"
+                        _LOGGER.info(
+                            f"{self.ogb.room}: NightHoldVPD suppressing {cap} - {suppression_reason}"
                         )
                 else:
                     prioritized.append(action)

custom_components/opengrowbox/OGBController/managers/OGBActionManager.py

@@ -700,21 +700,60 @@ def _apply_night_humidity_priority_to_actions(self, action_map: List, tent_data:
         if abs(real_hum_dev) <= 0:
             return action_map
 
-        humidity_caps = {"canDehumidify", "canHumidify", "canExhaust", "canVentilate", "canIntake", "canWindow"}
+        humidity_device_caps = {"canDehumidify", "canHumidify"}
+        air_exchange_caps = {"canExhaust", "canVentilate", "canIntake", "canWindow"}
         temperature_caps = {"canHeat", "canCool", "canClimate"}
-        keep_temperature = abs(real_temp_dev) >= 3.0
+
+        # Physikalisch-aware: check opposing directions
+        rh_high = real_hum_dev > 0
+        temp_low = real_temp_dev < 0
+        temp_high = real_temp_dev > 0
+        rh_low = real_hum_dev < 0
+        
+        # Determine if temperature actions should be kept
+        keep_temperature = True
+        keep_air_exchange = True
+        suppression_reason = None
+        air_exchange_reason = None
+        
+        if rh_high and temp_low:
+            # RH hoch + Temp niedrig: Entfeuchter wärmt → kein Heizer nötig
+            # Air-Exchange würde kühlen → unterdrücken
+            keep_temperature = abs(real_temp_dev) >= 5.0
+            keep_air_exchange = False
+            suppression_reason = f"Entfeuchter senkt RH und wärmt (Temp {abs(real_temp_dev):.1f}°C zu niedrig ignoriert)"
+            air_exchange_reason = f"Air-Exchange würde kühlen (Entfeuchter wärmt bereits)"
+        elif rh_low and temp_high:
+            # RH niedrig + Temp hoch: Kühler erhöht RH → kein Kühler nötig
+            # Air-Exchange würde trocknen → unterdrücken
+            keep_temperature = abs(real_temp_dev) >= 5.0
+            keep_air_exchange = False
+            suppression_reason = f"Kühler senkt Temp und erhöht RH (Temp {abs(real_temp_dev):.1f}°C zu hoch ignoriert)"
+            air_exchange_reason = f"Air-Exchange würde trocknen (Kühler erhöht bereits RH)"
+        elif abs(real_temp_dev) < 5.0:
+            # Moderate Temp-Abweichung ohne physikalischen Konflikt
+            keep_temperature = False
+            keep_air_exchange = True
+            suppression_reason = f"Tempabweichung {abs(real_temp_dev):.1f}°C < 5°C Schwellenwert"
 
         filtered_actions = []
         for action in action_map:
             capability = getattr(action, "capability", None)
-            if capability in humidity_caps:
+            if capability in humidity_device_caps:
                 filtered_actions.append(dataclasses.replace(action, priority="high"))
+            elif capability in air_exchange_caps:
+                if keep_air_exchange:
+                    filtered_actions.append(dataclasses.replace(action, priority="high"))
+                else:
+                    _LOGGER.info(
+                        f"{self.room}: NightHoldVPD suppressing {capability} - {air_exchange_reason}"
+                    )
             elif capability in temperature_caps:
                 if keep_temperature:
                     filtered_actions.append(dataclasses.replace(action, priority="low"))
                 else:
-                    _LOGGER.debug(
-                        f"{self.room}: NightHoldVPD suppressing {capability} in favor of humidity-first control"
+                    _LOGGER.info(
+                        f"{self.room}: NightHoldVPD suppressing {capability} - {suppression_reason}"
                     )
             else:
                 filtered_actions.append(action)
@@ -1413,30 +1452,36 @@ async def checkLimitsAndPublicateWithDampening(self, actionMap: List):
 
         # Check if device dampening is enabled in control options
         dampening_enabled = self.data_store.getDeep("controlOptions.vpdDeviceDampening", False)
+        final_actions = []
+        
         if self.dampening_actions and dampening_enabled:
-            await self.dampening_actions.process_actions_with_dampening(actionMap)
+            # Process with full dampening (includes night humidity priority now)
+            final_actions = await self.dampening_actions.process_actions_with_dampening(actionMap)
         else:
             # Fallback: execute actions directly without dampening
             _LOGGER.info(f"{self.room}: VPD mode with dampening (dampening disabled) - executing {len(actionMap)} actions directly")
-            actionMap = self._apply_night_humidity_priority_to_actions(actionMap)
+            final_actions = self._apply_night_humidity_priority_to_actions(actionMap)
 
             # Log actions before environment guard
-            action_summary = ", ".join([f"{getattr(a, 'capability', 'unknown')}:{getattr(a, 'action', 'unknown')}" for a in actionMap])
+            action_summary = ", ".join([f"{getattr(a, 'capability', 'unknown')}:{getattr(a, 'action', 'unknown')}" for a in final_actions])
             await self.event_manager.emit(
                 "LogForClient",
                 {
                     "Name": self.room,
-                    "message": f"VPD dampening mode: executing {len(actionMap)} actions",
+                    "message": f"VPD dampening mode: executing {len(final_actions)} actions",
                     "actions": action_summary,
-                    "actionCount": len(actionMap),
+                    "actionCount": len(final_actions),
                     "dampeningEnabled": False,
                 },
                 haEvent=True,
                 debug_type="INFO",
             )
-            
-            final_actions = await self._apply_environment_guard(actionMap)
-            await self.publicationActionHandler(final_actions)
+        
+        # Apply EnvironmentGuard (protects against cold/dry air from ambient/outside)
+        final_actions = await self._apply_environment_guard(final_actions)
+        
+        # Execute final actions
+        await self.publicationActionHandler(final_actions)
 
     async def publicationActionHandler(self, actionMap: List):
         """