@@ -756,6 +756,44 @@ async def _set_amperage(self, target_amperage: int):
 
 ## Version History
 
+### v2.2.0 (2026-06-01)
+**FEATURE: Measured charging power as the charging-state SSOT (with legacy status fallback)**
+
+**Problem**: "is the EV charging right now?" was answered by three incompatible proxies — `ChargerController.is_charging()` (commanded switch echo), `get_current_amperage()` (a setpoint, not a measurement), and the textual `CONF_EV_CHARGER_STATUS` string (`charger_charging`), which varies per wallbox. None detect a wallbox that reports `charger_charging` while drawing **0 W** (curtailment, EV paused at 100%, BMS throttle). This was also the root cause of the dashboard's green "EV charging" banner failing to appear: it used an exact `=== "charger_charging"` match that fails on any other brand string.
+
+**Solution**: **measured phase charging power (W)** becomes the single source of truth for `drawing_now`. Single-phase = 1 optional sensor; three-phase = 3 sensors summed. The textual status sensor becomes a **fallback only**. Surfaced through one new reader on the already-shared `ChargingModel` (`power_model.py`, stored on `runtime_data.power_model`), so every consumer reaches the same instantaneous truth.
+
+**Sacred invariant — byte-for-byte backward compat**: existing installs (status mapped, no power sensor) take the fallback path → zero behaviour change, no migration, entity counts unchanged (66 / 52). `read_charging_power` returns `None` when unconfigured → the controller answers from the switch echo exactly as v2.1.x. The regression guard `test_is_charging_no_power_sensor_uses_switch_echo` locks this.
+
+**SSOT API** ([power_model.py](custom_components/ev_smart_charger/power_model.py)): `read_charging_power(hass)` (summed W, **all-or-nothing** in three-phase: any unreadable mapped phase → `None`; clamped `max(0, …)` so a reversed-sign sensor reads a flat 0 W; **unit-normalized kW→W** by `unit_of_measurement` so a kW wallbox sensor agrees with the W floor and the frontend), `is_charging(hass)` (stateless: `power > CHARGING_POWER_DRAWING_FLOOR_W` → else a **tolerant status blocklist** matching the frontend → else False), `is_plugged_in(hass)`. New constants `CHARGING_POWER_DRAWING_FLOOR_W = 200`, `CHARGING_POWER_GRACE_SECONDS = 15`, `NIGHT_GRID_DRAW_START_GRACE_SECONDS = 90`.
+
+**Controller** ([charger_controller.py](custom_components/ev_smart_charger/charger_controller.py)): `_refresh_state` caches `_measured_power_w` **for the operation diagnostic only**. After code review, all controller *control* decisions stay strictly on the commanded switch echo / setpoint (byte-for-byte v2.1.x) — the earlier `_drawing_now_graced()` wiring into the Tuya decrease gate and `recover_to_target` was reverted because a single sub-floor measured glitch could (a) skip the safe Tuya stop/set/start decrease and change current live mid-charge, or (b) restart the charger from scratch on a transient dip. `is_charging()` is unchanged (commanded-on); the measured `drawing_now` is surfaced in the diagnostic via `power_model.is_charging`.
+
+**Config flow**: `CONF_CHARGING_POWER` / `_L2` / `_L3` added as `vol.Optional` to the phase-aware sensors step; `CONF_EV_CHARGER_STATUS` changed Required → **Optional** (kept forever as fallback, never locked). No `async_migrate_entry`, `ConfigFlow.VERSION` stays 1, step counts unchanged (10/9/9). A companion **None-guard** was added to every status reader/subscriber (`night_smart_charge`, `solar_surplus`, `boost_charge`, `automations`) so optional status never crashes setup.
+
+**The one control change** ([night_smart_charge.py](custom_components/ev_smart_charger/night_smart_charge.py) grid monitor Check 2): with a power sensor, the grid-mode session ends on (a) an explicit not-charging **lifecycle** status (free/end — immediate, preserved from v2.1.x), or (b) the **blind-spot** stop — status insists `charger_charging` but measured power stays below the floor for `CHARGING_POWER_GRACE_SECONDS` (debounced; `charger_wait` is treated as the transitional decrease and never debounces). Two code-review hardenings: a **startup ramp grace** (`NIGHT_GRID_DRAW_START_GRACE_SECONDS = 90`) suppresses the blind-spot stop right after the session starts, so a slow-to-draw EV (cold battery, scheduled charging, contactor delay) is not killed ~30 s in; and the debounce clock is **cleared when the power sensor goes unavailable** so a stale timestamp can't fire a premature stop on sensor recovery. No power sensor → byte-for-byte legacy status check. Seven unit tests cover blind-spot stop, debounce wait, keep-charging, lifecycle-survives-noisy-power, legacy fallback, startup-ramp grace, and stale-clock-clear.
+
+**Diagnostic**: Solar Surplus attaches `charging_power_w` / `charging_power_source` / `is_charging_basis` to every diagnostic event (no new entity), so a reversed-sign sensor shows a flat 0 W — the user's cue to apply a `| abs` template fix. The controller diagnostic also carries `measured_power_w` + `drawing_now` for traceability.
+
+**Dashboard**: `dashboard_manager` maps `charging_power_entity` (single) + `charging_power_entities` (per-phase array, whitelisted in `setConfig`). A single shared `_isDrawingNow()` (measured-W, unit-normalized, summed across phases → else a **tolerant status blocklist**, not exact-match) drives the hero banner, the SOC ring, and `_computeStructuralKey` (fixing the three-phase stale-banner case). The tolerant fallback fixes the green-banner symptom even for installs that never map a power sensor.
+
+**Deliberate refinements vs the design plan** (all reviewed):
+- The Smart Blocker does **not** get a new power rising-edge listener: its switch-ON listener already triggers it for power-only installs, and its block/allow decision depends on time/solar, not draw. **Known limitation**: a power-only install with no status sensor won't re-trigger the blocker when a car is plugged into an already-on switch (no switch event). Most power-sensor users keep their status sensor, so both listeners remain present.
+- `charger_controller.is_charging()` kept as commanded-on (not split); `is_plugged_in()` added but existing plug gates not refactored.
+
+**Code-review fixes (post-implementation, a 7-angle review of the diff)**:
+- **Controller reverted to commanded-only control** (see Controller above) — eliminates the live-current-change-on-Tuya-glitch and restart-on-transient-dip risks; `_measured_power_w` stays for diagnostics.
+- **Night-charge grid-stop hardened** with the startup ramp grace + stale-clock clear (see The one control change above).
+- **Power-only installs (power mapped, status unmapped) now work for Night Smart Charge**: the battery-start pre-check and the handover gate previously read the status string and rejected a `None` status as "not connected", so Night Charge never started without a status sensor. Both now proceed when no status sensor is mapped and let the power-based monitor stop a non-charging session. **Known limitation that remains**: plug-DISCONNECT handling (Solar Surplus releasing control / Hybrid Mode force-exit on `charger_free`) still needs the status sensor — measured 0 W cannot tell "paused" from "unplugged". Mapping the status sensor is recommended for full plug-lifecycle coverage.
+- **Backend/frontend SSOT alignment**: `power_model.is_charging`'s status fallback is now a tolerant blocklist (was exact `== charger_charging`), matching the frontend so a non-Tuya brand string ("Charging") reads identically on both sides.
+- **kW→W unit normalization in the backend reader** (was frontend-only) — a kW wallbox sensor would otherwise read ~3.7 < the 200 W floor and falsely report "not charging", killing real sessions.
+
+**Files**: `const.py`, `power_model.py`, `charger_controller.py`, `config_flow.py`, `night_smart_charge.py`, `solar_surplus.py`, `automations.py`, `dashboard_manager.py`, `frontend/ev-smart-charger-dashboard.js`, `manifest.json`, `strings.json` + `translations/{en,it,nl}.json`; tests: `test_power_model_and_charger_model.py`, `test_night_smart_charge.py` (+7), `test_config_flow.py` (+2). `VERSION = "2.2.0"`. Full suite green except the 19 pre-existing environment-only baseline failures (identical on clean master).
+
+**Upgrade priority**: 🟢 RECOMMENDED — map your wallbox's charging-power sensor (single-phase) or the three per-phase sensors (three-phase) via reconfigure to get a reliable charging-state SSOT and a working green banner. ⚪ NO-OP for everyone else — without a power sensor, behaviour is identical to v2.1.x (and the tolerant banner fallback still improves on the old exact-match). **Beta ask**: report wallbox brand, sign correctness (diagnostic `charging_power_w` should track real draw, not a flat 0), and three-phase tile match.
+
+---
+
 ### v2.1.1 (2026-06-01)
 **FIX: Tolerate user-disabled helper entities at startup ([issue #22](https://github.com/antbald/ha-ev-smart-charger/issues/22) — xion2000)**
 
 
@@ -398,10 +398,12 @@ Choose the display name used in the Home Assistant UI.
 |---|:---:|---|
 | Charger switch | Yes | `switch` |
 | Charging current control | Yes | `number`, `input_number`, `select`, `input_select` |
-| Charger status sensor | Yes | `sensor` |
+| Charger status sensor | No (v2.2.0) | `sensor` |
 
 The charger switch entity is used as the unique ID for the config entry. Adding the same charger twice is prevented automatically.
 
+**Charger status sensor (v2.2.0):** now optional. It is used as a *fallback* for charging detection when no charging-power sensor is mapped (see Step 3), and as the source of plug/idle/finished lifecycle. Mapping it is still recommended — it tells "plugged in but not charging" apart from "unplugged", which measured power alone cannot.
+
 ### Step 3 — Energy Sensors
 
 | Field | Required | Unit |
@@ -411,6 +413,9 @@ The charger switch entity is used as the unique ID for the config entry. Adding
 | Solar production | Yes | `W` |
 | Home consumption | Yes | `W` |
 | Grid import | Yes | `W` |
+| EV charging power (v2.2.0) | No | `W` |
+
+**EV charging power (v2.2.0):** the most reliable signal for whether the car is actually drawing current — when mapped it becomes the single source of truth for charging detection (and the dashboard's green "EV charging" banner), overriding the status string. In three-phase mode map all three per-phase sensors (they are summed) or leave all blank. The sensor must report positive watts while charging; if yours reports negative, wrap it in a template sensor (`{{ states('sensor.your_power') | float(0) | abs }}`) — the diagnostic sensor's `charging_power_w` will read a flat 0 W if the sign is reversed.
 
 ### Step 4 — PV Forecast
 
 
@@ -210,10 +210,16 @@ async def async_setup(self) -> None:
                 f"Using default values. Restart Home Assistant to create missing helper entities."
             )
 
-        # Listen for charger status changes (charger_free -> charger_charging)
-        self._unsub_status = async_track_state_change_event(
-            self.hass, charger_status_entity, self._async_charger_status_changed
-        )
+        # Listen for charger status changes (charger_free -> charger_charging).
+        # v2.2.0: CONF_EV_CHARGER_STATUS is optional — guard before subscribing.
+        # The switch-ON listener below remains the primary trigger; the power
+        # rising-edge listener (v2.2.0) is the SSOT trigger when a charging-power
+        # sensor is mapped. Stored for that wiring.
+        self._charger_status_entity = charger_status_entity
+        if charger_status_entity:
+            self._unsub_status = async_track_state_change_event(
+                self.hass, charger_status_entity, self._async_charger_status_changed
+            )
 
         # Listen for charger switch turning ON (off -> on)
         self._unsub_switch = async_track_state_change_event(
 
@@ -162,6 +162,10 @@ def __init__(
         self._last_operation_time: Optional[datetime] = None
         self._current_amperage: Optional[int] = None
         self._is_on: Optional[bool] = None
+        # v2.2.0 — measured charging power (W) cached on each _refresh_state.
+        # None when no charging-power sensor is mapped (→ drawing-now falls back
+        # to the commanded switch echo, byte-for-byte legacy behaviour).
+        self._measured_power_w: Optional[float] = None
         self._lock = asyncio.Lock()
 
         self.logger.info(
@@ -195,6 +199,15 @@ async def _emit_operation_diagnostic(
                 "target_amps": target_amps,
                 "current_amps": self._current_amperage,
                 "charger_on": self._is_on,
+                # v2.2.0: measured charging power (diagnostic only — control uses
+                # the commanded switch echo). drawing_now is the model's stateless
+                # verdict; None when no power sensor is mapped.
+                "measured_power_w": self._measured_power_w,
+                "drawing_now": (
+                    self._runtime_data.power_model.is_charging(self.hass)
+                    if self._runtime_data and self._runtime_data.power_model
+                    else None
+                ),
                 "charger_switch": self._charger_switch,
                 "current_entity": self._charger_current,
                 "error_message": error_message,
@@ -214,11 +227,21 @@ async def async_setup(self):
         )
 
     async def _refresh_state(self):
-        """Refresh cached state from Home Assistant."""
+        """Refresh cached state from Home Assistant.
+
+        ``_is_on`` / ``_current_amperage`` stay strictly COMMANDED (switch echo,
+        setpoint) and drive ALL control decisions (byte-for-byte v2.1.x). v2.2.0
+        also caches the measured charging power for the operation DIAGNOSTIC only
+        (it does not gate any control path); None when no power sensor is mapped.
+        """
         charger_state = self.hass.states.get(self._charger_switch)
         if charger_state:
             self._is_on = charger_state.state == "on"
         self._current_amperage = self._current_control.get_numeric_state()
+        if self._runtime_data is not None and self._runtime_data.power_model is not None:
+            self._measured_power_w = self._runtime_data.power_model.read_charging_power(
+                self.hass
+            )
 
     async def start_charger(
         self,
 
@@ -13,6 +13,9 @@
     CONF_BATTERY_POWER,
     CONF_CAR_OWNER,
     CONF_CHARGER_MODEL,
+    CONF_CHARGING_POWER,
+    CONF_CHARGING_POWER_L2,
+    CONF_CHARGING_POWER_L3,
     CONF_CREATE_DASHBOARD,
     CONF_ENERGY_FORECAST_TARGET,
     CONF_EV_CHARGER_CURRENT,
@@ -131,7 +134,13 @@ def _charger_schema(current_data: dict[str, Any] | None = None) -> vol.Schema:
                 CONF_EV_CHARGER_CURRENT,
                 **_field_config(current_data.get(CONF_EV_CHARGER_CURRENT)),
             ): _entity_selector(CURRENT_CONTROL_DOMAINS),
-            vol.Required(
+            # v2.2.0: Optional (was Required). Now a FALLBACK for the charging
+            # power SSOT (used when no charging-power sensor is mapped) and the
+            # source for plug/idle/finished lifecycle that power cannot express.
+            # Never removed — kept prefilled in reconfigure/options so users don't
+            # silently drop their fallback. No "Required-if-set" lock (unlike
+            # soc_home) because status maps to zero helper entities → no orphans.
+            vol.Optional(
                 CONF_EV_CHARGER_STATUS,
                 **_field_config(current_data.get(CONF_EV_CHARGER_STATUS)),
             ): _entity_selector("sensor"),
@@ -233,6 +242,23 @@ def _sensor_schema(
             fields[vol.Required(l2, **_field_config(current_data.get(l2)))] = _entity_selector("sensor")
             fields[vol.Required(l3, **_field_config(current_data.get(l3)))] = _entity_selector("sensor")
 
+    # v2.2.0: measured EV charging power — the SSOT for "is the car drawing now".
+    # Optional (most installs lack a charger CT; the switch echo + status string
+    # are the fallback). Single-phase = 1 sensor; three-phase = 3 summed. The
+    # "all three or none" rule is enforced in ChargingModel.read_charging_power
+    # (Optional fields cannot be made schema-Required without breaking the
+    # single-phase / no-sensor cases).
+    fields[
+        vol.Optional(CONF_CHARGING_POWER, **_field_config(current_data.get(CONF_CHARGING_POWER)))
+    ] = _entity_selector("sensor")
+    if three_phase:
+        fields[
+            vol.Optional(CONF_CHARGING_POWER_L2, **_field_config(current_data.get(CONF_CHARGING_POWER_L2)))
+        ] = _entity_selector("sensor")
+        fields[
+            vol.Optional(CONF_CHARGING_POWER_L3, **_field_config(current_data.get(CONF_CHARGING_POWER_L3)))
+        ] = _entity_selector("sensor")
+
     return vol.Schema(fields)
 
 
 
@@ -2,7 +2,7 @@
 
 # ========== INTEGRATION METADATA ==========
 DOMAIN = "ev_smart_charger"
-VERSION = "2.1.1"
+VERSION = "2.2.0"
 DEFAULT_NAME = "EV Smart Charger"
 FRONTEND_URL_BASE = "/api/ev_smart_charger/frontend"
 FRONTEND_CARD_FILENAME = "ev-smart-charger-dashboard.js"
@@ -65,6 +65,26 @@
 GENERIC_AMP_LEVELS = list(range(6, 33))  # [6, 7, 8, ..., 32]
 VOLTAGE_EU = 230  # European standard voltage (per phase)
 
+# ========== CHARGING-STATE SSOT (v2.2.0) ==========
+# Drawing-now threshold on the TOTAL measured charging power (single absolute
+# value on the summed watts — NOT scaled by phase count). The minimum real
+# charging session is ~1380 W single-phase / ~4140 W three-phase total, both far
+# above this floor; the floor only rejects EVSE standby / CT noise (5-40 W).
+# "Is a session intended / plugged in" is answered by status/command, never the
+# floor. Tunable in beta against real wallbox standby observations.
+CHARGING_POWER_DRAWING_FLOOR_W = 200
+# Command-wins grace window. Measured charging power lags the commanded state
+# (ramp-up at start, decay at stop, and the Tuya stop→set→start decrease), so a
+# naive ``power > floor`` would oscillate against the rate-limited command loop.
+# Within this many seconds of a start/stop command, the command wins.
+CHARGING_POWER_GRACE_SECONDS = 15
+# Night-charge GRID mode: suppress the measured-power blind-spot stop for this
+# long after the session starts. An EV can take tens of seconds to begin drawing
+# after the wallbox reports 'charging' (cold battery, scheduled charging,
+# preconditioning, contactor delay); without this window the 15 s low-draw
+# debounce would false-terminate a legitimate session ~30 s in.
+NIGHT_GRID_DRAW_START_GRACE_SECONDS = 90
+
 # ========== PHASE MODE & CHARGER MODEL (v2.0.0, opt-in) ==========
 # Phase mode: single-phase (default, unchanged behaviour) or three-phase.
 # In three-phase, production/consumption/grid are THREE sensors each (summed)
@@ -104,6 +124,17 @@
 CONF_HOME_CONSUMPTION_L3 = "home_consumption_l3"
 CONF_GRID_IMPORT_L2 = "grid_import_l2"
 CONF_GRID_IMPORT_L3 = "grid_import_l3"
+
+# v2.2.0 — Measured EV charging power (W) sensor(s). The SSOT for "is the car
+# drawing current right now" (drawing_now). Unlike production/consumption/grid,
+# L1 is a NEW key (no pre-v2.2 single-phase equivalent). Single-phase = 1 sensor;
+# three-phase = 3 sensors summed. Optional: when unmapped, the charging-state
+# answer falls back to the textual CONF_EV_CHARGER_STATUS sensor → existing
+# installs are byte-for-byte unchanged. Unsigned positive watts (no sign toggle;
+# reversed-sign sensors read a flat 0 W after the clamp in read_charging_power).
+CONF_CHARGING_POWER = "charging_power"
+CONF_CHARGING_POWER_L2 = "charging_power_l2"
+CONF_CHARGING_POWER_L3 = "charging_power_l3"
 # v1.11.14: distinct from CONF_PV_FORECAST. Optional sensor that reports
 # the *next-day* solar production forecast in kWh. Consumed only by the
 # auto-dashboard "Forecast Domani" chip — Night Smart Charge stays wired