@@ -27,6 +27,60 @@
 # 3. Consider Octopus API key to access current tariff info and switch links
 
 
+# What Compare.run_all() saves before comparing tariffs and restores afterwards: every tariff fetches, plans and
+# predicts on the live instance. The plan state is what calculate_plan() writes that outlives the run - leaving
+# plan_preclip as the last tariff's plan once made the first re-plan after midnight score the wrong plan as the
+# plan in force. Add any new plan state calculate_plan() keeps across runs here.
+COMPARE_PLAN_STATE = (
+    "charge_window_best",
+    "charge_limit_best",
+    "export_window_best",
+    "export_limits_best",
+    "plan_preclip",
+    "end_record",
+    "plan_valid",
+    "plan_last_updated",
+    "plan_last_updated_minutes",
+    "rate_best_cost_threshold_charge",
+    "rate_best_cost_threshold_export",
+)
+# Battery and inverter values a tariff can override, reset after each tariff as well as at the end
+COMPARE_HARDWARE_STATE = ("soc_max", "battery_rate_max_charge", "battery_rate_max_charge_dc", "battery_rate_max_discharge", "battery_rate_max_export", "inverter_limit")
+COMPARE_RESTORED_STATE = (
+    COMPARE_PLAN_STATE
+    + COMPARE_HARDWARE_STATE
+    + (
+        "forecast_plan_hours",
+        "forecast_minutes",
+        "forecast_days",
+        "manual_charge_times",
+        "manual_export_times",
+        "manual_freeze_charge_times",
+        "manual_freeze_export_times",
+        "manual_demand_times",
+        "manual_all_times",
+        "cost_today_sofar",
+        "carbon_today_sofar",
+        "iboost_today",
+        "iboost_plan",
+        "import_today_now",
+        "export_today_now",
+        "octopus_intelligent_charging",
+        "soc_kw",
+    )
+)
+# Car state the comparison rebuilds per tariff, deep-copied as the lists are changed in place
+COMPARE_RESTORED_COPIES = (
+    "car_charging_plan_smart",
+    "car_charging_limit",
+    "car_charging_limit_model",
+    "car_charging_soc",
+    "car_charging_battery_size",
+    "car_charging_slots",
+    "car_charging_now_slots",
+)
+
+
 class Compare:
     """Tariff comparison engine.
 
@@ -605,43 +659,9 @@ def run_all(self, debug=False, fetch_sensor=True):
 
         my_predbat = self.pb
 
-        save_forecast_plan_hours = my_predbat.forecast_plan_hours
-        save_forecast_minutes = my_predbat.forecast_minutes
-        save_forecast_days = my_predbat.forecast_days
-        save_manual_charge_times = my_predbat.manual_charge_times
-        save_manual_export_times = my_predbat.manual_export_times
-        save_manual_freeze_charge_times = my_predbat.manual_freeze_charge_times
-        save_manual_freeze_export_times = my_predbat.manual_freeze_export_times
-        save_manual_demand_times = my_predbat.manual_demand_times
-        save_manual_all_times = my_predbat.manual_all_times
-        save_charge_window_best = my_predbat.charge_window_best
-        save_export_window_best = my_predbat.export_window_best
-        save_export_limits_best = my_predbat.export_limits_best
-        save_charge_limit_best = my_predbat.charge_limit_best
-        # The pre-clip copy of the plan in force, which the next re-plan scores as the previous plan; each tariff's
-        # calculate_plan() replaces it with its own plan
-        save_plan_preclip = my_predbat.plan_preclip
-        save_cost_today_sofar = my_predbat.cost_today_sofar
-        save_carbon_today_sofar = my_predbat.carbon_today_sofar
-        save_iboost_today = my_predbat.iboost_today
-        save_iboost_plan = my_predbat.iboost_plan
-        save_import_today_now = my_predbat.import_today_now
-        save_export_today_now = my_predbat.export_today_now
-        save_octopus_intelligent_charging = my_predbat.octopus_intelligent_charging
-        save_car_charging_plan_smart = copy.deepcopy(my_predbat.car_charging_plan_smart)
-        save_car_charging_limit = copy.deepcopy(my_predbat.car_charging_limit)
-        save_car_charging_limit_model = copy.deepcopy(my_predbat.car_charging_limit_model)
-        save_car_charging_soc = copy.deepcopy(my_predbat.car_charging_soc)
-        save_car_charging_battery_size = copy.deepcopy(my_predbat.car_charging_battery_size)
-        save_car_charging_slots = copy.deepcopy(my_predbat.car_charging_slots)
-        save_car_charging_now_slots = copy.deepcopy(my_predbat.car_charging_now_slots)
-        save_soc_kw = my_predbat.soc_kw
-        save_soc_max = my_predbat.soc_max
-        save_battery_rate_max_charge = my_predbat.battery_rate_max_charge
-        save_battery_rate_max_charge_dc = my_predbat.battery_rate_max_charge_dc
-        save_battery_rate_max_discharge = my_predbat.battery_rate_max_discharge
-        save_battery_rate_max_export = my_predbat.battery_rate_max_export
-        save_inverter_limit = my_predbat.inverter_limit
+        # Everything the comparison changes on the live instance, saved here and put back in the finally below
+        saved = {name: getattr(my_predbat, name) for name in COMPARE_RESTORED_STATE}
+        saved.update({name: copy.deepcopy(getattr(my_predbat, name)) for name in COMPARE_RESTORED_COPIES})
 
         # Final reports, cut end_record back to 24 hours to ignore the dump at end of day
         end_record = int((my_predbat.minutes_now + 24 * 60 + 29) / 30) * 30 - my_predbat.minutes_now
@@ -688,19 +708,18 @@ def run_all(self, debug=False, fetch_sensor=True):
                     # First ever run for this tariff: start from actual midnight SoC
                     start_soc = soc_midnight_fallback
                 self.log("Compare tariff {} starting SoC: {:.2f} kWh".format(tariff.get("id", ""), start_soc))
+                # Each tariff plans from scratch: scored against the previous tariff's plan, the keep-or-switch threshold
+                # in calculate_plan() could leave one tariff's result as another tariff's plan
+                my_predbat.plan_valid = False
                 try:
-                    result_data = self.run_single(tariff, rate_import_base, rate_export_base, end_record, debug=debug, fetch_sensor=fetch_sensor, car_charging_slots=save_car_charging_slots, start_soc=start_soc, io_adjusted_base=io_adjusted_base)
+                    result_data = self.run_single(tariff, rate_import_base, rate_export_base, end_record, debug=debug, fetch_sensor=fetch_sensor, car_charging_slots=saved["car_charging_slots"], start_soc=start_soc, io_adjusted_base=io_adjusted_base)
                     if result_data is not None:
                         results[tariff["id"]] = result_data
                 finally:
                     # Restore hardware settings after each tariff so overrides don't bleed into the next tariff;
                     # in a finally so a raised run_single() can't leave compare values applied to the live instance
-                    my_predbat.soc_max = save_soc_max
-                    my_predbat.battery_rate_max_charge = save_battery_rate_max_charge
-                    my_predbat.battery_rate_max_charge_dc = save_battery_rate_max_charge_dc
-                    my_predbat.battery_rate_max_discharge = save_battery_rate_max_discharge
-                    my_predbat.battery_rate_max_export = save_battery_rate_max_export
-                    my_predbat.inverter_limit = save_inverter_limit
+                    for name in COMPARE_HARDWARE_STATE:
+                        setattr(my_predbat, name, saved[name])
                     # Restore config: overrides after each tariff too, for the same reason - otherwise a
                     # tariff's config override stays applied to config_index for every subsequent tariff,
                     # even ones with no config block of their own (issue #4156)
@@ -725,39 +744,6 @@ def run_all(self, debug=False, fetch_sensor=True):
                 my_predbat.fetch_config_options()
 
             # Restore original settings
-            my_predbat.forecast_plan_hours = save_forecast_plan_hours
-            my_predbat.forecast_minutes = save_forecast_minutes
-            my_predbat.forecast_days = save_forecast_days
-            my_predbat.manual_charge_times = save_manual_charge_times
-            my_predbat.manual_export_times = save_manual_export_times
-            my_predbat.manual_freeze_charge_times = save_manual_freeze_charge_times
-            my_predbat.manual_freeze_export_times = save_manual_freeze_export_times
-            my_predbat.manual_demand_times = save_manual_demand_times
-            my_predbat.manual_all_times = save_manual_all_times
-            my_predbat.charge_window_best = save_charge_window_best
-            my_predbat.export_window_best = save_export_window_best
-            my_predbat.export_limits_best = save_export_limits_best
-            my_predbat.charge_limit_best = save_charge_limit_best
-            my_predbat.plan_preclip = save_plan_preclip
-            my_predbat.cost_today_sofar = save_cost_today_sofar
-            my_predbat.carbon_today_sofar = save_carbon_today_sofar
-            my_predbat.iboost_today = save_iboost_today
-            my_predbat.iboost_plan = save_iboost_plan
-            my_predbat.import_today_now = save_import_today_now
-            my_predbat.export_today_now = save_export_today_now
-            my_predbat.octopus_intelligent_charging = save_octopus_intelligent_charging
-            my_predbat.car_charging_limit = save_car_charging_limit
-            my_predbat.car_charging_limit_model = save_car_charging_limit_model
-            my_predbat.car_charging_soc = save_car_charging_soc
-            my_predbat.car_charging_battery_size = save_car_charging_battery_size
-            my_predbat.car_charging_slots = save_car_charging_slots
-            my_predbat.car_charging_now_slots = save_car_charging_now_slots
-            my_predbat.car_charging_plan_smart = save_car_charging_plan_smart
-            my_predbat.soc_kw = save_soc_kw
-            my_predbat.soc_max = save_soc_max
-            my_predbat.battery_rate_max_charge = save_battery_rate_max_charge
-            my_predbat.battery_rate_max_charge_dc = save_battery_rate_max_charge_dc
-            my_predbat.battery_rate_max_discharge = save_battery_rate_max_discharge
-            my_predbat.battery_rate_max_export = save_battery_rate_max_export
-            my_predbat.inverter_limit = save_inverter_limit
+            for name in COMPARE_RESTORED_STATE + COMPARE_RESTORED_COPIES:
+                setattr(my_predbat, name, saved[name])
             my_predbat.io_adjusted = io_adjusted_base
@@ -16,11 +16,14 @@
   - hardware isolation between tariffs: overrides applied for tariff N must not
     bleed into tariff N+1 in run_all() (regression for the bug where agile_fixed
     reported a final SOC larger than the normal battery size)
+  - run_all() restores every attribute it saves, the plan state calculate_plan() keeps across runs
+    included (regression for plan_preclip left as the last tariff's plan), and plans each tariff from scratch
+  - every attribute calculate_plan() assigns is either restored by run_all() or rebuilt on every run
 """
 
 import inspect
 
