fix: keep anti-wrinkle alive-then-close it when the power sensor goes silent

The anti-wrinkle idle-timeout (anti_wrinkle_idle_timeout) and the 2 h
safety cap both live in the detector and only advance from within
process_reading, so they need incoming readings to fire. A
publish-on-change power sensor goes completely silent once power
flatlines at standby / 0 W after the last tumble pulse, which freezes
the idle timer mid-count and pins the state in anti_wrinkle until the
next real reading (typically the next cycle).

The manager watchdog injects synthetic 0 W keepalives to advance the
accumulator during silence, but its state guard excluded
STATE_ANTI_WRINKLE, so it never fed that state. Add a dedicated
anti-wrinkle branch that injects a 0 W keepalive once the sensor has
been silent longer than off_delay, so the detector's own idle-timeout
(or the 2 h safety cap) elapses on schedule and the tail closes into
OFF instead of showing anti-wrinkle for hours after the appliance
physically finished.

The synthetic keepalive bumps _last_reading_time, which is also the
sampling-throttle clock in _async_power_changed. A real tumble pulse
(>= min_power, therefore not is_low_power) arriving within one sampling
interval of a keepalive would be discarded by that throttle before
reaching the detector, so it could not reset the idle timer. Exempt
high-power readings from the throttle while in anti_wrinkle; sub-min
baseline readings stay throttled as before.

Adds tests/test_anti_wrinkle_watchdog_keepalive.py: watchdog injection
during anti-wrinkle silence, no injection before off_delay, no-op before
first reading, end-to-end close into OFF under injected keepalives, a
pulse resets the idle timer, the throttle bypass for real pulses, and
that RUNNING high readings / anti-wrinkle baselines are still throttled.

Closes #339

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: sharkyy

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Notifications to `notify.*` entity targets no longer crash with "extra keys not allowed"** (`manager.py`): When a notify target was configured as a `notify.*` entity (e.g. `notify.mobile_app_phone`), WashData routed the call through HA's newer `notify.send_message` entity service, which only accepts `message`, `title`, and `entity_id`. Mobile-app enrichment keys (tag, channel, priority, iOS Live Activity fields, icon, progress) were still bundled into a `data` sub-dict and appended to that call, causing a voluptuous schema rejection (`extra keys not allowed @ data['data']`) and a "Task exception was never retrieved" error in the HA log -- meaning the notification was silently dropped. When `svc_data` is non-empty the call now falls through to the legacy `notify.mobile_app_*` domain service, which uses `NOTIFY_SERVICE_SCHEMA` and accepts `data: dict`, so all enrichment keys arrive correctly.
 
+- **Anti-wrinkle no longer stays stuck forever when the power sensor goes silent** ([#339](https://github.com/3dg1luk43/ha_washdata/issues/339)) (`manager.py`): The anti-wrinkle idle-timeout (`anti_wrinkle_idle_timeout`) and the 2-hour safety cap both live inside the detector and only advance from within `process_reading`, so they need incoming power readings to fire. A publish-on-change power sensor (most Zigbee/WiFi smart plugs) stops emitting updates entirely once power flatlines at standby / 0 W after the last tumble pulse — which freezes the idle timer partway through its count and pins the state in `anti_wrinkle` until the next real reading, typically the start of the *following* cycle. The manager watchdog, which injects synthetic 0 W keepalives to advance the accumulator during silence, excluded `anti_wrinkle` from its state guard and so never fed it. The watchdog now injects a 0 W keepalive during `anti_wrinkle` once the sensor has been silent longer than `off_delay`, so the detector's own idle-timeout (or the 2-hour safety cap) elapses on schedule and the tail closes cleanly into OFF instead of the state showing "anti-wrinkle" for hours after the dryer has physically finished. Injecting 0 W (rather than the last standby draw) matches the existing low-power keepalive path and is safe: a steady sub-pulse baseline carries no tumble activity, so it correctly counts toward the idle timeout, while a real tumble pulse resets it as before. The synthetic keepalive shares the sampling-throttle clock (`_last_reading_time`), so a real tumble pulse (`>= min_power`) arriving within one sampling interval of a keepalive is now explicitly exempted from that throttle while in `anti_wrinkle` — otherwise the pulse would have been discarded before reaching the detector and could not reset the idle timer.
+
 ## 0.5.3 - 2026-07-26
 
 ### Features

custom_components/ha_washdata/manager.py

@@ -2859,8 +2859,21 @@ def _async_power_changed(self, event: Any) -> None:
             or prev_raw_power >= min_p  # genuine drop from active power
         )
 
+        # Anti-wrinkle tumble pulses must always reach the detector so they can
+        # reset the idle timer. In anti_wrinkle the watchdog injects synthetic 0 W
+        # keepalives (see _watchdog_check_stuck_cycle) whose timestamp bumps
+        # _last_reading_time — the very clock this throttle uses. Without this
+        # bypass a real pulse (>= min_power, so not is_low_power) arriving within
+        # _sampling_interval of a keepalive would be discarded, defeating the reset
+        # and letting the mode time out mid-tumble. Pulses are sparse and brief, so
+        # exempting them here cannot flood the detector.
+        is_anti_wrinkle_pulse = (
+            self.detector.state == STATE_ANTI_WRINKLE and power >= min_p
+        )
+
         if (
             not is_low_power
+            and not is_anti_wrinkle_pulse
             and self._last_reading_time
             and (now - self._last_reading_time).total_seconds() < self._sampling_interval
         ):
@@ -3223,6 +3236,40 @@ def _power_off_timer_check(self) -> None:
 
     async def _watchdog_check_stuck_cycle(self, now: datetime) -> None:
         """Watchdog: check if cycle is stuck (no updates for too long)."""
+        # ANTI_WRINKLE keepalive. The anti-wrinkle idle-timeout
+        # (anti_wrinkle_idle_timeout) and the 2 h safety cap both live inside the
+        # detector and only advance from within process_reading, so they need
+        # incoming readings to fire. A publish-on-change power sensor goes
+        # completely silent once power flatlines at standby / 0 W after the last
+        # tumble pulse - which freezes the idle timer mid-count and pins the
+        # state in anti_wrinkle until the next real reading (typically the start
+        # of the following cycle). The main state guard below excludes
+        # ANTI_WRINKLE, so without this branch no keepalive is ever injected and
+        # the mode never closes on its own. Inject a 0 W keepalive on silence so
+        # the detector's own idle-timeout / safety cap advances and the tail
+        # closes into OFF on schedule. Injecting 0 W (rather than the last known
+        # standby draw) is consistent with the low-power keepalive path below and
+        # is safe: a steady sub-pulse baseline carries no tumble activity, so it
+        # should count toward the idle timeout.
+        if self.detector.state == STATE_ANTI_WRINKLE:
+            if not self._last_reading_time:
+                return
+            time_since_any_update = (now - self._last_reading_time).total_seconds()
+            if time_since_any_update > self._config.off_delay:
+                self._logger.debug(
+                    "Watchdog: Anti-wrinkle silence (%.0fs > off_delay %ds). "
+                    "Injecting 0W keepalive to advance the idle timer.",
+                    time_since_any_update,
+                    self._config.off_delay,
+                )
+                self.detector.process_reading(0.0, now)
+                # Reset only the 'any-update' clock so the next keepalive is one
+                # off_delay away; leave _last_real_reading_time untouched.
+                self._last_reading_time = now
+                self._current_power = 0.0
+                self._notify_update()
+            return
+
         if self.detector.state not in (STATE_RUNNING, STATE_STARTING, STATE_PAUSED, STATE_ENDING):
             return