boneio 1.4.0.dev3__tar.gz → 1.4.0.dev5__tar.gz

{boneio-1.4.0.dev3/boneio.egg-info → boneio-1.4.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.4.0.dev3
+Version: 1.4.0.dev5
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.4.0.dev3 → boneio-1.4.0.dev5}/boneio/components/cover/cover.py

@@ -192,6 +192,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._movement_thread = None
         self._stop_event = threading.Event()
 
+        # Flag set by action executor to signal this call originates from a button action.
+        # Used by VenetianCover to conditionally skip tilt restore.
+        self._from_action: bool = False
+        # When True, tilt restore is explicitly requested by the action definition.
+        self._action_tilt_restore: bool = False
+
         self._event_bus.add_sigterm_listener(self.on_exit)
 
         with suppress(RuntimeError):

{boneio-1.4.0.dev3 → boneio-1.4.0.dev5}/boneio/components/cover/venetian.py

@@ -35,7 +35,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             actuator_activation_duration: Actuator activation time (unused).
             restored_state: Persisted position/tilt from disk.
             tilt_restore_after_close: If True, restore previous tilt
-                position after closing the cover.
+                position after closing the cover (UI/HA calls).
         """
         self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
         self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
@@ -300,10 +300,17 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def _save_tilt_for_restore(self) -> None:
         """Save current tilt position for later restoration.
 
-        Called before any closing movement when tilt_restore_after_close
-        is enabled. Clears saved value if tilt is already at 0%.
+        Called before any closing movement. Determines whether to save
+        based on the call source:
+        - UI/HA calls: uses tilt_restore_after_close setting
+        - Action calls: uses _action_tilt_restore flag (set by executor)
         """
-        if self._tilt_restore_after_close and self._tilt_position > 0:
+        if self._from_action:
+            should_restore = self._action_tilt_restore
+        else:
+            should_restore = self._tilt_restore_after_close
+
+        if should_restore and self._tilt_position > 0:
             self._tilt_before_close = self._tilt_position
             _LOGGER.debug(
                 "VenetianCover %s: saving tilt=%d%% before close",

{boneio-1.4.0.dev3 → boneio-1.4.0.dev5}/boneio/components/irrigation/controller.py

@@ -75,6 +75,7 @@ class IrrigationController:
         repeat: int = 0,
         auto_advance: bool = True,
         reverse: bool = False,
+        pause_timeout_s: int = 1800,
     ) -> None:
         """Initialize irrigation controller.
 
@@ -95,6 +96,8 @@ class IrrigationController:
             repeat: Number of cycle repeats.
             auto_advance: Automatically advance to next zone.
             reverse: Run zones in reverse order.
