feat(annual): baseline tariff, run deletion, nav fix and current cap rates

Four changes to the WhatIf tab.

The no-PV/battery counterfactual can now be priced on its own tariff,
defaulting to the Ofgem price cap. A household with no system is not on a
battery tariff - the cheap overnight rates only pay off once there is somewhere
to put the energy - so pricing the counterfactual on the user's own smart
tariff credited it with a saving it could never have had, and understated the
system. It applies to no_pvbat only; every other scenario keeps the main
tariff. Both still share the main tariff's standing charge, so any difference
there is excluded from savings - stated in the results caveats and the docs
rather than left to be discovered.

The rate swap has to happen BEFORE the Prediction is constructed, because
Prediction snapshots the rates off predbat at construction time - built first,
it bills at the main tariff whatever is installed afterwards, so the swap looks
like it works and changes nothing. That is exactly what the first version did.

Sub-pages now highlight their parent menu entry. /annual_view and
/annual_compare matched no menu link, so the JS fell through to its default of
"first item" and lit up Dashboard while the user was plainly on WhatIf. The
second pass only runs when nothing matched exactly, so /apps_editor keeps its
own highlight rather than being captured by /apps.

Runs can be deleted from the Compare page, with confirmation. Deleting discards
the document and every captured plan through the same path eviction uses, so it
leaves no orphaned storage behind.

Price cap figures brought to the July 2026 cap: 26.11p/kWh and 57.19p/day, from
Ofgem, replacing 24.86p and a 60p default. Named constants now, so the next cap
change is a one-line edit. The 4.1p SEG export rate still sits inside the
typical 3-8p band for fixed export offers and is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: springfall2008

apps/predbat/annual.py

@@ -25,6 +25,7 @@
 from annual_weather import AnnualWeather, resolve_postcode
 from const import MINUTE_WATT, PREDICT_STEP
 from prediction import Prediction
+from tariff_catalogue import PRICE_CAP_IMPORT_P, SEG_EXPORT_P
 
 VALID_SHAPES = ["night", "day", "flat"]
 
@@ -215,6 +216,13 @@ def _validate_load(raw):
     }
 
 
+# What a household with no PV and no battery actually pays: the Ofgem price cap for
+# import, and a typical fixed Smart Export Guarantee rate for the export they cannot
+# have without generation. Rates come from tariff_catalogue so the cap figure is stated
+# in exactly one place.
+DEFAULT_BASELINE_TARIFF = {"rates_import": [{"rate": PRICE_CAP_IMPORT_P}], "rates_export": [{"rate": SEG_EXPORT_P}]}
+
+
 def _validate_tariff(raw):
     """Normalise the tariff block, requiring at least one import rate source.
 
@@ -297,6 +305,12 @@ def validate_config(config, today=None):
         "battery": battery,
         "load": _validate_load(raw.get("load")),
         "tariff": _validate_tariff(raw.get("tariff")),
+        # The counterfactual bill is what the household would pay with no system at all,
+        # and such a household is not on a battery tariff: the smart import tariffs are
+        # only worth having once you have something to shift load into. Pricing the
+        # no-PV/battery scenario on the same tariff as the battery scenarios therefore
+        # understates what the system is worth. Defaults to the Ofgem price cap.
+        "baseline_tariff": _validate_tariff(raw.get("baseline_tariff") or DEFAULT_BASELINE_TARIFF),
         "samples_per_month": samples_per_month,
         "costs": _validated_costs(raw.get("costs")),
         "debug": _coerce_bool(raw.get("debug", False)),
@@ -1079,7 +1093,7 @@ def _capture_plan(predbat, pv_step, pv_step10, load_step, load_step10, end_recor
     return raw_plan
 
 
-def _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh, car_rate_kw, plans=None):
+def _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh, car_rate_kw, plans=None, baseline_tariff=None):
     """Run all four scenarios against one sampled day at a fixed car charging energy.
 
     ``car_kwh`` is the actual energy this leg charges - either a full weekly charging