-from compare import Compare
+from compare import Compare, COMPARE_HARDWARE_STATE, COMPARE_PLAN_STATE, COMPARE_RESTORED_STATE, COMPARE_RESTORED_COPIES
 from const import MINUTE_WATT
 
 
@@ -68,28 +71,45 @@ def _make_compare():
     return cmp, pb
 
 
-def test_run_all_restores_plan_preclip(my_predbat):
-    """run_all() puts back the pre-clip copy of the plan in force, which each tariff's calculate_plan() replaces.
-
-    Left as the last tariff's 48-hour plan, the first re-plan after the midnight comparison scored that plan as the
-    previous one, so it always switched plans whatever metric_min_improvement_plan said (seen live on 9 Oct 2026:
-    previous plan 300.97p against 30.71p when the comparison is not run).
+# Assigned by calculate_plan() but rebuilt on every run before use, so the comparison need not restore them
+CALCULATE_PLAN_REBUILT = (
+    "load_minutes_step",
+    "load_minutes_step10",
+    "load_minutes_step90",
+    "pv_forecast_minute_step",
+    "pv_forecast_minute10_step",
+    "pv_forecast_minute90_step",
+    "prediction",
+    "metric_cloud_coverage",
+    "metric_load_divergence",
+    "plan_last_duration_seconds",
+)
+
+
+def test_run_all_restores_state(my_predbat):
+    """run_all() puts back everything it saves however a tariff's run changed it, resets the hardware values between
+    tariffs, and plans each tariff from scratch.
+
+    Each tariff fetches, plans and predicts on the live instance. Leaving plan_preclip as the last tariff's 48-hour
+    plan made the first re-plan after the midnight comparison score that plan as the plan in force, so it always
+    switched plans whatever metric_min_improvement_plan said (seen live on 9 Oct 2026: 300.97p against 30.71p).
     """
-    from compare import Compare
-
+    names = COMPARE_RESTORED_STATE + COMPARE_RESTORED_COPIES
+    original = {name: getattr(my_predbat, name) for name in names}
     saved_compare_list = my_predbat.args.get("compare_list")
-    saved_preclip = my_predbat.plan_preclip
-    plan_in_force = ([18.08], [{"start": 0, "end": 90, "average": 7.62}], [], [])
-    my_predbat.plan_preclip = plan_in_force
-    my_predbat.args["compare_list"] = [{"id": "test_tariff", "name": "Test tariff"}]
+    my_predbat.args["compare_list"] = [{"id": "tariff_a", "name": "Tariff A"}, {"id": "tariff_b", "name": "Tariff B"}]
     comparison = Compare.__new__(Compare)
     comparison.pb = my_predbat
     comparison.log = my_predbat.log
     comparison.comparisons = {}
+    seen_at_start = []
 
     def run_single(*args, **kwargs):
-        """Stand in for a tariff's run: its calculate_plan() replaces plan_preclip with that tariff's plan."""
-        my_predbat.plan_preclip = ([0.0], [{"start": 0, "end": 2880, "average": 30.0}], [], [])
+        """Stand in for a tariff's run, changing every saved attribute as fetching and planning a tariff can."""
+        seen_at_start.append((my_predbat.plan_valid, all(getattr(my_predbat, name) == original[name] for name in COMPARE_HARDWARE_STATE)))
+        for name in names:
+            setattr(my_predbat, name, ("changed by", name))
+        my_predbat.plan_valid = True
         return None
 
     comparison.run_single = run_single