+            pause_timeout_s: Auto-shutdown after this many seconds in PAUSED state.
+                Default 1800 (30 minutes). Set 0 to disable.
         """
         self.id = id
         self.name = name
@@ -119,6 +122,8 @@ class IrrigationController:
         self._skip_next_run = False
 
         self._zone_timer_cancel = None
+        self._pause_timer_cancel = None
+        self._pause_timeout_s = max(0, pause_timeout_s)
         self._run_start_utc: datetime | None = None
         self._active_zone_idx: int | None = None
         self._active_zone_remaining_s: int | None = None
@@ -181,6 +186,10 @@ class IrrigationController:
     def _schedule_skip_cmd_topic(self, idx: int) -> str:
         return f"{self._topic_prefix}/cmd/{IRRIGATION}/{self.id}/schedule/{idx}/skip/set"
 
+    def _event_topic(self) -> str:
+        """MQTT topic for HA event entity notifications."""
+        return f"{self._topic_prefix}/{IRRIGATION}/{self.id}/event"
+
     def _state_key(self, suffix: str) -> str:
         return f"{self.id}/{suffix}"
 
@@ -223,6 +232,24 @@ class IrrigationController:
         _LOGGER.debug("Irrigation MQTT publish: topic='%s' payload=%s retain=%s", topic, payload, retain)
         self._message_bus.send_message(topic=topic, payload=payload, retain=retain)
 
+    def _publish_event(self, event_type: str, **attributes: Any) -> None:
+        """Publish an event to the HA event entity topic.
+
+        The payload follows the HA MQTT event entity format:
+        ``{"event_type": "...", ...extra attributes}``.
+
+        Events are NOT retained — they are instantaneous notifications.
+
+        Args:
+            event_type: One of the registered event types
+                (interlock_fault, cycle_complete, standby_blocked).
+            **attributes: Additional key-value pairs included in the event payload.
+        """
+        import json
+
+        payload = {"event_type": event_type, **attributes}
+        self._publish(self._event_topic(), json.dumps(payload), retain=False)
+
     def _ordered_zones(self) -> list[tuple[int, IrrigationZone]]:
         indexed = list(enumerate(self._zones))
         if self._reverse:
@@ -352,6 +379,7 @@ class IrrigationController:
             "".join(traceback.format_stack(limit=5)),
         )
         self.stop_schedules()
+        self._cancel_pause_timer()
         await self._stop_current_zone()
         await self._handle_pump_stop_sequence()
         self._state = ControllerState.IDLE
@@ -370,11 +398,13 @@ class IrrigationController:
         self._cancel_zone_timer()
         await self._stop_current_zone()
         self._state = ControllerState.PAUSED
+        self._arm_pause_timer()
         await self.publish_all_states()
 
     async def resume(self) -> None:
         if self._state != ControllerState.PAUSED or self._active_zone_idx is None:
             return
+        self._cancel_pause_timer()
         remaining = self._active_zone_remaining_s or self._current_zone_duration_seconds()
         await self._start_zone(self._active_zone_idx, override_duration=remaining)
 
@@ -400,6 +430,11 @@ class IrrigationController:
         )
         if self._standby:
             _LOGGER.info("Irrigation %s is in standby mode, not starting", self.id)
+            self._publish_event(
+                "standby_blocked",
+                controller=self.id,
+                message=f"Irrigation '{self.name}' start blocked: standby mode is active",
+            )
             return
 
         if self._state in (ControllerState.RUNNING, ControllerState.PAUSED):
@@ -428,6 +463,12 @@ class IrrigationController:
         )
         if self._standby:
             _LOGGER.info("Irrigation %s is in standby mode, not starting zone", self.id)
+            self._publish_event(
+                "standby_blocked",
+                controller=self.id,
+                zone=zone_id,
+                message=f"Irrigation '{self.name}' zone '{zone_id}' blocked: standby mode is active",
+            )
             return
 
         match_idx = None
@@ -551,6 +592,11 @@ class IrrigationController:
             await self._start_cycle_from_eligible()
             return
 
+        self._publish_event(
+            "cycle_complete",
+            controller=self.id,
+            message=f"Irrigation '{self.name}' cycle completed",
+        )
         await self.shutdown()
 
     def _ordered_zone_indices(self) -> list[int]:
@@ -718,8 +764,10 @@ class IrrigationController:
     async def _handle_interlock_fault(self, zone_id: str, source_id: str | None) -> None:
         """Handle interlock-blocked activation.
 
-        Shuts down the controller and publishes a fault notification via MQTT
-        so that Home Assistant (or other consumers) can alert the user.
+        Shuts down the controller and publishes both a retained fault status
+        message and a non-retained HA event notification via the event entity.
+        Home Assistant automations can listen to the event entity to trigger
+        mobile push notifications, Telegram messages, etc.
 
         Args:
             zone_id: ID of the zone that was being started.
@@ -734,13 +782,15 @@ class IrrigationController:
             source_info,
         )
 
-        # Publish fault notification on MQTT
+        fault_message = f"Irrigation '{self.name}' stopped: output blocked by interlock (zone: {zone_id})"
+
+        # Publish retained fault status on MQTT (legacy topic)
         fault_payload = {
             "fault": "interlock_blocked",
             "controller": self.id,
             "zone": zone_id,
             "source": source_id or "",
-            "message": f"Irrigation '{self.name}' stopped: output blocked by interlock (zone: {zone_id})",
+            "message": fault_message,
         }
         self._publish(
             f"{self._topic_prefix}/{IRRIGATION}/{self.id}/fault",
@@ -748,6 +798,15 @@ class IrrigationController:
             retain=False,
         )
 
