fix: v2.9.2 — armed night window disarms past its stop condition (no phantom daylight session / 1h freeze) + Solar Surplus brand-disconnect gate

Incident 2026-07-21: window armed at 00:01 with no EV connected stayed
'active' via hysteresis all day; the 08:13 plug-in launched a daylight
battery session killed 3s later, latching completed_today + 1h cooldown
and freezing Solar Surplus under full sun. The armed-but-idle window now
disarms to 'ready' (no latch, no cooldown) once sunrise/deadline/PV
handoff has passed. Solar Surplus plug gate now uses
is_disconnected_status() so OCPP 'available' skips the tick (was a
125-tick 20A start loop against an empty plug). +6 regression tests,
suite 284 passed / 0 failed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Antonio ...

CLAUDE.md

@@ -757,6 +757,63 @@ async def _set_amperage(self, target_amperage: int):
 
 ## Version History
 
+### v2.9.2 (2026-07-21)
+**FIX: Armed night window without a session survives past sunrise → phantom daylight session + 1h freeze; Solar Surplus 'available' start loop**
+
+Root-caused from a maintainer's live incident log (2026-07-21, non-Tuya wallbox,
+OCPP vocabulary). Chain of events: the night window armed `_session_state =
+"active"` at 00:01 with **no EV connected**; the v2.9.1 connect gate correctly
+rejected `available` every tick, but the hysteresis in `_is_in_active_window`
+kept the state armed all night and past sunrise (03:37). When the car was
+plugged in at **08:13**, the connect gate passed, the armed state bypassed any
+window re-check, and a **battery session started in broad daylight** (with a
+start notification). Three seconds later the periodic check detected "past stop
+condition", stopped it terminally → `completed_today` + **1-hour cooldown** —
+which also blocked Solar Surplus ("respecting cooldown period") with full sun
+and ~12 A of surplus available. Net effect: notification of charge start, then
+nothing for an hour.
+
+**Fix A — armed-window disarm ([night_smart_charge.py](custom_components/ev_smart_charger/night_smart_charge.py), STEP 2 of `_is_in_active_window`).**
+When the state is `"active"` but **no session is running** (`is_active()` is
+False), the check now consults `_should_stop_for_deadline()`: if the window's
+own stop condition (sunrise on car_ready=OFF, deadline/target on car_ready=ON,
+PV handoff when enabled) has passed, the state disarms back to `"ready"` —
+deliberately **without** the `completed_today` latch and **without** the
+cooldown, because no session ever ran and there is nothing to anti-loop
+against. Control then falls through to the normal STEP 3 window computation
+(False past the stop condition), so a morning plug-in is handled by Solar
+Surplus. A genuinely running session keeps the legacy hysteresis byte-for-byte
+(its stop conditions are enforced by the monitors / periodic check, which run
+first). On car_ready=ON days the armed state intentionally survives past
+sunrise until the deadline — that is the "car ready by deadline" semantics.
+
+**Fix B — Solar Surplus disconnect gate ([solar_surplus.py](custom_components/ev_smart_charger/solar_surplus.py), Section 7).**
+The same incident log showed a **125-tick loop** (05:38–07:46) of "Starting
+charger with 20A" battery support against an **empty plug**: the plug gate
+compared the status against the literal `charger_free` only, so `available`
+passed as "connected". This was the call site deliberately left untouched in
+v2.9.1 ("no observed defect") — the defect is now observed. The gate uses the
+centralized `is_disconnected_status()` classifier; unknown strings still
+default to "connected" (safe failure mode), Tuya installs unchanged.
+
+**Files**: `night_smart_charge.py` (STEP 2 guard), `solar_surplus.py` (gate +
+import), `const.py` + `manifest.json` (VERSION), `README.md`, this file;
+tests: `tests/test_night_smart_charge.py` (+4: disarm past stop condition
+with no latch/cooldown, hysteresis kept before stop, running session never
+disarms via window check, end-to-end late-arrival-past-sunrise starts no
+phantom session), `tests/test_solar_surplus.py` (+2: `available` skips the
+tick, `charger_free` regression). `VERSION = "2.9.2"`. Full suite green:
+**284 passed / 0 failed**.
+
+**Upgrade priority**: 🔴 STRONGLY RECOMMENDED for non-Tuya wallboxes using
+Night Smart Charge (completes the v2.9.0/v2.9.1 series — without it a morning
+plug-in can freeze all charging for an hour). ⚪ Low impact for Tuya installs
+(the phantom-session path required a brand `available` status, but the
+armed-window disarm also protects Tuya setups where the car is plugged in
+after sunrise).
+
+---
+
 ### v2.9.1 (2026-07-19)
 **FIX: Brand-vocabulary status classifiers — 'available' no longer passes as "connected", 'charged' recognized as charge-complete**
 

