Merge pull request #118 from partach/claude/expand-felicity-card-B7dl4

Claude/expand felicity card b7dl4

Author: partach

CLAUDE.md

@@ -219,10 +219,12 @@ After selecting slots, simulates battery forward through every slot. Drops slots
 - Charge pushing SOC > capacity → drop most expensive non-negative charge first, then negative-price charges if needed
 - Discharge pulling SOC < minimum → drop least profitable discharge
 
-Negative-price slots are no longer fully exempt from overflow pruning.
-When PV production combined with grid charging would overfill the battery,
-negative-price charge slots are dropped to prevent forced grid export at
-penalty rates (inverter cannot disconnect PV panels).
+Negative-price slots are preserved when PV alone would fill the battery
+(surplus ≥ 90% of remaining capacity).  In that case the overflow is
+PV-caused — pruning negative-price slots won't prevent it, and the
+negative-price income is pure profit.  When PV is insufficient to cause
+overflow on its own, negative-price charge slots are still pruned to
+prevent forced grid export at penalty rates.
 
 ### Arbitrage Price Delta (both mode)
 
@@ -237,8 +239,8 @@ Prevents over-scheduling when PV will fill the battery:
 ```python
 headroom = max(0, max_battery_kwh - current_kwh - net_pv_surplus)
 max_today_slots = floor(headroom / effective_per_slot)
-# Negative-price slots pass through here (profitable to consume),
-# but _validate_schedule_soc prunes any that would cause overflow.
+# Negative-price slots pass through here (profitable to consume).
+# SOC validation prunes only when PV alone wouldn't fill the battery.
 ```
 
 ---
@@ -473,7 +475,7 @@ discharge combined).
 
 ## Testing
 