+        # Publish HA event entity notification (non-retained, instantaneous)
+        self._publish_event(
+            "interlock_fault",
+            controller=self.id,
+            zone=zone_id,
+            source=source_id or "",
+            message=fault_message,
+        )
+
         await self.shutdown()
         await self.publish_all_states()
 
@@ -799,6 +858,44 @@ class IrrigationController:
     async def _zone_timer_callback(self, _timestamp: datetime) -> None:
         await self._advance_to_next_zone(force=False)
 
+    def _cancel_pause_timer(self) -> None:
+        """Cancel the pause timeout timer if active."""
+        if self._pause_timer_cancel is not None:
+            self._pause_timer_cancel()
+            self._pause_timer_cancel = None
+
+    def _arm_pause_timer(self) -> None:
+        """Arm an auto-shutdown timer for the PAUSED state.
+
+        If pause_timeout_s is 0, no timer is set (pause lasts indefinitely).
+        Otherwise, the controller will auto-shutdown after the configured timeout.
+        """
+        self._cancel_pause_timer()
+        if self._pause_timeout_s <= 0:
+            return
+        point = utcnow() + timedelta(seconds=self._pause_timeout_s)
+        self._pause_timer_cancel = async_track_point_in_time(
+            loop=self._event_bus._loop,
+            job=self._pause_timeout_callback,
+            point_in_time=point,
+        )
+        _LOGGER.info(
+            "Irrigation %s: pause timeout armed for %d seconds",
+            self.id,
+            self._pause_timeout_s,
+        )
+
+    async def _pause_timeout_callback(self, _timestamp: datetime) -> None:
+        """Handle pause timeout — auto-shutdown the controller."""
+        if self._state != ControllerState.PAUSED:
+            return
+        _LOGGER.warning(
+            "Irrigation %s: pause timeout expired after %d seconds, shutting down",
+            self.id,
+            self._pause_timeout_s,
+        )
+        await self.shutdown()
+
     async def handle_main_command(self, payload: str) -> None:
         cmd = payload.strip()
         upper = cmd.upper()

{boneio-1.4.0.dev3 → boneio-1.4.0.dev5}/boneio/components/output/remote.py

@@ -10,15 +10,21 @@ The actual hardware control is delegated to the parent ``ESPHomeDeviceManager``
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from boneio.const import OFF, ON, SWITCH
-from boneio.core.events import EventBus
+from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.core.utils import callback
+from boneio.core.utils.timeperiod import TimePeriod, parse_time_to_seconds
 from boneio.models import OutputState
 from boneio.models.events import OutputEvent
 
+if TYPE_CHECKING:
+    from boneio.integration.interlock import SoftwareInterlockManager
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -60,6 +66,16 @@ class RemoteOutputBase:
         show_in_ha: bool = False,
         area: str | None = None,
         on_disconnect: str = "ignore",
+        interlock_manager: SoftwareInterlockManager | None = None,
+        interlock_groups: list[str] | None = None,
+        enforce_interlock: bool = False,
+        momentary_turn_on: TimePeriod | None = None,
+        momentary_turn_off: TimePeriod | None = None,
+        adjustable_duration: bool = False,
+        duration_default: float = 60.0,
+        duration_min: float = 1.0,
+        duration_max: float = 3600.0,
+        duration_unit: str = "s",
     ) -> None:
         self._id = id
         self._name = name
@@ -72,10 +88,32 @@ class RemoteOutputBase:
         self.area: str | None = area
         self._on_disconnect = on_disconnect
 
+        # Interlock support (shared with local BasicOutput instances)
+        self._interlock_manager: SoftwareInterlockManager | None = interlock_manager
+        self._interlock_groups: list[str] = interlock_groups or []
+        self._enforce_interlock: bool = enforce_interlock
+
+        # Momentary actions (auto-off / auto-on after duration)
+        self._momentary_turn_on: TimePeriod | None = momentary_turn_on
+        self._momentary_turn_off: TimePeriod | None = momentary_turn_off
+        self._momentary_action: Any = None
+
+        # Adjustable duration (HA number entity slider)
+        self._adjustable_duration_enabled: bool = adjustable_duration
+        self._duration_min: float = max(1.0, duration_min)
+        self._duration_max: float = max(self._duration_min, duration_max)
+        self._duration_default: float = duration_default
+        self._duration_unit: str = duration_unit
+        self._adjustable_duration: float = max(self._duration_min, min(self._duration_max, self._duration_default))
+        # If adjustable_duration is on, momentary_turn_on is managed by the slider
+        if self._adjustable_duration_enabled:
+            self._momentary_turn_on = None
+
         self._state: str = OFF
         self._last_timestamp: float = 0.0
         self._available: bool = False
         self._brightness: int | None = None  # 0-255, None if not a dimmable light