README.md

@@ -58,6 +58,8 @@ Most projects target one charger brand or assume a single-phase home. EV Smart C
 
 > **📱 New in v2.7.3+** — EV charging **Live Activities / Live Updates** for the Home Assistant Companion app. When enabled from **Dashboard → Settings → Notifications**, the integration keeps a single `evsc_ev_charging` activity updated for Boost Charge, Night Smart Charge, Solar Surplus, Force Charge, and normal charging detected by the shared `charging_power` / charger-status SSOT. Updates are throttled to protect the iOS push budget and the activity closes only after charging has stopped for two monitor ticks. **Default: OFF**.
 
+> **🌅 New in v2.9.2** — **armed-night-window disarm + Solar Surplus disconnect gate**. Two fixes from a live incident (2026-07-21): (1) a Night Smart Charge window armed at its scheduled time with **no EV connected** stayed "active" all day via hysteresis — a morning plug-in then launched a phantom daylight battery session that was killed 3 seconds later, latching `completed_today` + the 1-hour cooldown and **freezing Solar Surplus with full sun available**. The armed-but-idle window now disarms cleanly (back to `ready`, no completion latch, no cooldown) once its own stop condition — sunrise, deadline, or PV handoff — has passed, so a morning plug-in is handled by Solar Surplus as it should be. A genuinely running session keeps the legacy hysteresis untouched. (2) Solar Surplus's plug gate now uses the v2.9.1 `is_disconnected_status()` classifier, so OCPP `available` (= no EV connected) skips the tick like `charger_free` instead of driving an endless battery-support start loop against an empty plug.
+
 > **🔌 New in v2.9.1** — **brand-vocabulary status classifiers**. "Is the cable disconnected?" and "has the charge completed?" are now answered by two centralized, case-insensitive classifiers in `power_model.py` (`is_disconnected_status` / `is_charge_complete_status`) instead of exact Tuya-string comparisons. This fixes the remaining v2.9.0 blind spot: on wallboxes reporting OCPP-style statuses (`available` = no EV connected, `charged` = session done), Night Smart Charge could start a session **with no car plugged** (the connect gate only rejected `charger_free`) and the plug-in *late-arrival* detection never fired (it compared against `charger_free` exactly). The classifiers are conservative allowlists of unambiguous synonyms — an unknown brand string still defaults to "connected", so no existing setup can lose night charging. Applied to the night-charge connect gates, late-arrival detection, and the grid-monitor lifecycle stops; `power_model.is_charging` / `is_plugged_in` now share the same vocabulary.
 
 > **🛠️ New in v2.9.0** — two Night Smart Charge reliability fixes. **(1)** The grid-mode monitor no longer terminates a session because your wallbox reports a brand-specific status string: the old check accepted only the Tuya vocabulary (`charger_charging` / `charger_wait`), so a wallbox reporting e.g. `charging` had its grid session killed ~15 s after the battery→grid fallback — leaving the EV under target for the rest of the night. The check is now the same tolerant blocklist used everywhere since v2.2.0 (only the explicit `charger_free` / `charger_end` lifecycle statuses stop the session; the measured-power blind-spot check keeps protecting against a genuinely idle charger). **(2)** Changing **today's** EV SOC target or turning on **today's** *car ready* switch after a session already ended now **re-arms Night Smart Charge**: the "completed today" latch (and its 1-hour cooldown) is cleared and the session restarts within a minute if the night window is still open. Previously those changes were silently ignored until the next day. **STRONGLY RECOMMENDED for non-Tuya wallboxes.**

custom_components/ev_smart_charger/const.py

@@ -2,7 +2,7 @@
 
 # ========== INTEGRATION METADATA ==========
 DOMAIN = "ev_smart_charger"
-VERSION = "2.9.1"
+VERSION = "2.9.2"
 DEFAULT_NAME = "EV Smart Charger"
 FRONTEND_URL_BASE = "/api/ev_smart_charger/frontend"
 FRONTEND_CARD_FILENAME = "ev-smart-charger-dashboard.js"

custom_components/ev_smart_charger/manifest.json

@@ -11,5 +11,5 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",
   "requirements": [],
-  "version": "2.9.1"
+  "version": "2.9.2"
 }

custom_components/ev_smart_charger/night_smart_charge.py

@@ -917,8 +917,36 @@ async def _is_in_active_window(self, now: datetime) -> bool:
 
         # === STEP 2: Hysteresis - stay active once activated ===
         if self._session_state == "active":