@@ -98,24 +118,50 @@ def run_single(*args, **kwargs):
     comparison.publish_data = lambda *args, **kwargs: None
     try:
         comparison.run_all(fetch_sensor=False)
-        if my_predbat.plan_preclip is not plan_in_force:
-            print("ERROR: run_all() should restore the plan in force's pre-clip copy, got {}".format(my_predbat.plan_preclip))
-            return 1
-        print("PASS: run_all() restores plan_preclip")
-        return 0
+        failed = 0
+        not_restored = [name for name in names if getattr(my_predbat, name) != original[name]]
+        if not_restored:
+            print("ERROR: run_all() did not restore {}".format(not_restored))
+            failed = 1
+        if seen_at_start != [(False, True), (False, True)]:
+            print("ERROR: each tariff should start with plan_valid False and the real hardware values, got {}".format(seen_at_start))
+            failed = 1
+        if not failed:
+            print("PASS: run_all() restores all {} saved attributes, resets hardware between tariffs and plans each from scratch".format(len(names)))
+        return failed
     finally:
-        my_predbat.plan_preclip = saved_preclip
+        for name, value in original.items():
+            setattr(my_predbat, name, value)
         if saved_compare_list is None:
             my_predbat.args.pop("compare_list", None)
         else:
             my_predbat.args["compare_list"] = saved_compare_list
 
 
