@@ -7,7 +7,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 This is a **Home Assistant custom integration** for intelligent EV charging control. It manages EV charger automation based on solar production, time of day, battery levels, grid import protection, and intelligent priority balancing between EV and home battery charging.
 
 **Domain:** `ev_smart_charger`
-**Current Version:** 2.13.2
+**Current Version:** 2.13.3
 **Installation:** HACS custom repository or manual installation to `custom_components/ev_smart_charger`
 
 ## Development Commands
@@ -757,6 +757,60 @@ async def _set_amperage(self, target_amperage: int):
 
 ## Version History
 
+### v2.13.3 (2026-09-28)
+**FIX: charging frozen at 10 A under curtailment — Hybrid Inverter Mode now adopts a running session**
+
+v2.13.2 did not solve the maintainer's report ("stuck at 10 A, the inverter can
+deliver more"). An end-to-end simulation — the real Solar Surplus tick driving
+the real Hybrid state machine against a simulated zero-export inverter
+(`production = min(pv_available, house + ev)`) — showed the RIDING_EDGE ramp
+itself climbs fine, and located the real, deterministic freeze elsewhere:
+
+**Bug A — Hybrid Mode never engaged on a running session.** `is_relevant()`
+returned False whenever `charger_is_on`, so Hybrid Mode could only start from
+its own 6 A probe. A session already running when the home battery fills and
+the inverter starts curtailing — started by Solar Surplus, battery support, or
+surviving an HA restart (Hybrid always boots IDLE) — stayed with normal Solar
+Surplus. Under curtailment production follows the load, so the measured
+surplus equals the EV's own draw (or ≈0 with a consumption sensor that
+includes the EV): `calculate_from_surplus` never returns more than the current
+level and the amperage froze forever (simulated: 10 A for 40 ticks with 7 kW
+available).
+
+Fix: with the charger ON, `is_relevant()` (new `current_amps` argument, passed
+by Solar Surplus) keeps every other entry guard (toggle, daytime, sunset
+buffer, battery full, cooldown/HARD_EXIT, priority, smoothed low grid import)
+and replaces the "surplus < 5.5 A" curtailment signature with "Solar Surplus
+cannot reach the next level": `surplus_amps < get_next_level_up(current)` and
+`current < solar_max_amperage`. `tick()` then calls the new `_adopt_session()`:
+acquires control through Solar Surplus, sets `_current_target_amps` and goes
+straight to RIDING_EDGE (no probe — the running charger already proves the
+load is served with grid import low). Real, uncurtailed surplus (≥ next level)
+is left to Solar Surplus.
+
+**Bug B — at the real PV limit the edge restarted from 6 A.** With a home
+consumption sensor that includes the EV, `surplus_watts ≈ -grid_import`, so the
+`-500 W` plausibility exit in `_check_active_exit_conditions` fired before the
+RIDING_EDGE step-down could, stopping the charger and re-probing from 6 A in a
+loop. The floor now applies to PROBING only; in RIDING_EDGE a deficit is grid
+import and is handled by the step-down path.
+
+**Files**: `hybrid_inverter_mode.py` (`is_relevant` adoption branch,
+`_adopt_session`, PROBING-only surplus floor, docstring), `solar_surplus.py`
+(passes `current_amps` to `is_relevant`), `const.py` + `manifest.json`
+(VERSION), `README.md`, this file; tests: NEW
+`tests/test_v2133_hybrid_adoption.py` (5, end-to-end with a simulated
+zero-export inverter: a running 10 A session is adopted and settles on the real
+24 A edge for both consumption-sensor conventions, a probe from OFF rides the
+edge without restarting for both conventions, real uncurtailed surplus is left
+to Solar Surplus). 3 of the 5 fail on v2.13.2. `VERSION = "2.13.3"`. No schema
+/ entity / config-flow change, entity counts unchanged (74 / 60). Full suite
+green: **373 passed / 0 failed**.
+
+**Upgrade priority**: 🔴 STRONGLY RECOMMENDED for every Hybrid Inverter Mode user.
+
+---
+
 ### v2.13.2 (2026-09-28)
 **FIX: Hybrid Inverter Mode RIDING_EDGE ramp froze mid-way (~10 A) despite PV headroom**
 
 