-            self.logger.debug("Already active - maintaining state (hysteresis)")
-            return True
+            # v2.9.2: an ARMED window with NO running session must not survive
+            # past its own stop conditions. Before this guard, a window armed
+            # at 00:01 with no EV connected stayed "active" all day via
+            # hysteresis; a morning plug-in (2026-07-21 incident, 08:13) then
+            # launched a battery session in broad daylight that the periodic
+            # check killed 3 seconds later — latching completed_today + the
+            # 1-hour cooldown, which also froze Solar Surplus with full sun
+            # available. Disarming back to "ready" (NOT completed_today: no
+            # session ever ran, there is nothing to anti-loop against) lets
+            # STEP 3 re-evaluate the real window, which is False past the stop
+            # condition, so the plug-in is handled by Solar Surplus instead.
+            # A genuinely RUNNING session keeps the legacy hysteresis — its
+            # stop conditions are enforced by the monitors / periodic check.
+            if not self.is_active():
+                should_stop, stop_reason = await self._should_stop_for_deadline(now)
+                if should_stop:
+                    self.logger.info(
+                        "🔄 Armed window expired with no session started "
+                        f"({stop_reason}) - disarming without completion latch"
+                    )
+                    self._session_state = "ready"
+                    # Fall through to STEP 3: recompute the real window.
+                else:
+                    self.logger.debug(
+                        "Already active - maintaining state (hysteresis)"
+                    )
+                    return True
+            else:
+                self.logger.debug("Already active - maintaining state (hysteresis)")
+                return True
 
         # === STEP 3: Time range validation with grace period ===
         if not self._night_charge_time_entity:

custom_components/ev_smart_charger/solar_surplus.py

@@ -13,7 +13,6 @@
 from homeassistant.util import dt as dt_util
 
 from .const import (
-    CHARGER_STATUS_FREE,
     CONF_EV_CHARGER_STATUS,
     CONF_FV_PRODUCTION,
     CONF_HOME_CONSUMPTION,
@@ -51,7 +50,7 @@
     has_home_battery,
 )
 from .localization import translate_runtime
-from .power_model import ChargingModel
+from .power_model import ChargingModel, is_disconnected_status
 from .runtime import EVSCRuntimeData
 from .utils.logging_helper import EVSCLogger
 from .utils.notification_service import NotificationService
@@ -920,7 +919,14 @@ async def _async_periodic_check(self, now=None, ignore_rate_limit: bool = False)
                 self.logger.warning("Charger status unavailable")
                 return
 
-            if charger_status == CHARGER_STATUS_FREE:
+            # v2.9.2: brand-vocabulary aware (companion to v2.9.1). The exact
+            # CHARGER_STATUS_FREE comparison let OCPP 'available' (= no EV
+            # connected) pass as "connected": on 2026-07-21 Solar Surplus ran a
+            # 125-tick battery-support start loop (05:38-07:46) against an
+            # empty plug. is_disconnected_status() covers 'charger_free' plus
+            # the unambiguous disconnected synonyms; unknown strings still
+            # default to "connected" (safe failure mode, unchanged).
+            if is_disconnected_status(charger_status):
                 if self._hybrid_mode is not None:
                     await self._hybrid_mode.async_force_exit("Charger disconnected")
                 if self._has_control():

tests/test_night_smart_charge.py