@@ -1119,11 +1133,32 @@ def _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_
     predbat.charge_window_best = []
     predbat.export_window_best = []
     predbat.export_limits_best = []
+    # Price the counterfactual on its OWN tariff. A household with no PV and no battery is
+    # not on a smart import tariff - those only pay off once there is something to shift
+    # load into - so charging the baseline at the battery tariff's overnight rate credits
+    # it with a saving it could never have had, and understates the system.
+    #
+    # The rates are restored immediately afterwards, from the tariff's own output rather
+    # than from predbat.rate_import: _apply_rates REPLICATES what it is given, so reusing
+    # the installed dict would re-replicate an already-replicated series. Every later
+    # scenario in this leg therefore runs on exactly what prepare_sample() installed.
+    if baseline_tariff is not None:
+        baseline_import, baseline_export = baseline_tariff.rates_for(midnight_utc, PLAN_MINUTES)
+        _apply_rates(predbat, baseline_import, baseline_export)
+
+    # Constructed AFTER the rate swap, never before: Prediction snapshots the rates off
+    # predbat at construction time (prediction.py, `self.rate_import = base.rate_import`),
+    # so a Prediction built first would be billed at the main tariff no matter what was
+    # installed afterwards - the swap would appear to work and change nothing.
     predbat.prediction = Prediction(predbat, zero_step, zero_step, load_step, load_step, soc_kw=0, soc_max=0)
     results["no_pvbat"] = _billed_result(predbat, DAY_MINUTES, zero_step)
     if plans is not None:
         plans["no_pvbat"] = _capture_plan(predbat, zero_step, zero_step, load_step, load_step, DAY_MINUTES)
 
+    if baseline_tariff is not None:
+        main_import, main_export = tariff.rates_for(midnight_utc, PLAN_MINUTES)
+        _apply_rates(predbat, main_import, main_export)
+
     # Scenario 1b: PV but no battery. apply_hardware gives the array its real inverter
     # and export limits - a PV-only system still has an inverter, and clipping matters -
     # while soc_max=0 leaves it with nowhere to store surplus, so everything the house
@@ -1223,7 +1258,7 @@ def _blend_results(with_car, without_car, fraction):
     return {key: {field: fraction * with_car[key][field] + (1 - fraction) * without_car[key][field] for field in SCENARIO_FIELDS} for key in SCENARIO_KEYS}
 
 