+def test_plan_state_covered(my_predbat):
+    """Every attribute calculate_plan() assigns is restored by the comparison or rebuilt on every run.
+
+    A new piece of plan state that outlives a run (as plan_preclip did) must be added to COMPARE_PLAN_STATE, or the
+    comparison will leave the last tariff's value behind.
+    """
+    import re
+
+    source = inspect.getsource(type(my_predbat).calculate_plan)
+    assigned = set(re.findall(r"self\.([a-z_0-9]+)\s*=(?!=)", source))
+    uncovered = sorted(assigned - set(COMPARE_PLAN_STATE) - set(CALCULATE_PLAN_REBUILT))
+    if uncovered:
+        print("ERROR: calculate_plan() assigns {} - add each to COMPARE_PLAN_STATE (compare.py) if it outlives the run, or to CALCULATE_PLAN_REBUILT here if it is rebuilt before use".format(uncovered))
+        return 1
+    print("PASS: every attribute calculate_plan() assigns is restored or rebuilt")
+    return 0
+
+
 def test_compare(my_predbat):
     """Run all compare unit tests."""
     failed = 0
     print("**** Running compare tests ****\n")
-    failed += test_run_all_restores_plan_preclip(my_predbat)
+    failed += test_run_all_restores_state(my_predbat)
+    failed += test_plan_state_covered(my_predbat)
 
     # ------------------------------------------------------------------
     # T1: apply_hardware_overrides – soc_max override