@@ -1436,3 +1436,104 @@ async def test_late_arrival_ignores_connected_to_connected_transition(
     await night_charge._async_charger_status_changed(event)
 
     night_charge._evaluate_and_charge.assert_not_awaited()
+
+
+# ============================================================================
+# v2.9.2: Armed-window-without-session disarm (2026-07-21 incident)
+# ============================================================================
+
+async def test_armed_window_without_session_disarms_past_stop_condition(
+    hass, night_charge
+):
+    """v2.9.2: a window armed with NO running session must disarm once its
+    stop condition (sunrise/deadline) has passed — back to 'ready', with NO
+    completed_today latch and NO cooldown. Regression for the 2026-07-21
+    incident: state stayed 'active' via hysteresis all night with no EV
+    connected, so the 08:13 plug-in launched a daylight battery session."""
+    now = dt_util.now()
+    night_charge._session_state = "active"
+    assert night_charge.is_active() is False  # no session running
+    night_charge._should_stop_for_deadline = AsyncMock(
+        return_value=(True, "Sunrise reached (car not needed urgently)")
+    )
+    # Past-window geometry: scheduled 7h ago, sunrise 4h ago.
+    night_charge._get_scheduled_time_for_today = MagicMock(
+        return_value=now - timedelta(hours=7)
+    )
+    night_charge._astral_service.get_next_sunrise_after = MagicMock(
+        return_value=now - timedelta(hours=4)
+    )
+
+    result = await night_charge._is_in_active_window(now)
+
+    assert result is False
+    assert night_charge._session_state == "ready"
+    assert night_charge._last_completion_date is None  # no completion latch
+    assert night_charge._last_completion_time is None  # no cooldown armed
+
+
+async def test_armed_window_without_session_keeps_hysteresis_before_stop(
+    hass, night_charge
+):
+    """Before the stop condition, the armed window keeps legacy hysteresis."""
+    now = dt_util.now()
+    night_charge._session_state = "active"
+    night_charge._should_stop_for_deadline = AsyncMock(return_value=(False, ""))
+
+    result = await night_charge._is_in_active_window(now)
+
+    assert result is True
+    assert night_charge._session_state == "active"
+
+
+async def test_armed_window_with_running_session_keeps_hysteresis(
+    hass, night_charge
+):
+    """A genuinely RUNNING session never disarms via the window check — its
+    stop conditions are enforced by the monitors / periodic check."""
+    now = dt_util.now()
+    night_charge._session_state = "active"
+    night_charge._night_charge_active = True
+    night_charge._active_mode = NIGHT_CHARGE_MODE_BATTERY
+    night_charge._should_stop_for_deadline = AsyncMock(
+        return_value=(True, "Sunrise reached")
+    )
+
+    result = await night_charge._is_in_active_window(now)
+
+    assert result is True
+    assert night_charge._session_state == "active"
+    night_charge._should_stop_for_deadline.assert_not_awaited()
+
+
+async def test_late_arrival_past_sunrise_does_not_start_phantom_session(
+    hass, night_charge
+):
+    """v2.9.2 end-to-end regression for 2026-07-21: plug-in at 08:13 with the
+    window still armed from 00:01 must NOT start a session (no notification,
+    no completed_today, no cooldown) — Solar Surplus handles the morning."""
+    now = dt_util.now()
+    night_charge._boost_charge = None
+    night_charge._session_state = "active"  # armed since 00:01, no session
+    night_charge._should_stop_for_deadline = AsyncMock(
+        return_value=(True, "Sunrise reached (car not needed urgently)")
+    )
+    night_charge._get_scheduled_time_for_today = MagicMock(
+        return_value=now - timedelta(hours=7)
+    )
+    night_charge._astral_service.get_next_sunrise_after = MagicMock(
+        return_value=now - timedelta(hours=4)
+    )
+    night_charge._evaluate_and_charge = AsyncMock()
+
+    event = MagicMock()
+    event.data = {
+        "old_state": MagicMock(state="available"),
+        "new_state": MagicMock(state="charging"),
+    }
+    await night_charge._async_charger_status_changed(event)
+
+    night_charge._evaluate_and_charge.assert_not_awaited()
+    night_charge.charger_controller.start_charger.assert_not_called()
+    assert night_charge._session_state == "ready"
+    assert night_charge._last_completion_date is None

tests/test_solar_surplus.py

@@ -703,3 +703,36 @@ async def test_sensor_error_counter_resets_on_recovery(hass, automation):
     await automation._async_periodic_check(ignore_rate_limit=True)
 
     assert automation._sensor_error_consecutive == 0
+
+
+async def test_periodic_check_skips_on_brand_disconnected_status(hass, automation):
+    """v2.9.2: OCPP 'available' (= no EV connected) must skip the tick like
+    'charger_free'. Regression for 2026-07-21: the exact-match gate let
+    'available' pass as connected, producing a 125-tick battery-support
+    start loop (05:38-07:46) against an empty plug."""
+    hass.states.async_set("switch.force", "off")
+    hass.states.async_set("select.profile", "solar_surplus")
+    hass.states.async_set("sensor.charger_status", "available")
+
+    automation.priority_balancer.is_enabled.return_value = True
+    automation._has_control = MagicMock(return_value=False)
+
+    await automation._async_periodic_check()
+
+    automation.charger_controller.start_charger.assert_not_called()
+    automation.charger_controller.set_amperage.assert_not_called()
+
+
+async def test_periodic_check_still_skips_on_charger_free(hass, automation):
+    """Tuya vocabulary unchanged: 'charger_free' still skips the tick."""
+    hass.states.async_set("switch.force", "off")
+    hass.states.async_set("select.profile", "solar_surplus")
+    hass.states.async_set("sensor.charger_status", CHARGER_STATUS_FREE)
+
+    automation.priority_balancer.is_enabled.return_value = True
+    automation._has_control = MagicMock(return_value=False)
+
+    await automation._async_periodic_check()
+
+    automation.charger_controller.start_charger.assert_not_called()
+    automation.charger_controller.set_amperage.assert_not_called()