-Tests are in `tests/test_ems.py` (130 tests). They import `ems.py` directly (bypassing HA dependencies) and test the pure scheduling functions.
+Tests are in `tests/test_ems.py` (134 tests). They import `ems.py` directly (bypassing HA dependencies) and test the pure scheduling functions.
 
 ```bash
 # Run all tests

custom_components/ha_felicity/ems.py

@@ -431,6 +431,23 @@ def _validate_schedule_soc(
     # Build price lookup from remaining
     price_of: dict[int, float] = {idx: price for idx, price in remaining}
 
+    # Check if PV alone would fill the battery (net surplus > available space).
+    # When true, overflow is PV-caused — pruning negative-price charge slots
+    # won't prevent it, and the negative-price income is pure profit.
+    pv_surplus_total = 0.0
+    for slot_idx, _ in remaining:
+        hour = int((slot_idx * minutes_per_slot) / 60)
+        pv_kwh = (pv_hourly_kwh or {}).get(hour, 0.0) * pv_confidence
+        pv_per_slot = pv_kwh * (minutes_per_slot / 60.0)
+        if consumption_hourly_kwh and hour in consumption_hourly_kwh:
+            cons = consumption_hourly_kwh[hour] * (minutes_per_slot / 60.0)
+        else:
+            cons = consumption_per_slot
+        surplus = pv_per_slot - cons
+        if surplus > 0:
+            pv_surplus_total += surplus
+    pv_fills_battery = pv_surplus_total >= (battery_capacity - current_kwh) * 0.9
+
     max_iterations = len(charge_slots) + len(discharge_slots) + 1
 
     for _ in range(max_iterations):
@@ -507,9 +524,7 @@ def _validate_schedule_soc(
         else:
             # Remove the most expensive charge at or before violation.
             # Prefer dropping non-negative slots first; fall back to
-            # negative-price slots if those are the only ones left —
-            # a negative-price slot that overflows the battery still
-            # causes forced PV export at penalty rates.
+            # negative-price slots only when PV alone wouldn't overflow.
             candidates = [
                 s for s in charge_slots
                 if s <= violation_slot and price_of.get(s, 0.0) >= 0
@@ -520,6 +535,17 @@ def _validate_schedule_soc(
                     if price_of.get(s, 0.0) >= 0
                 ]
             if not candidates:
+                # Only negative-price slots remain.  If PV alone would
+                # fill the battery, the overflow is PV-caused — pruning
+                # negative-price slots won't prevent it, and the income
+                # from charging at negative prices is pure profit.
+                if pv_fills_battery:
+                    _LOGGER.debug(
+                        "SOC validation: keeping negative-price charge slots — "
+                        "PV surplus (%.1f kWh) fills battery anyway",
+                        pv_surplus_total,
+                    )
+                    break
                 candidates = [
                     s for s in charge_slots
                     if s <= violation_slot

custom_components/ha_felicity/frontend/ha_felicity_ems.js

@@ -692,12 +692,15 @@ class FelicityEMSCard extends LitElement {
     const chartH = h - marginTop - marginBottom;
     const barW = Math.max(1, (w - marginLeft - marginRight) / numSlots);
 
-    // Find price range
+    // Find price range — add padding below minimum so bars at the lowest
+    // price still have visible height (otherwise they're clipped to 0px).
     const prices = displayData.map((s) => s.price).filter((p) => p != null);
     const actualMinPrice = prices.length ? Math.min(...prices) : 0;
     const actualMaxPrice = prices.length ? Math.max(...prices) : 0;
-    const minPrice = Math.min(...prices, 0);
+    const rawMin = Math.min(...prices, 0);
     const maxPrice = Math.max(...prices, 0.01);
+    const rawRange = maxPrice - rawMin || 0.01;
+    const minPrice = rawMin - rawRange * 0.05;
     const range = maxPrice - minPrice || 0.01;
 
     // Current time marker (only for today view)

tests/test_ems.py

@@ -759,8 +759,9 @@ def test_negative_prices_from_grid(self):
         charged_neg = sum(1 for s in charge_slots if prices[s] < 0)
         assert charged_neg > 0
 
-    def test_negative_prices_skipped_when_pv_fills_battery(self):
-        """Negative-price charging skipped when PV would overfill the battery."""
+    def test_negative_prices_kept_when_pv_fills_battery(self):
+        """Negative-price charging preserved when PV fills battery — the
+        overflow is PV-caused, so negative-price income is pure profit."""
         config = default_config()
         prices = make_prices(24, pattern="negative")
         state = default_state(
@@ -773,7 +774,10 @@ def test_negative_prices_skipped_when_pv_fills_battery(self):
         )
         result = calculate_schedule(config, state)
         charge_slots = [k for k, v in result.scheduled_slots.items() if v == "charge"]
-        assert len(charge_slots) == 0
+        neg_slots = [s for s in charge_slots if prices[s] < 0]
+        assert len(neg_slots) > 0, (
+            "Negative-price slots should be kept when PV fills battery anyway"
+        )
 
     def test_yesterday_deficit_carryover(self):
         """Yesterday's deficit increases today's charging."""
@@ -1077,8 +1081,9 @@ def test_scenario_negative_prices_bonus_charge(self):
         neg_slots = [s for s in charge_slots if prices[s] < 0]
         assert len(neg_slots) >= 1
 
-    def test_scenario_negative_prices_skipped_when_battery_full_with_pv(self):
-        """Negative prices skipped when PV + high SOC leaves no room."""
+    def test_scenario_negative_prices_kept_when_pv_fills_battery(self):
+        """Negative-price slots kept when PV alone fills battery — overflow
+        is PV-caused, negative-price income is pure profit."""
         config = default_config(consumption_est_kwh=20.0)
         prices = [0.25] * 10 + [-0.05, -0.03, -0.01] + [0.25] * 11
         state = default_state(
@@ -1092,8 +1097,9 @@ def test_scenario_negative_prices_skipped_when_battery_full_with_pv(self):
         result = calculate_schedule(config, state)
         charge_slots = [k for k, v in result.scheduled_slots.items() if v == "charge"]
         neg_slots = [s for s in charge_slots if prices[s] < 0]
-        # With 10 kWh battery at 70% and 35 kWh PV, no room for grid charging
-        assert len(neg_slots) == 0
+        assert len(neg_slots) >= 1, (
+            "Negative-price slots should be kept when PV fills battery anyway"
+        )
 
     def test_scenario_both_mode_negative_prices_with_headroom(self):
         """Both mode charges at negative prices when battery has room."""
@@ -1115,8 +1121,9 @@ def test_scenario_both_mode_negative_prices_with_headroom(self):
         neg_slots = [s for s in charge_slots if prices[s] < 0]
         assert len(neg_slots) >= 1
 
-    def test_scenario_both_mode_negative_prices_limited_by_pv(self):
-        """Both mode limits negative-price charging when PV would overflow battery."""
+    def test_scenario_both_mode_negative_prices_kept_when_pv_fills(self):
+        """Both mode keeps negative-price charging when PV fills battery —
+        overflow is PV-caused, negative-price income is profit."""
         config = default_config(
             grid_mode="both", consumption_est_kwh=10.0,
         )
@@ -1132,8 +1139,10 @@ def test_scenario_both_mode_negative_prices_limited_by_pv(self):
         )
         result = calculate_schedule(config, state)
         charge_slots = [k for k, v in result.scheduled_slots.items() if v == "charge"]
-        # Battery at 80% with 40 kWh PV on 10 kWh battery: almost no room
-        assert len(charge_slots) <= 2
+        neg_slots = [s for s in charge_slots if prices[s] < 0]
+        assert len(neg_slots) >= 1, (
+            "Negative-price slots should be kept when PV fills battery anyway"
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -3024,6 +3033,72 @@ def test_sell_slots_preserved_when_pv_recovers_soc(self):
                 f"SOC at slot {i} is {soc}%, below min {config.battery_discharge_min_pct}%"
             )
 
+    def test_negative_charge_preserved_when_pv_fills_battery(self):
+        """When PV alone would fill the battery, negative-price charge slots
+        should NOT be pruned — the overflow is PV-caused, and charging at
+        negative prices is pure profit."""
+        config = default_config(
+            grid_mode="from_grid",
+            battery_capacity_kwh=60.0,
+            battery_discharge_min_pct=20.0,
+            consumption_est_kwh=10.0,
+            safe_power_kw=5.0,
+            inverter_max_power_kw=10.0,
+        )
+        # Negative prices at hours 7-10, positive rest of day
+        prices = [0.05] * 7 + [-0.46, -0.30, -0.20] + [0.05] * 4 + [0.10] * 4 + [0.15] * 6
+        state = default_state(
+            battery_soc_pct=29.0,
+            slot_prices_today=prices,
+            pv_hourly_kwh=make_pv_hourly(65.0),
+            pv_forecast_remaining=64.7,
+            pv_forecast_today=65.0,
+            pv_actual_today_kwh=0.3,
+            current_hour=7,
+        )
+        result = calculate_schedule(config, state)
+        charges = {k for k, v in result.scheduled_slots.items() if v == "charge"}
+        neg_slots = {i for i, p in enumerate(prices) if p < 0 and i >= 7}
+        neg_charged = charges & neg_slots
+        assert len(neg_charged) == len(neg_slots), (
+            f"All {len(neg_slots)} negative-price slots should be charged "
+            f"(PV fills battery anyway), but only {len(neg_charged)} are: "
+            f"charged={sorted(charges)}, neg={sorted(neg_slots)}"
+        )
+
+    def test_negative_charge_still_pruned_when_pv_insufficient(self):
+        """When PV doesn't fill the battery, negative-price charge slots
+        that would cause overflow should still be pruned."""
+        config = default_config(
+            grid_mode="from_grid",
+            battery_capacity_kwh=60.0,
+            battery_discharge_min_pct=20.0,
+            consumption_est_kwh=10.0,
+            safe_power_kw=5.0,
+            inverter_max_power_kw=10.0,
+        )
+        # Battery nearly full, little PV, negative prices
+        prices = [0.05] * 7 + [-0.10, -0.05, -0.02] + [0.05] * 14
+        state = default_state(
+            battery_soc_pct=92.0,
+            slot_prices_today=prices,
+            pv_hourly_kwh=make_pv_hourly(5.0),
+            pv_forecast_remaining=3.0,
+            pv_forecast_today=5.0,
+            pv_actual_today_kwh=2.0,
+            current_hour=7,
+        )
+        result = calculate_schedule(config, state)
+        charges = {k for k, v in result.scheduled_slots.items() if v == "charge"}
+        neg_slots = {i for i, p in enumerate(prices) if p < 0 and i >= 7}
+        # At 92% of 60 = 55.2 kWh, capacity = 60, only 4.8 kWh headroom
+        # With 5 kW * 0.9 eff = 4.5 kWh per slot, only 1 slot fits.
+        # PV doesn't fill battery → overflow pruning should still apply.
+        assert len(charges & neg_slots) < len(neg_slots), (
+            f"Not all negative slots should charge when battery is nearly full "
+            f"and PV insufficient — overflow pruning should apply"
+        )
+
     def test_sell_still_pruned_when_discharge_causes_violation(self):
         """When a sell actually causes SOC to drop below min, it should
         still be pruned (the fix only affects inherent low SOC)."""