@@ -588,23 +634,13 @@ def _mock_plan_iboost_smart():
         print("PASS T18: bad export override value falls back to the discharge override")
 
     # ------------------------------------------------------------------
-    # T19: run_all() actually saves and restores battery_rate_max_export,
-    #      both mid-loop and at the end, so an export override can't bleed
-    #      into the next tariff (T7 only proves the pattern in isolation).
-    #      Positional checks (T12-style) so the snapshot must sit before the
-    #      tariff loop, not just anywhere in the source.
+    # T19: run_all() saves and restores battery_rate_max_export, after each
+    #      tariff and at the end, so an export override can't bleed into the
+    #      next tariff (T7 only proves the pattern in isolation; the restore
+    #      itself is exercised by test_run_all_restores_state)
     # ------------------------------------------------------------------
-    run_all_source = inspect.getsource(Compare.run_all)
-    loop_idx = run_all_source.find("for tariff in compare_list:")
-    snapshot_idx = run_all_source.find("save_battery_rate_max_export = my_predbat.battery_rate_max_export")
-    if loop_idx < 0 or snapshot_idx < 0:
-        print("ERROR T19: could not locate the tariff loop or the battery_rate_max_export snapshot in run_all() source - test may need updating")
-        failed += 1
-    elif not (snapshot_idx < loop_idx):
-        print("ERROR T19: battery_rate_max_export snapshot must appear before the tariff loop in run_all()")
-        failed += 1
-    elif run_all_source.count("my_predbat.battery_rate_max_export = save_battery_rate_max_export") < 2:
-        print("ERROR T19: run_all() must restore battery_rate_max_export both inside the tariff loop and at the end")
+    if "battery_rate_max_export" not in COMPARE_HARDWARE_STATE or "battery_rate_max_export" not in COMPARE_RESTORED_STATE:
+        print("ERROR T19: battery_rate_max_export must be reset after each tariff (COMPARE_HARDWARE_STATE) and at the end")
         failed += 1
     else:
         print("PASS T19: run_all() snapshots and restores battery_rate_max_export")
@@ -708,12 +744,8 @@ def _mock_plan_iboost_smart():
     #      restores it after it, as it does car_charging_slots, so the live plan
     #      gets its modelled slots back after a comparison (#5245 review)
     # ------------------------------------------------------------------
-    snapshot_idx = run_all_source.find("save_car_charging_now_slots = copy.deepcopy(my_predbat.car_charging_now_slots)")
-    if snapshot_idx < 0 or not (snapshot_idx < loop_idx):
-        print("ERROR T25: car_charging_now_slots must be snapshotted before the tariff loop in run_all()")
-        failed += 1
-    elif run_all_source.find("my_predbat.car_charging_now_slots = save_car_charging_now_slots") < loop_idx:
-        print("ERROR T25: run_all() must restore car_charging_now_slots after the tariff loop")
+    if "car_charging_now_slots" not in COMPARE_RESTORED_COPIES:
+        print("ERROR T25: run_all() must snapshot (deep copy) and restore car_charging_now_slots")
         failed += 1
     else:
         print("PASS T25: run_all() snapshots and restores car_charging_now_slots")