@@ -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.1
+**Current Version:** 2.13.2
 **Installation:** HACS custom repository or manual installation to `custom_components/ev_smart_charger`
 
 ## Development Commands
@@ -757,6 +757,48 @@ async def _set_amperage(self, target_amperage: int):
 
 ## Version History
 
+### v2.13.2 (2026-09-28)
+**FIX: Hybrid Inverter Mode RIDING_EDGE ramp froze mid-way (~10 A) despite PV headroom**
+
+`_handle_riding_edge` had three grid-import regions: step down when
+`grid_import > threshold` is sustained, step up only when
+`grid_import <= threshold / 2` for `HYBRID_HEADROOM_STABLE_SECONDS`, and
+**hold forever** in between. Zero-export inverters regulate to a small
+residual import that grows with the load (a CT control loop with a
+percentage deadband), so once that residual crossed `threshold / 2`
+(25 W at the default 50 W) the ramp neither climbed nor stepped down — on a
+typical install that happened around 10 A, with kilowatts of curtailed PV
+still available. Reproduced in a simulation with a 1.5 %-of-load residual:
+the old code sat at 8–10 A indefinitely.
+
+Fix: the step-up path now runs whenever `grid_import <= threshold` (the
+import is within the user's own budget). Anti-oscillation moved from the
+import domain to the amperage domain: every step-down (grid or battery
+masking) records the tripped level as an **edge ceiling**
+(`_set_edge_ceiling`), and the ramp may not climb back onto it for
+`HYBRID_EDGE_CEILING_SECONDS = 600`; after expiry the edge is re-probed once
+(PV availability changes through the day). An over-threshold tick now also
+clears `_headroom_ok_since`, so a step-up always needs a fresh stable window,
+and the import-violation timer resets as soon as import is back within the
+threshold (previously only below half of it). The ceiling is cleared on any
+return to IDLE, surfaced in the diagnostic snapshot (`edge_ceiling_amps`,
+`edge_ceiling_until`) and in the diagnostic state
+(`holding below {N}A import ceiling`). The Generic 2-level jump (issue #38)
+respects the ceiling. PROBING and IDLE-entry smoothing are unchanged.
+
+**Files**: `hybrid_inverter_mode.py`, `const.py` (`HYBRID_EDGE_CEILING_SECONDS`,
+VERSION), `manifest.json`, `README.md`, this file; tests: NEW
+`tests/test_v2132_hybrid_ramp.py` (4: ramp reaches 32 A with zero import,
+residual import within the threshold no longer freezes the ramp, a step-down
+blocks re-climbing until the ceiling expires then re-probes, sustained import
+still steps down). `VERSION = "2.13.2"`. No schema / entity / config-flow
+change, entity counts unchanged (74 / 60). Full suite green:
+**368 passed / 0 failed**.
+
+**Upgrade priority**: 🟢 RECOMMENDED for every Hybrid Inverter Mode user.
+
+---
+
 ### v2.13.1 (2026-09-25)
 **FIX: Boost Charge aborted when enabled on an already-charging vehicle (issue #60)**
 
 
@@ -56,6 +56,8 @@ 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.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**.
 
 > **🔌 New in v2.11.0** — **auto-disarm Force Charge on unplug** (opt-in). Force Charge means "charge now, whatever the automations think" — an intent that ends with that session, except the switch stays ON. Enable `evsc_force_charge_auto_disarm` (Dashboard → Settings → 🛡 Safety) and unplugging the EV turns Force Charge OFF automatically, so the next plug-in starts from the normal automation state instead of a forgotten override. Acts on the unplug **edge** only, and an `unknown`/`unavailable` status never counts as a disconnect — a sensor glitch must not cancel a Force Charge you are relying on. **Default OFF**; requires the charger status sensor.
@@ -1060,8 +1062,8 @@ Two-phase probing protects against inverter slow-ramp:
 
 After a successful probe, Hybrid Mode transitions to **RIDING_EDGE** where it "rides the edge" of `grid_import`:
 
-- Grid stays below 50 % of threshold for 60 s → step amperage **up** one level (6 → 8 → 10 → 13 → 16 → 20 → 24 → 32 A)
-- Grid exceeds threshold for `evsc_hybrid_max_import_duration` → step amperage **down** one level
+- Grid stays at or below the threshold for 60 s → step amperage **up** one level (6 → 8 → 10 → 13 → 16 → 20 → 24 → 32 A)
+- Grid exceeds threshold for `evsc_hybrid_max_import_duration` → step amperage **down** one level; the level that tripped the step-down is not re-tried for 10 minutes (anti-oscillation), then the edge is probed again
 - At 6 A and grid still high → stop and treat as a failed probe
 
 #### Cost transparency
@@ -1093,6 +1095,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. |
 
 #### Interaction with other automations
 
 
@@ -2,7 +2,7 @@
 
 # ========== INTEGRATION METADATA ==========
 DOMAIN = "ev_smart_charger"
-VERSION = "2.13.1"
+VERSION = "2.13.2"
 DEFAULT_NAME = "EV Smart Charger"
 FRONTEND_URL_BASE = "/api/ev_smart_charger/frontend"
 FRONTEND_CARD_FILENAME = "ev-smart-charger-dashboard.js"
@@ -506,6 +506,7 @@
 HYBRID_COOLDOWN_LONG_SECONDS = 900   # 15 min after N consecutive fails (sliding window)
 HYBRID_FAILURE_WINDOW_SECONDS = 1800  # 30 min sliding window for failure counting
 HYBRID_HEADROOM_STABLE_SECONDS = 60  # how long grid_import must stay low before stepping up
+HYBRID_EDGE_CEILING_SECONDS = 600  # v2.13.2: block re-climbing a level that forced a step-down for 10 min
 HYBRID_SUNSET_BUFFER_MIN = 90  # minutes before sunset — do not probe when sun is too low
 HYBRID_TRANSIENT_GRACE_SECONDS = 20  # first N seconds of PROBING: ignore grid_import (inverter ramp)
 HYBRID_GRID_ENTRY_SMOOTH_SECONDS = 60  # how long grid_import must stay low BEFORE entering PROBING
 
@@ -26,8 +26,10 @@
       └─ FAIL → stop_charger + COOLDOWN_SHORT, append to failure window
 
     RIDING_EDGE
-      ├─ headroom_ok_since ≥ HYBRID_HEADROOM_STABLE_SECONDS → step amperage up
-      ├─ import_violation_since ≥ max_import_duration → step amperage down
+      ├─ grid ≤ threshold for HYBRID_HEADROOM_STABLE_SECONDS → step amperage up
+      │  (never onto an active edge ceiling)
+      ├─ import_violation_since ≥ max_import_duration → step amperage down and
+      │  set an edge ceiling on the tripped level for HYBRID_EDGE_CEILING_SECONDS
       ├─ at 6A and import persists → STOP + COOLDOWN_SHORT (counts as FAIL)
       ├─ sustained ≥ HYBRID_RIDING_EDGE_SUCCESS_DURATION → reset failure window
       └─ exit condition fails → IDLE (graceful, NOT counted as FAIL)
@@ -84,6 +86,7 @@
     HELPER_SOLAR_MAX_AMPERAGE_SUFFIX,
     HYBRID_COOLDOWN_LONG_SECONDS,
     HYBRID_COOLDOWN_SHORT_SECONDS,
+    HYBRID_EDGE_CEILING_SECONDS,
     HYBRID_FAILURE_WINDOW_SECONDS,
     HYBRID_GRID_ENTRY_SMOOTH_SECONDS,
     HYBRID_HEADROOM_STABLE_SECONDS,
@@ -206,6 +209,10 @@ def __init__(
         # we jump 2 levels at a time to converge faster. Reset on any step-down
         # or exit. Tuya is unaffected (its levels are already coarse).
         self._consecutive_stepup_count: int = 0
+        # v2.13.2: amperage level that last forced a step-down; the ramp may not
+        # climb back onto it until _edge_ceiling_until (anti-oscillation).
+        self._edge_ceiling_amps: int | None = None
+        self._edge_ceiling_until: datetime | None = None
 
         # Grid import entry smoothing (so we don't enter PROBING on a 1s dip)
         self._grid_import_below_threshold_since: datetime | None = None
@@ -553,6 +560,9 @@ def get_diagnostic_snapshot(self) -> dict[str, Any]:
             snapshot["headroom_ok_since"] = self._headroom_ok_since.isoformat()
         if self._import_violation_since is not None:
             snapshot["import_violation_since"] = self._import_violation_since.isoformat()
+        if self._edge_ceiling_amps is not None and self._edge_ceiling_until is not None:
+            snapshot["edge_ceiling_amps"] = self._edge_ceiling_amps
+            snapshot["edge_ceiling_until"] = self._edge_ceiling_until.isoformat()
         if self._notification_sent_on_date is not None:
             snapshot["notification_sent_on_date"] = str(self._notification_sent_on_date)
         return snapshot
@@ -813,6 +823,9 @@ async def _handle_riding_edge(
 
         # Decrease path
         if grid_import > grid_threshold:
+            # v2.13.2: an over-threshold reading breaks the headroom stability
+            # window — a step-up must be earned by a fresh stable period.
+            self._headroom_ok_since = None
             if self._import_violation_since is None:
                 self._import_violation_since = now
             violation_elapsed = (now - self._import_violation_since).total_seconds()
@@ -833,6 +846,7 @@ async def _handle_riding_edge(
                         self._import_violation_since = None
                         self._headroom_ok_since = None
                         self._consecutive_stepup_count = 0  # issue #38
+                        self._set_edge_ceiling(current_amps, now)
                         await self._publish_diagnostic(
                             reason=f"RIDING_EDGE @ {next_down}A (reduced)"
                         )
@@ -851,8 +865,16 @@ async def _handle_riding_edge(
             )
             return
 
-        # Reset violation tracking when we're back below threshold
-        if grid_import <= grid_threshold / 2:
+        # v2.13.2: at/below the threshold the grid is within budget → ramp path.
+        # Before v2.13.2 this required grid_import <= threshold/2 and held the
+        # amperage forever in the (threshold/2, threshold] band. Zero-export
+        # inverters regulate to a small residual import that grows with the
+        # load, so the ramp froze as soon as that residual crossed threshold/2
+        # (~10 A on a typical install) even with kilowatts of headroom left.
+        # Anti-oscillation now lives in the amperage domain instead: a level
+        # that tripped a step-down is blocked for HYBRID_EDGE_CEILING_SECONDS
+        # (see _set_edge_ceiling).
+        if grid_import <= grid_threshold:
             self._import_violation_since = None
 
             # v2.1.0 (issue #29): battery-discharge masking step-down. With grid
@@ -891,6 +913,7 @@ async def _handle_riding_edge(
                             self._battery_violation_since = None
                             self._headroom_ok_since = None
                             self._consecutive_stepup_count = 0  # issue #38
+                            self._set_edge_ceiling(current_amps, now)
                             await self._publish_diagnostic(
                                 reason=f"RIDING_EDGE @ {next_down}A (reduced, battery)"
                             )
@@ -917,13 +940,22 @@ async def _handle_riding_edge(
             if self._headroom_ok_since is None:
                 self._headroom_ok_since = now
             headroom_elapsed = (now - self._headroom_ok_since).total_seconds()
+            # v2.13.2: never climb back onto a level that just tripped a
+            # step-down while its ceiling is still active.
+            max_amps = solar_max_amperage
+            ceiling = self._active_edge_ceiling(now)
+            if ceiling is not None:
+                max_amps = min(
+                    max_amps,
+                    AmperageCalculator.get_next_level_down(ceiling, self._amp_levels),
+                )
             # Increase path
             if (
                 headroom_elapsed >= HYBRID_HEADROOM_STABLE_SECONDS
-                and current_amps < solar_max_amperage
+                and current_amps < max_amps
             ):
                 next_up = AmperageCalculator.get_next_level_up(
-                    current_amps, solar_max_amperage, self._amp_levels
+                    current_amps, max_amps, self._amp_levels
                 )
                 # issue #38: self-tuning — on a Generic charger (1A levels), once
                 # we've already stepped up twice in a row on stable headroom, jump
@@ -933,10 +965,10 @@ async def _handle_riding_edge(
                     self._power_model.charger_model == CHARGER_MODEL_GENERIC
                     and self._consecutive_stepup_count >= 2
                     and next_up > current_amps
-                    and next_up < solar_max_amperage
+                    and next_up < max_amps
                 ):
                     next_up = AmperageCalculator.get_next_level_up(
-                        next_up, solar_max_amperage, self._amp_levels
+                        next_up, max_amps, self._amp_levels
                     )
                 if next_up > current_amps:
                     self.logger.info(
@@ -956,15 +988,38 @@ async def _handle_riding_edge(
                             reason=f"RIDING_EDGE @ {next_up}A (increased)"
                         )
                     return
-            await self._publish_diagnostic(
-                reason=f"RIDING_EDGE @ {current_amps}A (stable {headroom_elapsed:.0f}s)"
-            )
+            if ceiling is not None and current_amps >= max_amps:
+                reason = (
+                    f"RIDING_EDGE @ {current_amps}A (holding below {ceiling}A "
+                    "import ceiling)"
+                )
+            else:
+                reason = (
+                    f"RIDING_EDGE @ {current_amps}A (stable {headroom_elapsed:.0f}s)"
+                )
+            await self._publish_diagnostic(reason=reason)
             return
 
-        # Grid in the hysteresis band — hold position
-        await self._publish_diagnostic(
-            reason=f"RIDING_EDGE @ {current_amps}A (grid {grid_import:.0f}W, holding)"
-        )
+    def _set_edge_ceiling(self, tripped_amps: int, now: datetime) -> None:
+        """Block climbing back to a level that just forced a step-down.
+
+        v2.13.2: replaces the old grid-import hysteresis band as the RIDING_EDGE
+        anti-oscillation mechanism. The ceiling expires after
+        HYBRID_EDGE_CEILING_SECONDS so the edge is re-probed periodically
+        (PV availability changes during the day).
+        """
+        self._edge_ceiling_amps = tripped_amps
+        self._edge_ceiling_until = now + timedelta(seconds=HYBRID_EDGE_CEILING_SECONDS)
+
+    def _active_edge_ceiling(self, now: datetime) -> int | None:
+        """Return the active ceiling (amps), clearing it once expired."""
+        if self._edge_ceiling_amps is None or self._edge_ceiling_until is None:
+            return None
+        if now >= self._edge_ceiling_until:
+            self._edge_ceiling_amps = None
+            self._edge_ceiling_until = None
+            return None
+        return self._edge_ceiling_amps
 
     async def _handle_cooldown(self, now: datetime) -> None:
         """During COOLDOWN_*: wait for the timer to expire."""
@@ -1096,6 +1151,8 @@ async def _transition(self, new_state: str, *, reason: str) -> None:
             self._headroom_ok_since = None
             self._riding_edge_entered_at = None
             self._current_target_amps = 0
+            self._edge_ceiling_amps = None
+            self._edge_ceiling_until = None
         self.logger.info(
             f"{self.logger.DECISION} Hybrid state: {prev_state} → {new_state} ({reason})"
         )
 
@@ -11,5 +11,5 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",
   "requirements": [],
-  "version": "2.13.1"
+  "version": "2.13.2"
 }
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.1"`
	`14`	`+ "version": "2.13.2"`
`15`	`15`	`}`