+        self._loop: asyncio.AbstractEventLoop | None = None
 
         # Reference to remote device manager — set by register_remote_outputs().
         # May be None at startup if ESPHome devices load in background.
@@ -186,6 +224,34 @@ class RemoteOutputBase:
                 self._id,
             )
 
+    # ------------------------------------------------------------------
+    # Interlock
+    # ------------------------------------------------------------------
+
+    def set_interlock(
+        self,
+        interlock_manager: SoftwareInterlockManager,
+        interlock_groups: list[str],
+    ) -> None:
+        """Set interlock manager and groups.
+
+        Args:
+            interlock_manager: Shared interlock manager instance.
+            interlock_groups: List of group names this output belongs to.
+        """
+        self._interlock_manager = interlock_manager
+        self._interlock_groups = interlock_groups
+
+    def check_interlock(self) -> bool:
+        """Check if this output can be turned on without violating interlocks.
+
+        Returns:
+            True if no interlock violation, False if blocked.
+        """
+        if self._interlock_manager is not None and self._interlock_groups:
+            return self._interlock_manager.can_turn_on(self, self._interlock_groups)
+        return True
+
     # ------------------------------------------------------------------
     # Core control methods (duck-type compatible with BasicOutput)
     # ------------------------------------------------------------------
@@ -193,12 +259,21 @@ class RemoteOutputBase:
     async def async_turn_on(self, timestamp: float | None = None) -> bool:
         """Turn on the remote output.
 
+        Checks interlock before sending the ON command. If another output
+        in the same interlock group is already ON, the request is rejected.
+        After successful ON, schedules momentary auto-OFF if configured.
+
         Args:
             timestamp: Optional timestamp for state tracking.
 
         Returns:
-            True if the output was turned on, False on failure.
+            True if the output was turned on, False if blocked or failed.
         """
+        can_turn_on = self.check_interlock()
+        if not can_turn_on:
+            _LOGGER.warning("Interlock active: cannot turn on remote output '%s'", self._id)
+            return False
+
         if not self._resolve_device_manager():
             _LOGGER.error("Remote output '%s' has no device manager, cannot turn on", self._id)
             return False
@@ -211,6 +286,7 @@ class RemoteOutputBase:
             self._state = ON
             self._last_timestamp = timestamp or time.time()
             self._emit_state_event()
+            self._execute_momentary_turn(ON)
             _LOGGER.debug("Remote output '%s' turned ON", self._id)
         else:
             _LOGGER.warning("Failed to turn ON remote output '%s'", self._id)
@@ -219,6 +295,8 @@ class RemoteOutputBase:
     async def async_turn_off(self, timestamp: float | None = None) -> None:
         """Turn off the remote output.
 
+        After successful OFF, schedules momentary auto-ON if configured.
+
         Args:
             timestamp: Optional timestamp for state tracking.
         """
@@ -234,6 +312,7 @@ class RemoteOutputBase:
             self._state = OFF
             self._last_timestamp = timestamp or time.time()
             self._emit_state_event()
+            self._execute_momentary_turn(OFF)
             _LOGGER.debug("Remote output '%s' turned OFF", self._id)
         else:
             _LOGGER.warning("Failed to turn OFF remote output '%s'", self._id)
@@ -259,6 +338,10 @@ class RemoteOutputBase:
         Called by ESPHomeDeviceManager when it receives a state update
         for this output's entity.
 
+        If ``enforce_interlock`` is enabled and the output was turned ON
+        externally while violating an interlock, boneIO will immediately
+        send a turn-off command.
+
         Args:
             new_state: ``True`` if the output is now ON.
             brightness: Optional brightness value (0-255) for dimmable lights.