-def run_day(predbat, config, weather, tariff, load_source, day, midnight_utc, plans=None):
+def run_day(predbat, config, weather, tariff, load_source, day, midnight_utc, plans=None, baseline_tariff=None):
     """Run all four scenarios against one sampled day and return their billed figures.
 
     A configured car charges in weekly sessions, not a daily smear (see
@@ -1245,7 +1280,7 @@ def run_day(predbat, config, weather, tariff, load_source, day, midnight_utc, pl
 
     if car_charging_kwh <= 0:
         leg_plans = {} if plans is not None else None
-        result = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=0.0, car_rate_kw=car_rate_kw, plans=leg_plans)
+        result = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=0.0, car_rate_kw=car_rate_kw, plans=leg_plans, baseline_tariff=baseline_tariff)
         if plans is not None:
             plans.append({"leg": "single", "scenarios": leg_plans})
         return result
@@ -1257,12 +1292,12 @@ def run_day(predbat, config, weather, tariff, load_source, day, midnight_utc, pl
     sessions_per_week, session_kwh = car_charging_schedule(car_charging_kwh, car_rate_kw)
 
     with_car_plans = {} if plans is not None else None
-    with_car = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=session_kwh, car_rate_kw=car_rate_kw, plans=with_car_plans)
+    with_car = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=session_kwh, car_rate_kw=car_rate_kw, plans=with_car_plans, baseline_tariff=baseline_tariff)
     if plans is not None:
         plans.append({"leg": "with_car", "scenarios": with_car_plans})
 
     without_car_plans = {} if plans is not None else None
-    without_car = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=0.0, car_rate_kw=car_rate_kw, plans=without_car_plans)
+    without_car = _run_scenarios(predbat, config, weather, tariff, load_source, day, midnight_utc, car_kwh=0.0, car_rate_kw=car_rate_kw, plans=without_car_plans, baseline_tariff=baseline_tariff)
     if plans is not None:
         plans.append({"leg": "without_car", "scenarios": without_car_plans})
 
@@ -1423,6 +1458,9 @@ async def run(self, progress=None):
             self.caveats.append("Months {} had too few forecast/actual day pairs, so their P10 used the flat {} derate.".format(sorted(self.weather.fallback_months), self.config["pv10_derate_fallback"]))
         if has_solar:
             self.caveats.append("The forecast-versus-ERA5 gap includes systematic model bias as well as forecast error, so measured solar uncertainty is slightly overstated.")
+        self.caveats.append(
+            "The no_pvbat counterfactual is priced on its own baseline tariff, since a household with no PV or battery would not be on a battery tariff. Both scenarios still use ONE standing charge - the main tariff's - so any difference in standing charge between the two tariffs is NOT included in the reported savings or payback."
+        )
         self.caveats.append("export_credit_p_estimate is money ALREADY included inside cost_p (which prices every export minute at its real rate); it is informational only - adding it to cost_p double-counts export income.")
         self.caveats.append(
             "The without_predbat baseline charges in the single cheapest contiguous band of each day, mirroring Predbat's own savings baseline. On a half-hourly tariff such as Agile the cheapest band is often one 30 minute slot, so the baseline is a more pessimistic comparator there than on a banded tariff (Economy 7, Cosy, Flux) where it covers the whole cheap period. Compare predbat_vs_baseline_p across tariffs with that in mind."
@@ -1439,7 +1477,11 @@ async def run(self, progress=None):
         self.predbat = create_headless_predbat(self.work_dir, self.config["timezone"], self.log)
         self.load_source = await self._build_load_source()
         self.tariff = AnnualTariff(self.config["tariff"], log=self.log, predbat=self.predbat, storage=self.storage, timezone=self.config["timezone"])
+        # Prices the no-PV/battery counterfactual only. Its own AnnualTariff because it
+        # may be a completely different product with its own rate downloads and cache.
+        self.baseline_tariff = AnnualTariff(self.config["baseline_tariff"], log=self.log, predbat=self.predbat, storage=self.storage, timezone=self.config["timezone"])
 
+        baseline_fallback_months = []
         zone = pytz.timezone(self.config["timezone"])
         months = []
         total_units = 12
@@ -1452,6 +1494,11 @@ async def run(self, progress=None):
             days_in_month = calendar.monthrange(year, month)[1]
             standing_charge_p = self.tariff.standing_charge_p_per_day * days_in_month
 
+            baseline_ready = await self.baseline_tariff.fetch_month(year, month)
+            if not baseline_ready:
+                # Falls back to the main tariff for this month rather than losing it, but
+                # that silently changes what no_pvbat means, so it is recorded.
+                baseline_fallback_months.append(month)
             if not await self.tariff.fetch_month(year, month):
                 months.append({"month": month, "status": "unavailable", "reason": "no rate data available", "days": days_in_month, "standing_charge_p": standing_charge_p})
                 completed += 1
@@ -1478,7 +1525,7 @@ async def run(self, progress=None):
                 midnight_utc = zone.localize(datetime(day.year, day.month, day.day)).astimezone(pytz.utc)
                 day_plans = [] if self.config["debug"] else None
                 try:
-                    result = run_day(self.predbat, self.config, self.weather, self.tariff, self.load_source, day, midnight_utc, plans=day_plans)
+                    result = run_day(self.predbat, self.config, self.weather, self.tariff, self.load_source, day, midnight_utc, plans=day_plans, baseline_tariff=self.baseline_tariff if baseline_ready else None)
                 except Exception as exc:  # noqa: BLE001 - one bad sample must not abort the whole year
                     self.log("Warn: Annual: {} in month {} failed to plan/cost ({}: {}); excluding it from this month's total".format(day.isoformat(), month, type(exc).__name__, exc))
                     failed_days.append(day.isoformat())
@@ -1535,6 +1582,13 @@ async def run(self, progress=None):
 
         self.caveats.extend(self._tariff_fallback_caveats(self.tariff.fallback_months, self.tariff.unpaid_export_months, year))
 
+        if baseline_fallback_months:
+            # Falling back to the main tariff keeps the month rather than losing it, but it
+            # silently changes what no_pvbat means there, so it has to be said out loud.
+            self.caveats.append(
+                "No baseline-tariff rates were available for month(s) {}, so the no-PV/battery counterfactual there was priced on the main tariff instead, which understates what the system is worth in those months.".format(sorted(baseline_fallback_months))
+            )
+
         if progress:
             progress(total_units, total_units, "Complete")
 

apps/predbat/annual_store.py

@@ -309,3 +309,28 @@ async def backfill_summaries(storage, runs):
     if filled:
         await storage.save(STORAGE_MODULE, INDEX_NAME, runs, format="json")
     return runs
+
+
+async def delete_run(storage, run_id):
+    """Remove one run entirely - its document, its captured plans and its index entry.
+
+    Reuses the same discard path eviction uses, so a run the user deletes leaves no more
+    behind than one that aged out of the ring: the document and every plan key are
+    expired, not merely unlinked from the index. Storage has no ``delete`` method on the
+    real component, which is why discarding is overwrite-with-expiry rather than removal.
+
+    Returns True when a run was found and removed, False when the id matched nothing -
+    so the caller can tell "deleted" from "already gone" rather than reporting success
+    for a run that was never there.
+    """
+    if not storage or not run_id:
+        return False
+
+    index = await list_runs(storage)
+    entry = next((existing for existing in index if existing.get("id") == run_id), None)
+    if entry is None:
+        return False
+
+    await _discard_run(storage, run_id, entry.get("plan_keys"))
+    await storage.save(STORAGE_MODULE, INDEX_NAME, [existing for existing in index if existing.get("id") != run_id], format="json")
+    return True

apps/predbat/tariff_catalogue.py

@@ -24,6 +24,22 @@
 # The dropdown's escape hatch: leaves the URL fields blank for a hand-entered tariff
 CUSTOM_ID = "custom"
 
+# What a household with no PV and no battery is assumed to be on. Named here so the form
+# and the engine's own default cannot drift apart.
+BASELINE_DEFAULT_ID = "cap_seg"
+
+# Ofgem price cap, 1 July - 30 September 2026, direct debit, England/Scotland/Wales,
+# including VAT. Named rather than repeated so the next cap change is a one-line edit.
+# Source: https://www.ofgem.gov.uk/information-consumers/energy-advice-households/energy-price-cap-unit-rates-and-standing-charges
+PRICE_CAP_IMPORT_P = 26.11
+PRICE_CAP_STANDING_CHARGE_P = 57.19
+
+# A typical FIXED Smart Export Guarantee rate. Fixed SEG offers sit around 3-8p/kWh in
+# mid-2026, so this is deliberately at the conservative end - the smart export tariffs
+# that pay far more are separate entries in this catalogue, and a household on the price
+# cap is not on one of them.
+SEG_EXPORT_P = 4.1
+
 _OCTOPUS = "https://api.octopus.energy/v1/products"
 
 # The two Octopus flat-rate export products offered against each import tariff below.
@@ -42,11 +58,11 @@
 _OUTGOING_PRIME = "{}/OUTGOING-PRIME-FIX-12M-26-06-23/electricity-tariffs/E-1R-OUTGOING-PRIME-FIX-12M-26-06-23-{{dno_region}}/standard-unit-rates/".format(_OCTOPUS)
 
 BUILTIN_TARIFFS = [
-    {"id": "cap_seg", "name": "Price cap import / SEG export", "rates_import": [{"rate": 24.86}], "rates_export": [{"rate": 4.1}]},
+    {"id": "cap_seg", "name": "Price cap import / SEG export", "rates_import": [{"rate": PRICE_CAP_IMPORT_P}], "rates_export": [{"rate": SEG_EXPORT_P}]},
     {
         "id": "eon_next_drive",
         "name": "Eon Next Drive import / Fixed export",
-        "rates_import": [{"rate": 6.7, "start": "00:00:00", "end": "07:00:00"}, {"rate": 24.86, "start": "07:00:00", "end": "00:00:00"}],
+        "rates_import": [{"rate": 6.7, "start": "00:00:00", "end": "07:00:00"}, {"rate": PRICE_CAP_IMPORT_P, "start": "07:00:00", "end": "00:00:00"}],
         "rates_export": [{"rate": 16.5}],
     },
     {

apps/predbat/tests/test_annual_integration.py

@@ -329,6 +329,30 @@ def _run_car_config():
                 print("  ERROR: {}.{} = {} without capture but {} with capture - save is leaking into the billed numbers".format(key, field, without_capture[key][field], with_capture[key][field]))
                 failed = True
 
+    print("Test: the baseline tariff prices no_pvbat only and does not leak into the other scenarios")
+    # A flat price-cap-style baseline against the banded main tariff. Two properties
+    # matter and they pull in opposite directions: the counterfactual MUST change (or the
+    # feature does nothing), and every other scenario must be bit-for-bit identical (or
+    # the swap has leaked and silently repriced the system being evaluated). _apply_rates
+    # mutates predbat in place and replicates what it is given, so a leak here is a very
+    # live possibility rather than a theoretical one.
+    reset_inverter(my_predbat)
+    baseline_midnight = pytz.utc.localize(datetime(day.year, day.month, day.day))
+    baseline_load_source = SyntheticLoadProfile(annual_kwh=config["load"]["annual_kwh"], shape=config["load"]["shape"], year=config["year"])
+    flat_cap = StubTariff(cheap=26.11, normal=26.11, peak=26.11, export=4.1)
+    without_baseline = _run_scenarios(my_predbat, config, weather, StubTariff(), baseline_load_source, day, baseline_midnight, car_kwh=0.0, car_rate_kw=DEFAULT_CAR_RATE_KW)
+    reset_inverter(my_predbat)
+    with_baseline = _run_scenarios(my_predbat, config, weather, StubTariff(), baseline_load_source, day, baseline_midnight, car_kwh=0.0, car_rate_kw=DEFAULT_CAR_RATE_KW, baseline_tariff=flat_cap)
+
+    if abs(with_baseline["no_pvbat"]["cost_p"] - without_baseline["no_pvbat"]["cost_p"]) < 1.0:
+        print("  ERROR: a flat baseline tariff should reprice no_pvbat away from the banded main tariff, got {} vs {}".format(without_baseline["no_pvbat"]["cost_p"], with_baseline["no_pvbat"]["cost_p"]))
+        failed = True
+    for key in ["pv_only", "without_predbat", "with_predbat"]:
+        for field in SCENARIO_FIELDS:
+            if without_baseline[key][field] != with_baseline[key][field]:
+                print("  ERROR: {}.{} changed from {} to {} - the baseline tariff has leaked past no_pvbat".format(key, field, without_baseline[key][field], with_baseline[key][field]))
+                failed = True
+
     print("Test: capturing plans does not leak predbat.debug_enable on")
     # The annual "debug" flag means "save the plan info", nothing more - it must never be
     # wired to Predbat's own debug_enable, which kernel_supported() requires False to use