feat(plan): model-based clipping — prune plan slots that are dead in the central forecast (#4491)

* feat(plan): model-based clipping - prune plan slots dead in the central forecast

Follow-up to #4487. The heuristic clip branches each target one specific
failure shape (battery pinned empty, target unreachable, SoC flat above
limit), and #4453/#4478 showed new shapes keep appearing: every gate in the
pipeline is tuned for a different pathology, and dead slots thread between
them. Replace the guessing with a direct question to the model: remove the
slot, re-simulate, did the central forecast change?

prune_dead_plan_slots trials each active charge/export slot inside the
record window in turn - the slot is removed and the whole plan re-simulated
in the nominal (50%) scenario only, one simulation per trial via a new
run_prediction_metric(nominal_only=True) option (skips pv10 and pv90). The
removal is kept when the nominal metric does not get worse, so slots whose
value exists only in the pessimistic branches - or nowhere at all - are
dropped. If the pv10/pv90 conditions materialise in reality, the next plan
recompute re-creates a genuine slot from actual state.

The pass runs after the pre-clip scoring snapshot, so plan selection still
compares plans as optimised (#4403). In-progress windows are never trialled
(the #4402 commitment - the clip_export_slots phantom branch from #4487
remains as the complementary catch for that case), manual windows are
preserved, and each accepted removal updates the running baseline so one
removal cannot make the next look free.

Random benchmark over 20 scenarios against main: 114 slots pruned, nominal
cost of the executed plan never worse than +0.012p (the per-trial epsilon)
and dramatically better on two scenarios (-35.18p, -71.61p - plans were
carrying slots that cost real money in the central forecast for pessimistic
-branch insurance); the pv-weighted metric of the executed plan gives back
+0.62p on average (max +5.05p) where pure insurance was stripped, which is
the designed trade. Plan runtime unchanged (1.33s avg both sides).

Debug case expected files regenerated: agile1's pruned plan is 1.31p
cheaper nominally (metric-neutral), pre_saving1's is cost-identical with a
+0.21p pv10 residual.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* refactor(plan): drop the clip removal branches now subsumed by the prune

prune_dead_plan_slots decides whether a slot achieves anything by asking the
model, which makes the trajectory-based removal heuristics in clip_charge_slots
and clip_export_slots redundant. Instrumenting every branch across the 20
scenario benchmark shows the removal branches fire 31 times with the prune
disabled and 0 times with it enabled, while both clip-up branches keep firing
unchanged (111 fires). The same holds on the real captures from #4453/#4478.

Removed: freeze-export-at-100%, no-SoC-above-reserve (#4171/#4434), phantom
export (#4453/#4487), export target-unreachable, and charge
never-reaches-limit. What remains in both functions is limit adjustment only -
narrowing a requested limit to what the window can actually achieve, so the
target sent to the inverter matches the simulated plan and adjacent windows
merge. The charge freeze-to-charge-at-100% conversion is kept: it rewrites a
limit rather than removing a window, and covers windows the prune skips.

The prune deliberately does not trial a window covering the current minute
(#4402), so an in-progress phantom is no longer converted in place; it is
re-planned on the next cycle from real inverter state instead.

Random benchmark over 20 scenarios before vs after this removal: plan metric
and cost identical 20/20, runtime unchanged. Debug cases pass unchanged - the
expected files regenerated for the prune itself needed no further update, which
is independent evidence the branches were dead.

Tests that asserted the removed behaviour are rewritten to assert the new
contract (clipping adjusts limits and never removes); the removal behaviour
they covered is now exercised by the prune tests and the debug case regression.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(plan): let the prune trial in-progress slots too

The prune skipped any window covering the current minute, on the grounds that
#4402 forbids cancelling an in-progress export. That over-applied the guard:
#4402's regression came from writing back a change scored on optimise_export's
adjusted metric (commitment bonus plus tie-break weightings) with no check that
the whole plan improved, and its fix was to gate on the unadjusted whole-plan
metric - exactly what the prune trial already uses. An in-progress export worth
anything fails that gate and is kept.

Skipping it also left the worst gap: the in-progress window is the slot being
executed right now, so a dead one there is precisely the spurious command that
reaches the inverter - and since the clip removal branches were dropped in
favour of the prune, nothing covered it at all.

Probing the 20 scenario benchmark, all 15 in-progress slots are worth real
money to keep (+0.41p to +25.91p if removed), so none are pruned and the plans
are identical 20/20 on metric and cost. Runtime +0.03s average for the extra
trials.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* test(random): start scenarios part way through a plan slot

Every scenario ran from the template's minutes_now of 08:00, exactly on a
30 minute boundary, so a window covering the current minute always had its
full length remaining. Partially-elapsed slots - the shape that matters for
in-progress pruning and for anything that reasons about the remainder of the
window being executed - were never generated.

Scenarios now carry a clock offset sampled from 0/5/10/15/20/25 minutes (5
minutes being predbat's run cadence) and start that far into the slot. The
offset is drawn last in the generator's random sequence, so re-generating an
existing seed leaves every other parameter unchanged, and it is applied from
the slot boundary rather than the current clock so that applying scenarios in
a loop cannot accumulate offsets.

Scenario files written before this carry no "clock" entry and keep the
template's own minutes_now: re-running the committed cases/random_scenarios.yaml
gives metric and cost identical to before on all 20, so previously recorded
benchmark results stay comparable.

A freshly generated set has 16 of 20 scenarios starting mid-slot and produces
in-progress windows with 5, 15 and 25 minutes remaining (previously always 30).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* test(random): randomise scenario start time, and cover the whole PV horizon

Replaces the within-slot clock offset with a random minute-of-day (still on
predbat's 5 minute cadence), so scenarios start at every point of the tariff
and solar day - overnight cheap windows, the evening peak, mid-generation -
rather than all at the template's 08:00. Start times in the regenerated set
span 00:10 to 22:10 with 15 of 20 landing off a 30 minute boundary, so
partially-elapsed slots are now generated as a matter of course.

Fixes a harness bug the randomisation would otherwise have made much worse:
step_data_history reads forward series at (minute + minutes_now), but
expand_pv_forecast only generated 0..forecast_minutes, so the tail of every
horizon silently had no PV at all - 8 hours' worth even at the fixed 08:00
start, and nearly the whole horizon for a scenario starting late in the day.
It now runs to minutes_now + forecast_minutes.

cases/random_scenarios.yaml is regenerated, which resets the benchmark
baseline: the scenarios are substantially richer (mean optimise time 1.3s ->
12.9s, because the horizon now actually contains solar), so results are not
comparable with runs recorded before this commit.

Re-measured on the new set, prune vs the pre-prune base: nominal cost better
by 3.36p on average (best -43.21p, worst +0.06p, which is within the
accumulated per-trial epsilon), pv-weighted metric +0.25p on average as pure
pessimistic-branch insurance is stripped, optimise time +0.8s (6%).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: springfall2008

apps/predbat/plan.py

@@ -17,7 +17,7 @@ def run_clip_charge_slots_tests(my_predbat):
     failed = False
     failed |= test_disabled_window_ignored(my_predbat)
     failed |= test_passed_window_clipped(my_predbat)
-    failed |= test_clip_off_soc_above_limit(my_predbat)
+    failed |= test_clip_left_alone_soc_above_limit(my_predbat)
     failed |= test_clip_off_preserves_reserve(my_predbat)
     failed |= test_clip_up_soc_max_below_limit(my_predbat)
     failed |= test_clip_up_soc_max_within_margin_of_limit(my_predbat)
@@ -122,25 +122,23 @@ def test_passed_window_clipped(my_predbat):
     return failed
 
 
-def test_clip_off_soc_above_limit(my_predbat):
-    """Charge window should be clipped off when soc_min is well above the charge limit"""
-    print("**** test_clip_charge_off_soc_above_limit ****")
+def test_clip_left_alone_soc_above_limit(my_predbat):
+    """Clipping no longer removes a charge window whose SoC is already above the limit - deciding a slot
+    achieves nothing is prune_dead_plan_slots' job, which asks the model instead of the SoC trace"""
+    print("**** test_clip_charge_left_alone_soc_above_limit ****")
     failed = False
     setup(my_predbat)
 
     minutes_now = 720
     windows = [make_window(720, 750)]
     limits = [3.0]  # Charge to 3 kWh (30% of 10)
-    # SoC at 8 kWh (80%) which is well above 30% + 1%
+    # SoC at 8 kWh (80%) which is well above the limit - nothing to charge
     predict_soc = make_predict_soc(minutes_now, 8.0, 60)
 
     result_windows, result_limits = my_predbat.clip_charge_slots(minutes_now, predict_soc, windows, limits, 1, 5)
 
-    if result_limits[0] != 0:
-        print("ERROR: Expected charge window clipped off (0) but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 0:
-        print("ERROR: Expected target 0 but got {}".format(result_windows[0]["target"]))
+    if result_limits[0] != 3.0:
+        print("ERROR: Charge limit was modified by clipping, expected 3.0 but got {}".format(result_limits[0]))
         failed = True
 
     if not failed:
@@ -457,14 +455,14 @@ def test_multiple_windows_mixed(my_predbat):
 
     minutes_now = 720
     windows = [
-        make_window(720, 750),  # Window 0: SoC well above limit -> clip off
+        make_window(720, 750),  # Window 0: SoC well above limit -> left alone (prune removes it)
         make_window(780, 810),  # Window 1: freeze charge at 100% SoC -> convert to full charge
         make_window(840, 870),  # Window 2: SoC below limit -> clip up
     ]
     limits = [3.0, my_predbat.reserve, 8.0]
 
     predict_soc = {}
-    # Window 0: relative minutes 0-30, SoC at 8.0, limit is 3.0 (30%) -> clip off
+    # Window 0: relative minutes 0-30, SoC at 8.0, limit is 3.0 (30%) -> left alone
     for minute in range(0, 35, 5):
         predict_soc[minute] = 8.0
     # Window 1: relative minutes 60-90, SoC at soc_max -> freeze charge to full charge
@@ -476,9 +474,9 @@ def test_multiple_windows_mixed(my_predbat):
 
     result_windows, result_limits = my_predbat.clip_charge_slots(minutes_now, predict_soc, windows, limits, 3, 5)
 
-    # Window 0: clipped off
-    if result_limits[0] != 0:
-        print("ERROR: Window 0 expected clipped off (0) but got {}".format(result_limits[0]))
+    # Window 0: SoC already above the limit - clipping leaves it alone now (removal is the prune's job)
+    if result_limits[0] != 3.0:
+        print("ERROR: Window 0 expected left alone at 3.0 but got {}".format(result_limits[0]))
         failed = True
 
     # Window 1: freeze charge at 100% -> converted to soc_max

apps/predbat/tests/test_clip_charge_slots.py

@@ -15,17 +15,12 @@ def run_clip_export_slots_tests(my_predbat):
     Tests for clip_export_slots method
     """
     failed = False
-    failed |= test_freeze_export_clipped_at_100_soc(my_predbat)
-    failed |= test_freeze_export_manual_preserved_at_100_soc(my_predbat)
+    failed |= test_freeze_export_left_alone_at_100_soc(my_predbat)
     failed |= test_freeze_export_kept_when_soc_below_max(my_predbat)
-    failed |= test_normal_export_clipped_off_when_soc_below_limit(my_predbat)
+    failed |= test_normal_export_left_alone_when_soc_below_limit(my_predbat)
     failed |= test_normal_export_clipped_up_when_soc_above_limit(my_predbat)
-    failed |= test_normal_export_clipped_off_when_soc_never_above_reserve(my_predbat)
     failed |= test_normal_export_clipped_up_when_soc_above_reserve_with_zero_limit(my_predbat)
-    failed |= test_normal_export_clipped_to_freeze_when_soc_flat_above_limit(my_predbat)
-    failed |= test_normal_export_clipped_off_when_soc_flat_at_full(my_predbat)
-    failed |= test_normal_export_clipped_off_when_soc_flat_and_freeze_unsupported(my_predbat)
-    failed |= test_manual_export_preserved_when_soc_flat_above_limit(my_predbat)
+    failed |= test_normal_export_clipped_up_when_soc_flat_above_limit(my_predbat)
     failed |= test_disabled_window_ignored(my_predbat)
     failed |= test_passed_window_clipped(my_predbat)
     failed |= test_multiple_windows_mixed(my_predbat)
@@ -64,9 +59,10 @@ def setup(my_predbat):
     my_predbat.manual_export_times = []
 
 
-def test_freeze_export_clipped_at_100_soc(my_predbat):
-    """Freeze export (limit=99) should be clipped to 100 when SoC is at soc_max throughout the window"""
-    print("**** test_freeze_export_clipped_at_100_soc ****")
+def test_freeze_export_left_alone_at_100_soc(my_predbat):
+    """Clipping no longer removes a freeze export that sits at 100% SoC - deciding a slot achieves
+    nothing is prune_dead_plan_slots' job now, so clipping must leave the limit untouched"""
+    print("**** test_freeze_export_left_alone_at_100_soc ****")
     failed = False
     setup(my_predbat)
 
@@ -77,40 +73,8 @@ def test_freeze_export_clipped_at_100_soc(my_predbat):
 
     result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
 
-    if result_limits[0] != 100.0:
-        print("ERROR: Expected limit 100.0 but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 100:
-        print("ERROR: Expected target 100 but got {}".format(result_windows[0]["target"]))
-        failed = True
-
-    if not failed:
-        print("PASS")
-    return failed
-
-
-def test_freeze_export_manual_preserved_at_100_soc(my_predbat):
-    """Manual freeze export (limit=99) should NOT be clipped even when SoC is at soc_max (bug fix for #3657)"""
-    print("**** test_freeze_export_manual_preserved_at_100_soc ****")
-    failed = False
-    setup(my_predbat)
-
-    minutes_now = 720
-    window_start = 720
-    windows = [make_window(window_start, 750)]
-    limits = [99.0]
-    predict_soc = make_predict_soc(minutes_now, my_predbat.soc_max, 60)
-
-    # Mark this window as a manual freeze export
-    my_predbat.manual_freeze_export_times = [window_start]
-
-    result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
-
     if result_limits[0] != 99.0:
-        print("ERROR: Manual freeze export was clipped! Expected limit 99.0 but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 99.0:
-        print("ERROR: Manual freeze export target changed! Expected 99.0 but got {}".format(result_windows[0]["target"]))
+        print("ERROR: Freeze export was modified by clipping, expected 99.0 but got {}".format(result_limits[0]))
         failed = True
 
     if not failed:
@@ -141,25 +105,23 @@ def test_freeze_export_kept_when_soc_below_max(my_predbat):
     return failed
 
 
-def test_normal_export_clipped_off_when_soc_below_limit(my_predbat):
-    """Normal export window should be clipped off (set to 100) when soc_max < limit_soc"""
-    print("**** test_normal_export_clipped_off_when_soc_below_limit ****")
+def test_normal_export_left_alone_when_soc_below_limit(my_predbat):
+    """A window whose SoC never reaches its export target is no longer clipped off here - removal is
+    prune_dead_plan_slots' job. Clipping only narrows limits towards what is achievable, and there is
+    nothing to narrow when the battery is below the target."""
+    print("**** test_normal_export_left_alone_when_soc_below_limit ****")
     failed = False
     setup(my_predbat)
 
     minutes_now = 720
     windows = [make_window(720, 750)]
-    limits = [50.0]  # Export at 50%
-    # SoC well below the 50% export limit (limit_soc = 10 * 50/100 = 5.0, soc_max in window = 2.0)
-    predict_soc = make_predict_soc(minutes_now, 2.0, 60)
+    limits = [50.0]  # Export at 50% (limit_soc = 5.0)
+    predict_soc = make_predict_soc(minutes_now, 2.0, 60)  # SoC well below the target
 
     result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
 
-    if result_limits[0] != 100.0:
-        print("ERROR: Expected export clipped off (100.0) but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 100.0:
-        print("ERROR: Expected target 100.0 but got {}".format(result_windows[0]["target"]))
+    if result_limits[0] != 50.0:
+        print("ERROR: Export limit was modified by clipping, expected 50.0 but got {}".format(result_limits[0]))
         failed = True
 
     if not failed:
@@ -191,34 +153,6 @@ def test_normal_export_clipped_up_when_soc_above_limit(my_predbat):
     return failed
 
 
-def test_normal_export_clipped_off_when_soc_never_above_reserve(my_predbat):
-    """A window whose SoC never rises above reserve has nothing exportable and should be clipped off,
-    even when the requested limit is 0% (drain to empty) - regression test for #4171"""
-    print("**** test_normal_export_clipped_off_when_soc_never_above_reserve ****")
-    failed = False
-    setup(my_predbat)
-    my_predbat.reserve = 0.5
-
-    minutes_now = 720
-    windows = [make_window(720, 750)]
-    limits = [0.0]  # Export to 0% (drain to empty)
-    # SoC flat at reserve throughout the window - nothing above reserve to export
-    predict_soc = make_predict_soc(minutes_now, 0.5, 60)
-
-    result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
-
-    if result_limits[0] != 100.0:
-        print("ERROR: Expected export clipped off (100.0) but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 100.0:
-        print("ERROR: Expected target 100.0 but got {}".format(result_windows[0]["target"]))
-        failed = True
-
-    if not failed:
-        print("PASS")
-    return failed
-
-
 def test_normal_export_clipped_up_when_soc_above_reserve_with_zero_limit(my_predbat):
     """A 0% export request should still be clipped up (not off) when SoC genuinely rises above reserve,
     so the reserve-floor check doesn't swallow the existing clip-up behaviour"""
@@ -244,111 +178,25 @@ def test_normal_export_clipped_up_when_soc_above_reserve_with_zero_limit(my_pred
     return failed
 
 
-def test_normal_export_clipped_to_freeze_when_soc_flat_above_limit(my_predbat):
-    """A forced export window whose predicted SoC stays flat above the requested limit moved no energy in
-    the simulation (e.g. PV already saturates the export limit) - a phantom export. In the simulation the
-    window pinned SoC (blocking charge like a freeze does), so convert it to freeze export (99) to keep
-    the executed plan faithful to what was scored, while removing the force-export command that would
-    dump to grid if PV dips - regression test for the lone-export artifact in #4453.
-    If conditions later worsen (the PV10 case), a genuine export re-appears on a subsequent plan."""
-    print("**** test_normal_export_clipped_to_freeze_when_soc_flat_above_limit ****")
-    failed = False
-    setup(my_predbat)
-    my_predbat.set_export_freeze = True
-
-    minutes_now = 720
-    windows = [make_window(720, 750)]
-    limits = [50.0]  # Export to 50% (limit_soc = 5.0)
-    # SoC flat at 8.0 for the whole window: the commanded drain to 5.0 never happened
-    predict_soc = make_predict_soc(minutes_now, 8.0, 60)
-
-    result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
-
-    if result_limits[0] != 99.0:
-        print("ERROR: Expected phantom export converted to freeze (99.0) but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 99.0:
-        print("ERROR: Expected target 99.0 but got {}".format(result_windows[0]["target"]))
-        failed = True
-
-    if not failed:
-        print("PASS")
-    return failed
-
-
-def test_normal_export_clipped_off_when_soc_flat_at_full(my_predbat):
-    """A phantom export whose flat SoC is at soc_max must be clipped off (100), not converted to freeze:
-    the native freeze rule clips a 99 window off when SoC is pinned at 100%, and the conversion must not
-    produce a freeze window that rule would have removed (review finding on #4487)"""
-    print("**** test_normal_export_clipped_off_when_soc_flat_at_full ****")
-    failed = False
-    setup(my_predbat)
-    my_predbat.set_export_freeze = True
-
-    minutes_now = 720
-    windows = [make_window(720, 750)]
-    limits = [50.0]
-    # SoC pinned at full for the whole window: the drain never happened AND a freeze would be pointless
-    predict_soc = make_predict_soc(minutes_now, my_predbat.soc_max, 60)
-
-    result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
-
-    if result_limits[0] != 100.0:
-        print("ERROR: Expected phantom export at full SoC clipped off (100.0) but got {}".format(result_limits[0]))
-        failed = True
-    if result_windows[0]["target"] != 100.0:
-        print("ERROR: Expected target 100.0 but got {}".format(result_windows[0]["target"]))
-        failed = True
-
-    if not failed:
-        print("PASS")
-    return failed
-
-
-def test_normal_export_clipped_off_when_soc_flat_and_freeze_unsupported(my_predbat):
-    """The phantom-export conversion falls back to off (100) when set_export_freeze is disabled, since a
-    freeze window cannot be executed on such systems"""
-    print("**** test_normal_export_clipped_off_when_soc_flat_and_freeze_unsupported ****")
+def test_normal_export_clipped_up_when_soc_flat_above_limit(my_predbat):
+    """A phantom-shaped window (SoC flat, above the requested limit) now only has its limit narrowed by
+    clipping - removing it is prune_dead_plan_slots' job, which asks the model rather than the SoC trace"""
+    print("**** test_normal_export_clipped_up_when_soc_flat_above_limit ****")
     failed = False
     setup(my_predbat)
-    my_predbat.set_export_freeze = False
 
     minutes_now = 720
     windows = [make_window(720, 750)]
-    limits = [50.0]
-    predict_soc = make_predict_soc(minutes_now, 8.0, 60)
+    limits = [50.0]  # limit_soc = 5.0
+    predict_soc = make_predict_soc(minutes_now, 8.0, 60)  # flat, above the target
 
     result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
 
-    if result_limits[0] != 100.0:
-        print("ERROR: Expected phantom export clipped off (100.0) without freeze support but got {}".format(result_limits[0]))
+    if result_limits[0] in (99.0, 100.0):
+        print("ERROR: Clipping removed/converted the window instead of narrowing it, got {}".format(result_limits[0]))
         failed = True
-
-    if not failed:
-        print("PASS")
-    return failed
-
-
-def test_manual_export_preserved_when_soc_flat_above_limit(my_predbat):
-    """A manually forced export window must not be clipped off by the phantom-export prune even when the
-    simulation shows no energy moving - the user asked for it explicitly"""
-    print("**** test_manual_export_preserved_when_soc_flat_above_limit ****")
-    failed = False
-    setup(my_predbat)
-
-    minutes_now = 720
-    window_start = 720
-    windows = [make_window(window_start, 750)]
-    limits = [50.0]
-    predict_soc = make_predict_soc(minutes_now, 8.0, 60)
-
-    # Mark this window as a manual export
-    my_predbat.manual_export_times = [window_start]
-
-    result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 1, 5)
-
-    if result_limits[0] == 100.0:
-        print("ERROR: Manual export was clipped off by the phantom-export prune")
+    if result_limits[0] <= 50.0:
+        print("ERROR: Expected the limit to be clipped up from 50.0, got {}".format(result_limits[0]))
         failed = True
 
     if not failed:
@@ -411,9 +259,9 @@ def test_multiple_windows_mixed(my_predbat):
 
     minutes_now = 720
     windows = [
-        make_window(720, 750),  # Window 0: freeze export at 100% SoC (should be clipped)
-        make_window(750, 780),  # Window 1: manual freeze export at 100% SoC (should be preserved)
-        make_window(780, 810),  # Window 2: normal export (should remain)
+        make_window(720, 750),  # Window 0: freeze export at 100% SoC (left alone)
+        make_window(750, 780),  # Window 1: manual freeze export at 100% SoC (left alone)
+        make_window(780, 810),  # Window 2: normal export (limit clipped up)
     ]
     limits = [99.0, 99.0, 50.0]
 
@@ -427,12 +275,12 @@ def test_multiple_windows_mixed(my_predbat):
 
     result_windows, result_limits = my_predbat.clip_export_slots(minutes_now, predict_soc, windows, limits, 3, 5)
 
-    # Window 0: auto freeze export at 100% SoC -> clipped to 100
-    if result_limits[0] != 100.0:
-        print("ERROR: Window 0 (auto freeze at 100% SoC) expected 100.0 but got {}".format(result_limits[0]))
+    # Window 0: freeze export is never modified by clipping now
+    if result_limits[0] != 99.0:
+        print("ERROR: Window 0 (freeze at 100% SoC) expected 99.0 but got {}".format(result_limits[0]))
         failed = True
 
-    # Window 1: manual freeze export at 100% SoC -> preserved at 99
+    # Window 1: manual freeze export likewise untouched
     if result_limits[1] != 99.0:
         print("ERROR: Window 1 (manual freeze at 100% SoC) expected 99.0 but got {}".format(result_limits[1]))
         failed = True