@@ -281,6 +364,15 @@ class RemoteOutputBase:
             self._brightness,
         )
 
+        # Enforce interlock: if turned ON externally and violating interlock,
+        # immediately send OFF command to the remote device.
+        if new_state and self._enforce_interlock and not self.check_interlock():
+            _LOGGER.warning(
+                "Remote output '%s' turned ON externally, violating interlock — forcing OFF",
+                self._id,
+            )
+            asyncio.ensure_future(self._enforce_interlock_off())
+
     async def async_set_brightness(self, brightness: int, timestamp: float | None = None) -> None:
         """Set brightness on the remote light output.
 
@@ -386,9 +478,138 @@ class RemoteOutputBase:
             area=self.area,
             remote=True,
             brightness=self._brightness,
+            interlock_groups=self._interlock_groups,
         )
         self._event_bus.trigger_event(OutputEvent(entity_id=self._id, state=output_state))
 
+    # ------------------------------------------------------------------
+    # Momentary actions (auto-off / auto-on after delay)
+    # ------------------------------------------------------------------
+
+    def _execute_momentary_turn(self, momentary_type: str) -> None:
+        """Schedule momentary action (auto-off after ON, or auto-on after OFF).
+
+        If adjustable_duration is enabled and this is a turn-ON action,
+        the slider value is used instead of the static momentary_turn_on.
+
+        Args:
+            momentary_type: ON or OFF.
+        """
+        if self._loop is None:
+            try:
+                self._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                return
+
+        if self._momentary_action:
+            _LOGGER.debug("Cancelling momentary action for %s", self._name)
+            self._momentary_action()
+
+        if momentary_type == ON:
+            action = self.async_turn_off
+            if self._adjustable_duration_enabled:
+                delayed_action = TimePeriod(seconds=self._adjustable_duration)
+            else:
+                delayed_action = self._momentary_turn_on
+        else:
+            action = self.async_turn_on
+            delayed_action = self._momentary_turn_off
+
+        if delayed_action:
+            _LOGGER.debug(
+                "Scheduling momentary action for %s in %s",
+                self._name,
+                delayed_action.as_timedelta,
+            )
+            self._momentary_action = async_track_point_in_time(
+                loop=self._loop,
+                job=self._momentary_callback,
+                point_in_time=utcnow() + delayed_action.as_timedelta,
+                action=action,
+            )
+
+    @callback
+    async def _momentary_callback(self, timestamp: float, action: Any) -> None:
+        """Execute the scheduled momentary turn-on or turn-off."""
+        _LOGGER.info("Momentary callback at %s for remote output %s", timestamp, self._name)
+        await action(timestamp=timestamp)
+        self._momentary_action = None
+
+    # -- Adjustable duration -------------------------------------------------
+
+    @property
+    def adjustable_duration_enabled(self) -> bool:
+        """Whether this output has an adjustable duration (HA number entity)."""
+        return self._adjustable_duration_enabled
+
+    @property
+    def adjustable_duration(self) -> float:
+        """Current adjustable duration value in seconds."""
+        return self._adjustable_duration
+
+    @property
+    def duration_min(self) -> float:
+        """Minimum duration in seconds for HA slider."""
+        return self._duration_min
+
+    @property
+    def duration_max(self) -> float:
+        """Maximum duration in seconds for HA slider."""
+        return self._duration_max
+
+    @property
+    def duration_unit(self) -> str:
+        """Unit of measurement for HA number entity ('s' or 'min')."""
+        return self._duration_unit
+
+    def set_adjustable_duration(self, seconds: float) -> None:
+        """Set the adjustable duration value.
+
+        Clamps to [duration_min, duration_max].
+
+        Args:
+            seconds: New duration in seconds.
+        """
+        self._adjustable_duration = max(self._duration_min, min(self._duration_max, seconds))
+        _LOGGER.debug(
+            "Remote output '%s' adjustable duration set to %.1fs",
+            self.id,
+            self._adjustable_duration,
+        )
+
+    def restore_adjustable_duration(self, seconds: float) -> None:
+        """Restore persisted duration value.
+
+        Args:
+            seconds: Persisted duration value.
+        """
+        self._adjustable_duration = max(self._duration_min, min(self._duration_max, seconds))
+
+    async def _enforce_interlock_off(self) -> None:
+        """Send OFF command to remote device after interlock violation.
+
+        Called when the remote device reports ON state that violates an
+        active interlock group. Small delay allows the state to settle.
+        """
+        await asyncio.sleep(0.1)  # Allow state to settle
+        if not self._resolve_device_manager():
+            _LOGGER.error(
+                "Cannot enforce interlock OFF on '%s': no device manager",
+                self._id,
+            )
+            return
+        success = await self._device_manager.control_output(
+            output_id=self._output_id,
+            action="OFF",
+        )
+        if success:
+            _LOGGER.info("Interlock enforced: remote output '%s' turned OFF", self._id)
+        else:
+            _LOGGER.error(
+                "Failed to enforce interlock OFF on remote output '%s'",
+                self._id,
+            )
+
     # ------------------------------------------------------------------
     # Properties (duck-type compatible with BasicOutput)
     # ------------------------------------------------------------------

{boneio-1.4.0.dev3 → boneio-1.4.0.dev5}/boneio/core/manager/irrigation.py

@@ -11,11 +11,13 @@ from boneio.const import NEXT_VALVE, ON, PAUSE, RESUME
 from boneio.core.utils.timeperiod import parse_time_to_seconds
 from boneio.integration.homeassistant import (
     ha_irrigation_button_message,
+    ha_irrigation_event_message,
     ha_irrigation_main_switch_message,
     ha_irrigation_number_message,
     ha_irrigation_select_message,
     ha_irrigation_switch_message,
     ha_irrigation_timestamp_sensor_message,
+    ha_irrigation_valve_message,
 )
 
 if TYPE_CHECKING:
@@ -90,6 +92,7 @@ class IrrigationManager:
             repeat=int(cfg.get("repeat", 0)),
             auto_advance=bool(cfg.get("auto_advance", True)),
             reverse=bool(cfg.get("reverse", False)),
+            pause_timeout_s=int(parse_time_to_seconds(cfg.get("pause_timeout"), 1800)),
         )
 
     def _build_zone(self, zone_cfg: dict[str, Any]) -> IrrigationZone | None:
@@ -280,9 +283,10 @@ class IrrigationManager:
             (f"{ctrl.id}_next_valve", "button"),
             (f"{ctrl.id}_pause", "button"),
             (f"{ctrl.id}_resume", "button"),
+            (f"{ctrl.id}_event", "event"),
         ]
         for zone in ctrl.zones:
-            discovery_ids.append((f"{ctrl.id}_zone_{zone.id}", "switch"))
+            discovery_ids.append((f"{ctrl.id}_zone_{zone.id}", "valve"))
             discovery_ids.append((f"{ctrl.id}_zone_{zone.id}_enabled", "switch"))
             discovery_ids.append((f"{ctrl.id}_zone_{zone.id}_duration", "number"))
         for idx in range(len(ctrl._schedule)):
@@ -506,10 +510,16 @@ class IrrigationManager:
         )
 
         for zone in ctrl.zones:
+            # Remove stale switch discovery (migration from switch → valve)
             self._manager.publish_ha_discovery(
                 id=f"{ctrl.id}_zone_{zone.id}",
                 ha_type="switch",
-                payload=ha_irrigation_switch_message(
+                payload="",
+            )
+            self._manager.publish_ha_discovery(
+                id=f"{ctrl.id}_zone_{zone.id}",
+                ha_type="valve",
+                payload=ha_irrigation_valve_message(
                     ctrl.id,
                     ctrl.name,
                     suffix=f"zone/{zone.id}",
@@ -584,3 +594,14 @@ class IrrigationManager:
                     config_helper=cfg,
                 ),
             )
+
+        # Event entity — fires on interlock faults, cycle completions, etc.
+        self._manager.publish_ha_discovery(
+            id=f"{ctrl.id}_event",
+            ha_type="event",
+            payload=ha_irrigation_event_message(
+                ctrl.id,
+                ctrl.name,
+                config_helper=cfg,
+            ),
+        )