@@ -56,7 +56,9 @@ Most projects target one charger brand or assume a single-phase home. EV Smart C
 
 > **🆕 New in v2.6.0** — mass bug-fix & improvement release (issues #36–#42). Highlights: an optional **`grid_available` binary sensor** ([issue #36](https://github.com/antbald/ha-ev-smart-charger/issues/36)) stops Night Smart Charge grid mode during a **grid outage** so it doesn't drain the home battery on hybrid Battery First / UPS inverters (fail-safe: an unavailable sensor never triggers a false stop); a **customizable nighttime window** ([issue #42](https://github.com/antbald/ha-ev-smart-charger/issues/42)) via two opt-in offset numbers (start before sunset / end after sunrise); and a big **INFO log-noise reduction** ([issue #40](https://github.com/antbald/ha-ev-smart-charger/issues/40)) — idle ticks no longer flood the HA log. Also: valid day icons (#37), faster Generic-charger ramp-up (#38), a consistent Hybrid full-battery threshold (#39), and a cleaner telemetry log (#41). **All backward compatible** — the two features are opt-in.
 
-> **⚡ New in v2.13.2** — **Hybrid Inverter Mode no longer stalls mid-ramp.** In RIDING_EDGE the amperage only stepped up while grid import stayed below *half* of `evsc_grid_import_threshold`, and was held forever between half and the full threshold. Zero-export inverters regulate to a small residual import that grows with the load, so on many installs the ramp froze around 10 A even with kilowatts of PV headroom left. The ramp now climbs whenever import is within the threshold; anti-oscillation moved to the amperage domain — a level that forced a step-down is not re-tried for 10 minutes, after which the edge is probed again. **RECOMMENDED for every Hybrid Inverter Mode user.**
+> **⚡ New in v2.13.3** — **Hybrid Inverter Mode takes over a session that is already charging.** Hybrid Mode used to engage only with the charger OFF. When a session was already running as the home battery filled up and the inverter started curtailing (started by Solar Surplus, by battery support, or still running after a Home Assistant restart), the amperage froze wherever it was — typically 10 A — because the measured surplus becomes exactly the EV's own draw and Solar Surplus never sees room for the next level. Hybrid Mode now adopts that session and rides the edge from its current amperage. Also, at the real PV limit the edge now steps down one level instead of stopping the charger and restarting from 6 A when the home consumption sensor includes the EV. **STRONGLY RECOMMENDED for every Hybrid Inverter Mode user.**
+
+> **⚡ New in v2.13.2** — **Hybrid Inverter Mode no longer stalls mid-ramp.** In RIDING_EDGE the amperage only stepped up while grid import stayed below *half* of `evsc_grid_import_threshold`, and was held forever between half and the full threshold. Zero-export inverters regulate to a small residual import that grows with the load, so the ramp could freeze mid-way with PV headroom left. The ramp now climbs whenever import is within the threshold; anti-oscillation moved to the amperage domain — a level that forced a step-down is not re-tried for 10 minutes, after which the edge is probed again. **RECOMMENDED for every Hybrid Inverter Mode user.**
 
 > **📱 New in v2.12.0 — full iOS Live Activities support.** Now that the Companion App renders Live Activities on the iPhone Lock Screen and Dynamic Island, EV charging Live Activities are **ON by default** and their update policy has been rewritten around Apple's real constraints: a single `evsc_ev_charging` activity is pushed only on discrete state changes (mode switch, EV target change, every 5 points of EV SOC), never on the continuously moving charging power, amperage or wallbox status — so the card moves when something actually happens instead of once a minute. Covers Boost Charge, Night Smart Charge, Solar Surplus, Force Charge, and normal charging. Requires HA Core 2026.7+ and iOS 17.2+ (Android 16+ for Live Updates), plus allowing Live Activities in **iOS Settings → Home Assistant**.
 
@@ -1040,6 +1042,7 @@ stateDiagram-v2
     [*] --> IDLE
 
     IDLE --> PROBING: Entry conditions met\n(battery full, grid≈0, daytime, etc.)
+    IDLE --> RIDING_EDGE: charger already ON,\nsurplus pinned to EV draw\n→ session adopted
     PROBING --> RIDING_EDGE: probe completed\nwithout grid violation
     PROBING --> COOLDOWN_SHORT: import sustained\n→ probe FAILED
 
@@ -1055,6 +1058,8 @@ stateDiagram-v2
     HARD_EXIT --> IDLE: next sunrise
 ```
 
+If the charger is **already charging** when those conditions hold (a session started by Solar Surplus or battery support, or still running after a restart) and Solar Surplus cannot justify the next amperage level — under curtailment the surplus equals the EV's own draw — Hybrid Mode **adopts the session** and goes straight to RIDING_EDGE from the current amperage (v2.13.3). No probe is needed: the running charger already proves the load is served with grid import near zero.
+
 Two-phase probing protects against inverter slow-ramp:
 
 1. **Phase A (0–20 s, "transient grace"):** charger at 6 A, `grid_import` is **ignored**. This is the window where the inverter detects the new load and starts ramping PV up.
@@ -1095,7 +1100,7 @@ You will receive **one push notification per day** (filtered by car-owner presen
 | Every probe fails (`COOLDOWN_SHORT` then `COOLDOWN_LONG`) | Raise `evsc_hybrid_max_import_duration` to 90–120 s. Slow-ramp inverters (Solis, Growatt) need more time to react. |
 | Module enters `HARD_EXIT` too often | Your inverter probably has genuine PV constraints (small system, partial shading). Raise `evsc_hybrid_battery_full_threshold` to 100 % so probing only happens when truly full. |
 | RIDING_EDGE oscillates a lot | Raise `evsc_grid_import_threshold` slightly (from 50 W default to 100 W) for more headroom. |
-| RIDING_EDGE stops climbing at a low amperage (e.g. 10 A) | Fixed in v2.13.2. If it still holds, check the diagnostic: `holding below …A import ceiling` means that level really imported from the grid within the last 10 minutes. |
+| Charging stops climbing at a low amperage (e.g. 10 A) with the battery full | Fixed in v2.13.3 (running sessions are now adopted by Hybrid Mode). Make sure the Hybrid Mode toggle is ON and the charging profile is `solar_surplus`. If it still holds, check the diagnostic: `holding below …A import ceiling` means that level really imported from the grid within the last 10 minutes. |
 
 #### Interaction with other automations
 
 
@@ -2,7 +2,7 @@
 
 # ========== INTEGRATION METADATA ==========
 DOMAIN = "ev_smart_charger"
-VERSION = "2.13.2"
+VERSION = "2.13.3"
 DEFAULT_NAME = "EV Smart Charger"
 FRONTEND_URL_BASE = "/api/ev_smart_charger/frontend"
 FRONTEND_CARD_FILENAME = "ev-smart-charger-dashboard.js"
 
@@ -16,7 +16,10 @@
 State machine:
 
     IDLE
-      └─ entry conditions met → [start_charger(6A) + notify_once] → PROBING
+      ├─ entry conditions met, charger OFF → [start_charger(6A) + notify_once] → PROBING
+      └─ entry conditions met, charger already ON and Solar Surplus cannot
+         reach the next level (surplus pinned to the EV draw) → adopt the
+         running session → RIDING_EDGE (v2.13.3)
 
     PROBING (probe_duration s at 6A, two-phase observation)
       ├─ Phase A (0-20s "transient grace"): ignore grid_import (inverter ramp)
@@ -324,6 +327,7 @@ async def is_relevant(
         charger_is_on: bool,
         priority: str | None,
         now: datetime,
+        current_amps: int = 0,
     ) -> bool:
         """Return True if Solar Surplus must delegate this tick to hybrid mode.
 
@@ -381,9 +385,31 @@ async def is_relevant(
             self._grid_import_below_threshold_since = None
             return False
 
-        # Surplus must look near-zero (curtailment signature). If surplus is real
-        # and above start threshold, normal Solar Surplus path handles it.
-        if surplus_amps >= SURPLUS_STOP_THRESHOLD:
+        if charger_is_on:
+            # v2.13.3: adopt a session Solar Surplus is already running. Once
+            # the inverter curtails, the measured surplus is pinned to the EV's
+            # own draw (production follows the load), so Solar Surplus can never
+            # justify the next level and the amperage freezes wherever the
+            # session happened to be (e.g. 10 A). Adopt only when Solar Surplus
+            # cannot climb on its own (surplus below the next level) and the
+            # charger is not already at its ceiling.
+            solar_max_amperage = get_int(
+                self.hass,
+                self._solar_max_amperage_entity,
+                default=DEFAULT_SOLAR_MAX_AMPERAGE,
+            )
+            if current_amps <= 0 or current_amps >= solar_max_amperage:
+                self._grid_import_below_threshold_since = None
+                return False
+            next_up = AmperageCalculator.get_next_level_up(
+                current_amps, solar_max_amperage, self._amp_levels
+            )
+            if next_up <= current_amps or surplus_amps >= next_up:
+                self._grid_import_below_threshold_since = None
+                return False
+        elif surplus_amps >= SURPLUS_STOP_THRESHOLD:
+            # Surplus must look near-zero (curtailment signature). If surplus is
+            # real and above start threshold, normal Solar Surplus handles it.
             self._grid_import_below_threshold_since = None
             return False
 
@@ -393,11 +419,12 @@ async def is_relevant(
             self._grid_import_below_threshold_since = None
             return False
 
-        # Charger must currently be off AND plugged in (not free, not finished).
-        if charger_is_on:
-            return False
+        # Charger must be plugged in (not free, not finished). A charger that is
+        # OFF also needs a readable status; a running one is its own evidence.
         status = get_state(self.hass, self._charger_status)
-        if status in (CHARGER_STATUS_FREE, CHARGER_STATUS_END, None, "unavailable", "unknown"):
+        if status in (CHARGER_STATUS_FREE, CHARGER_STATUS_END):
+            return False
+        if not charger_is_on and status in (None, "unavailable", "unknown"):
             return False
 
         # Priority Balancer must not say HOME. EV_FREE override is allowed only
@@ -478,7 +505,10 @@ async def tick(
             # State-specific handlers
             if self._state == HYBRID_STATE_IDLE:
                 # Caller guaranteed entry conditions are met (is_relevant returned True)
-                await self._start_probe(now)
+                if charger_is_on and current_amps > 0:
+                    await self._adopt_session(now, current_amps)
+                else:
+                    await self._start_probe(now)
                 return True
 
             if self._state == HYBRID_STATE_PROBING:
@@ -609,8 +639,15 @@ async def _check_active_exit_conditions(
         if status in (CHARGER_STATUS_FREE, CHARGER_STATUS_END):
             return f"charger status now {status}"
 
-        # 6A floor + plausibility
-        if surplus_watts < self._max_negative_surplus_w:
+        # 6A floor + plausibility. PROBING only: in RIDING_EDGE a real deficit
+        # shows up as grid import and is handled by the step-down path. With a
+        # consumption sensor that includes the EV, surplus ≈ -grid_import, so
+        # this check would stop the charger (and restart from 6 A) instead of
+        # stepping down one level at the edge (v2.13.3).
+        if (
+            self._state == HYBRID_STATE_PROBING
+            and surplus_watts < self._max_negative_surplus_w
+        ):
             return f"surplus dropped below {self._max_negative_surplus_w}W (no plausible headroom)"
 
         # PRIORITY checks
@@ -666,6 +703,38 @@ async def _start_probe(self, now: datetime) -> None:
             await self._mobile_notifier.send_hybrid_mode_started_notification()
             self._notification_sent_on_date = today
 
+    async def _adopt_session(self, now: datetime, current_amps: int) -> None:
+        """Transition IDLE → RIDING_EDGE on a session that is already charging.
+
+        v2.13.3: no probe is needed — the running charger already proves the
+        load is being served with grid import low (smoothed by is_relevant), so
+        we go straight to riding the edge from the current amperage.
+        """
+        if self._solar_surplus is not None:
+            acquired = await self._solar_surplus._acquire_control(
+                "turn_on", "Hybrid Mode: adopting running session"
+            )
+            if not acquired:
+                self.logger.info("Coordinator denied adoption — staying IDLE")
+                return
+
+        self.logger.separator()
+        self.logger.start(
+            f"{self.logger.SOLAR} Hybrid Mode: adopting running session at "
+            f"{current_amps}A (surplus pinned to EV load — curtailment)"
+        )
+        self._current_target_amps = current_amps
+        self._import_violation_since = None
+        self._battery_violation_since = None
+        self._headroom_ok_since = None
+        self._riding_edge_entered_at = now
+        await self._transition(HYBRID_STATE_RIDING_EDGE, reason="adopted running session")
+
+        today = now.date()
+        if self._notification_sent_on_date != today:
+            await self._mobile_notifier.send_hybrid_mode_started_notification()
+            self._notification_sent_on_date = today
+
     async def _handle_probing(self, now: datetime, grid_import: float) -> None:
         """During PROBING: two-phase observation of grid_import."""
         probe_duration = get_int(
 
@@ -11,5 +11,5 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",
   "requirements": [],
-  "version": "2.13.2"
+  "version": "2.13.3"
 }
@@ -1166,6 +1166,7 @@ async def _async_periodic_check(self, now=None, ignore_rate_limit: bool = False)
                 charger_is_on=charger_is_on,
                 priority=priority,
                 now=now,
+                current_amps=current_amps_for_hybrid,
             ):
                 handled = await self._hybrid_mode.tick(
                     surplus_amps=surplus_amps,
Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,5 @@`
`11`	`11`	`"iot_class": "local_push",`
`12`	`12`	`"issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",`
`13`	`13`	`"requirements": [],`
`14`		`- "version": "2.13.2"`
	`14`	`+ "version": "2.13.3"`
`15`	`15`	`}`