fix: iBoost demand grid covers the fetchable horizon for tariff compare

The tariff compare raises forecast_minutes to 48h after fetch_sensor_data
has run, so a demand grid built over the live forecast_minutes read as
zero for the extended horizon and compared tariffs saw different iBoost
demand. The grid now covers the whole fetchable horizon
(forecast_days + 1 days) and the raw data extent is recorded separately
(iboost_forecast_extent) so the fill pass stays clamped to real data
rather than the grid end. Test helpers reset the extent alongside the
forecast they inject.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016QiqN8TJpbXRsSkph6yNSx

Author: claude

apps/predbat/fetch.py

@@ -1021,6 +1021,7 @@ def fetch_sensor_data(self, save=True):
 
         # iBoost hot water demand forecast and tank state of charge
         self.iboost_forecast = {}
+        self.iboost_forecast_extent = None
         self.iboost_tank_soc_percent = None
         if self.iboost_enable:
             self.iboost_forecast = self.fetch_iboost_forecast()
@@ -2978,15 +2979,19 @@ def fetch_iboost_forecast(self):
             return {}
 
         # Convert the cumulative series into demand per plan interval, aligned to the same interval
-        # grid the planner books slots on. Per-minute positive deltas are taken per source (the
-        # same reading get_from_incrementing gives the load forecast) and only within that source's
-        # own raw extent, so a series that ends or resets never books phantom demand from
-        # minute_data's back-fill and one source's tail cannot mask another's draw. Minutes already
-        # elapsed in the current interval are skipped: any draw there is in the tank SoC reading.
+        # grid the planner books slots on. The grid covers the whole fetchable horizon (not just
+        # forecast_minutes) so a planning horizon raised after the fetch - the tariff compare sets
+        # forecast_minutes to 48h after fetching - still finds the demand. Per-minute positive
+        # deltas are taken per source (the same reading get_from_incrementing gives the load
+        # forecast) and only within that source's own raw extent, so a series that ends or resets
+        # never books phantom demand from minute_data's back-fill and one source's tail cannot
+        # mask another's draw. Minutes already elapsed in the current interval are skipped: any
+        # draw there is in the tank SoC reading.
         demand = {}
         total = 0.0
         start_minute = int(self.minutes_now / self.plan_interval_minutes) * self.plan_interval_minutes
-        for minute in range(start_minute, start_minute + self.forecast_minutes, self.plan_interval_minutes):
+        grid_end = max(start_minute + self.forecast_minutes, (self.forecast_days + 1) * 24 * 60)
+        for minute in range(start_minute, grid_end, self.plan_interval_minutes):
             kwh = 0.0
             for _, forecast, first_minute, last_minute in sources:
                 for offset in range(self.plan_interval_minutes):
@@ -3003,6 +3008,7 @@ def fetch_iboost_forecast(self):
             self.log("Warn: iBoost demand forecast contains no future demand, using the legacy iBoost smart plan")
             return {}
 
+        self.iboost_forecast_extent = last_data_minute
         self.log("iBoost demand forecast loaded: {} kWh over {} intervals of {} minutes from minute {}".format(dp2(total), len(demand), self.plan_interval_minutes, start_minute))
         return demand
 

apps/predbat/plan.py

@@ -5513,7 +5513,7 @@ def plan_iboost_forecast(self):
         # seen by later fill slots only counts energy that survives.
         fill_threshold = self.iboost_fill_rate_threshold
         if fill_threshold > -99.0:
-            forecast_extent = max(self.iboost_forecast.keys()) + interval
+            forecast_extent = self.iboost_forecast_extent if self.iboost_forecast_extent is not None else max(self.iboost_forecast.keys()) + interval
             levels_boosted, levels_after = self.iboost_tank_trajectory(stored_start, capacity, demand, boost)
             day_usage = self.iboost_forecast_day_usage(interval_starts, boost, total_days)
             for slot_n in range(num_intervals):

apps/predbat/predbat.py

@@ -608,6 +608,7 @@ def reset(self):
         self.iboost_rate_threshold_export = 9999
         self.iboost_plan = []
         self.iboost_forecast = {}
+        self.iboost_forecast_extent = None
         self.iboost_tank_capacity = 10.0
         self.iboost_tank_reserve = 0.0
         self.iboost_tank_soc_percent = None

apps/predbat/tests/test_iboost.py

@@ -76,6 +76,7 @@ def restore_iboost_state(my_predbat):
     my_predbat.iboost_tank_reserve = my_predbat.get_arg("iboost_tank_reserve")
     my_predbat.iboost_fill_rate_threshold = my_predbat.get_arg("iboost_fill_rate_threshold")
     my_predbat.iboost_forecast = {}
+    my_predbat.iboost_forecast_extent = None
     my_predbat.iboost_tank_soc_percent = None
     my_predbat.minutes_now = 12 * 60
 
@@ -313,6 +314,7 @@ def run_iboost_fetch_test(test_name, my_predbat, config, states, expect_demand=N
         del my_predbat.args[key]
     for entity_id in states:
         del my_predbat.ha_interface.dummy_items[entity_id]
+    my_predbat.iboost_forecast_extent = None
     if minutes_now is not None:
         my_predbat.minutes_now = 12 * 60
 
@@ -346,6 +348,7 @@ def run_iboost_forecast_plan_test(
     my_predbat.iboost_tank_soc_percent = tank_soc_percent
     my_predbat.iboost_fill_rate_threshold = fill_rate_threshold
     my_predbat.iboost_forecast = forecast
+    my_predbat.iboost_forecast_extent = None
     saved_gas = None
     if gas_rate is not None:
         saved_gas = (my_predbat.iboost_gas, my_predbat.iboost_gas_scale, my_predbat.rate_gas)
@@ -409,6 +412,22 @@ def run_iboost_forecast_test_cases(my_predbat):
         expect_demand={780: 1.0, 870: 1.0},
         expect_total=2.0,
     )
+    # The demand grid spans the whole fetchable horizon (the tariff compare raises
+    # forecast_minutes after the fetch) and the raw data extent is recorded for the fill clamp
+    print("**** Running Test: iboost_fetch_wide_grid ****")
+    my_predbat.args["iboost_forecast"] = ["sensor.hot_water_demand$results"]
+    my_predbat.ha_interface.set_state("sensor.hot_water_demand", "ok", attributes={"results": forecast_attribute})
+    demand = my_predbat.fetch_iboost_forecast()
+    if max(demand) < (my_predbat.forecast_days + 1) * 24 * 60 - my_predbat.plan_interval_minutes:
+        print("ERROR: iboost_fetch_wide_grid demand grid ends at {} which does not cover the fetchable horizon".format(max(demand)))
+        failed = True
+    if my_predbat.iboost_forecast_extent != 900:
+        print("ERROR: iboost_fetch_wide_grid forecast extent should be 900 got {}".format(my_predbat.iboost_forecast_extent))
+        failed = True
+    del my_predbat.args["iboost_forecast"]
+    del my_predbat.ha_interface.dummy_items["sensor.hot_water_demand"]
+    my_predbat.iboost_forecast_extent = None
+
     failed |= run_iboost_fetch_test(
         "iboost_fetch_scaling",
         my_predbat,