UX-53 review: DECISIONS text, day/night weekend case and peak guard limit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
UX-53: Home draws a grid charge only where the add-on will take it
2026-10-26 13:10:49 +01:00 · 2026-10-26 11:15:29 +01:00
27 changed files with 793 additions and 1801 deletions
@@ -1,60 +1,5 @@
 # Changelog

-## 0.19.2
-
-**A patch bump: one fix for charging from the grid under the peak limit, and no option changes.**
-No option was added, removed or renamed, and no default changed (86 options).
-**Existing installs need no option change:** options that start 0.19.1 also
-start 0.19.2. The change below applies with one inverter or two.
-
-**Charging from the grid now stays under this month's peak.** A late meter reading near a period's end could push a grid charge to full power. That could take the 15-minute period over the peak. Now the charge is cut back, with one inverter too. The peak guard line no longer says "under" when the period is over.
-
-Contents of this release, in merge order since 0.19.1 (`2932f3a`):
-
-| | |
-|---|---|
-| `SAFETY-125` | A grid charge (a battery mode's cheap run, price trading or the maintenance charge, with one inverter or two) counts the seconds since a late meter reading at that reading, so it is cut back near the end of a 15-minute period instead of going back to full power. With one inverter the maintenance charge is now held to the room left in the period, as with two, so the peak guard no longer steps in and gives power at the period's end. Over the limit at the current rate, the peak guard row and the month peak line say so, and that the grid charge is cut back ([[SAFETY-125]]). |
-
-### Known issues
-
-The list under `## 0.19.0` below still applies. The SAFETY-99 line there now
-covers the guard's discharge only, not a grid charge.
-
-### If you are crossing from a version older than 0.10.0
-
-`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
-withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
-`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
-bare options (`jq '.data.options'`) first.
-
-## 0.19.1
-
-**A patch bump: two fixes for battery modes, and no option changes.**
-No option was added, removed or renamed, and no default changed (86 options).
-**Existing installs need no option change:** options that start 0.19.0 also
-start 0.19.1. The changes below apply with one inverter or two.
-
-**Battery modes now see a day/night or fixed tariff.** With battery modes on, a day/night or fixed tariff and no price service, the batteries never got the prices: "Cheap hours" never charged from the grid at the cheap rate, and the Batteries screen said "No prices". They get them now, with no price service and no internet call added.
-
-**A solar forecast now counts for the price gap.** With battery modes on and a solar forecast read, a price mode needs a gap of at least *Battery cycle cost*, not 1.5 times that. Without a forecast it is still 1.5 times. A day/night gap of 0.08 now works at a cycle cost of 0.07 or less.
-
-Contents of this release, in merge order since 0.19.0 (`793a676`):
-
-| | |
-|---|---|
-| `TARIFF-24` | With battery modes on, the add-on now also resolves the tariff when no price service and no price trading are set, so a day/night or fixed tariff gives the batteries their price runs ([[TARIFF-24]]). With battery modes on and a solar forecast read, the price gap a mode needs is *Battery cycle cost* (widened only for a real-time feed), not 1.5 times that; Home and the Batteries screen use the same rule ([[AUDIT-02]] F1). |
-
-### Known issues
-
-The list under `## 0.19.0` below still applies.
-
-### If you are crossing from a version older than 0.10.0
-
-`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
-withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
-`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
-bare options (`jq '.data.options'`) first.
-
 ## 0.19.0

 **A minor bump: price trading behaves differently, plus a fix for a false warning, the Home price chart in 15-minute bars, more Dutch text and EMS-port wording, and no option changes.**
@@ -1,10 +0,0 @@
-# SAFETY-125 - a grid charge under the month peak
-
-**Status: FIXED in 0.19.2 (hotfix from 0.19.1).** Tests: `test_safety125.py`.
-
-A grid charge is sized by `peakguard.charge_room_w()`, the guard's headroom
-with the seconds since a late meter reading counted at that reading (the
-projection leaves them out, SAFETY-99, the bill does not), and the guard's own
-floor is unchanged. At N=1 the maintenance charge is now sized too (owner
-2026-10-29; SAFETY-84 had left it out). Evidence (repro on 0.19.1, sweep,
-digests): the SAFETY-125 pull request.
@@ -39,8 +39,7 @@ was fine.
 **Not changed.**
 - At N=1 the charge is not sized to the headroom: the guard still suspends it
  and the battery gives until the quarter is safe. The same sizing would fit
-  there; that is an owner question, not this fix. (SAFETY-125, 0.19.2: the
-  owner said yes, and N=1 is sized the same way.)
+  there; that is an owner question, not this fix.
 - Outside a cheap window (`hi = 0`, solar only) nothing is filed, at any N.
 - A HOLD (later fixed by [[SAFETY-86]]) and the "Battery is not keeping up"
  alarm (SAFETY-85) are untouched. In the identity runs that alarm's log line
@@ -1,66 +0,0 @@
-# TARIFF-24 - battery modes need the tariff task
-
-**Status: FIXED in 0.19.1 (hotfix from 0.19.0, owner go 2026-10-28).**
-Follows TARIFF-10 (fetching is not trading). Tests: `test_tariff24.py`.
-
-**The defect.** The control cycle gets prices only from
-`Controller.tariff_plan`, which only `run_tariff_refresh()` stores. `amain()`
-starts that task when `tariff_refresh_wanted(opts)`, which was
-`provider_configured(opts) or arbitrage.enabled(opts)`. Battery modes read the
-plan but were not a term. With battery modes on, a day/night or fixed
-`static_profile`, `price_provider: off` and `arbitrage_enabled: false` (the
-site trade switch is not read with modes on) no task ran. Then
-`fresh_tariff_plan()` was None, `_price_runs()` was None and `mode_runs` was
-None, so Leftover solar and Cheap hours never charged from the grid. The
-Batteries screen said "No prices, so it follows the house" while Home priced
-the day from `static_plan()` itself (`homeview.build_plan()`).
-
-**The fix** (`main.py`, `tariff_refresh_wanted()`). `packmode.enabled(opts)`
-is a third term. The gate stays a widening: nothing that started the task
-before stops. No HTTPS call is added: with `price_provider: off`,
-`resolve_tariff()` is the pure `static_plan()`.
-
-**Not changed.** Modes off, arbitrage off, no feed still starts no task. The
-control law, the price runs and every message are untouched.
-
-**One rule, not two.** Gating on "modes on and a static profile" was
-considered. It saves one arithmetic pass every 30 min on a site with modes on
-and no prices at all, and it adds a second condition that has to track what
-`resolve_tariff()` accepts. With no profile and no feed the plan is `no_data`,
-exactly what the cycle sees without the task.
-
-**UX-55.** Home said "no prices have arrived" (`mode_runs` None) with every
-battery on Solar first. The same cause, and this fix clears it for a site with
-a static profile (`test_tariff24.py` part 5). A site with no profile and no
-feed still has no prices, and Home still says so.
-
-## Round 2 (AUDIT-02 F1): the forecast replaces the "no weather" doubt
-
-**Decided 2026-10-28 (owner), in the same hotfix.** The price gap a mode needs
-was `cycle_cost_threshold_eur` x 1.5 (`Uncertainty.NO_WEATHER`) whether or not
-a solar forecast was read. At the shipped cost 0.10 that is 0.15, so a
-day/night gap (0.08) and many dynamic days never traded, and the screens said
-only "Prices differ too little".
-
-**Why the doubt goes with a forecast.** The widening stands in for not knowing
-the weather. The forecast is that knowledge, and the day plan already trusts it
-for how much to charge. Trusting it for the plan but doubting it for the gap
-was one input judged twice.
-
-**The rule** (`arbitrage.weather_uncertainty()`). With battery modes on and a
-usable forecast (`solar_fc` not None, the day plan's own test) the doubt is
-not added: the gap needed is the cycle cost, widened by the price product only.
-No forecast, or a stale or unusable one: 1.5 x, as before. It is read in three
-places that must agree: the run plan (`_price_runs()`), the charge gate
-(`_mode_roles()`) and Home's mirror (`homeview.trade_verdict()`). The forecast
-is read at most every 60 s and the plan key already holds "forecast or not", so
-the gap follows in the cycle the read changes, both ways, with one exception:
-a run planned with a forecast that is under way keeps that gap to its end
-(`Controller.weather_held()`), so a sensor that goes unavailable does not stop
-or restart a charge. The wider gap applies from the next run.
-
-**Not changed.** Modes off (the site trade) keeps the doubt always. The
-shipped cost 0.10 still needs a gap of 0.10 even with a forecast: a 0.08
-day/night site must set *Battery cycle cost* to 0.08 or less. Showing the two
-numbers on the screens (AUDIT-02 F1 option b) is a separate card.
-
@@ -0,0 +1,40 @@
+# UX-53 - Home draws a grid charge only where the add-on will take it
+
+**Status: DONE 2026-10-26 (owner go 2026-10-25, from the PRICE-02 rig test F-1 and F-2).**
+
+## Decision
+
+Home asks the add-on's own gate, and does not decide for itself.
+
+- **Modes on.** `Controller._mode_roles()` files the gate it just asked
+  (`TariffPlan.arbitrage()` with the measured peak guard) as `mode_gate`: None
+  when it allowed a charge, else its reason (`peak`, `not_worth`,
+  `not_covered`). While it is set, `homeview.mode_runs()` draws no grid charge
+  and `price_windows()` marks no cheap quarter. Control never reads it. A
+  refusal that is not the gate (no measured headroom, a battery cycling) is
+  not filed, so those pages are as before.
+- **Modes off.** A charge the verdict puts after its last dear period is
+  refused when its time comes: the quarters left are all equal. `leg_taken()`
+  asks `trade_verdict()` (the control cycle's own call) at the leg's start and
+  keeps the leg only if the gate allows it there. A leg in progress is the
+  verdict's own answer now. The sale, "Tomorrow:" lines and chart marks use
+  the same answer.
+- **Words.** "Lowest/Highest published price" becomes "Lowest/Highest price
+  left" (the verdict reads only the periods not yet over). The flat-tariff
+  refusal calls a site "a fully fixed product" only when its product is fixed.
+
+## What does not change
+
+No control decision, command or option. Day/night and hourly sites with a
+second day of prices keep both legs at every half hour of a day
+(`test_ux53.py` part 4), except where every price left is equal: with an
+all-night weekend, Friday's 22:00 charge is no longer drawn, as the add-on
+does not take it. Price-off sites draw nothing, as before.
+
+## Limits
+
+The leg's gate is asked on today's plan, as the control cycle will find it at
+that time. A plan that gets new prices in between is drawn again at the next
+refresh. While the peak guard holds, a modes-on page shows no grid charge at
+all, also not the rest of a run the add-on charges in once the guard clears,
+as the modes-off page already did.
@@ -538,7 +538,7 @@ With battery modes on, these choices replace the *Charging and selling on price*

 **Cheap and expensive hours.** They come from the published day-ahead prices, as runs of consecutive 15-minute periods, not a single period.
 - The cheap run is the cheapest stretch long enough to fill the batteries that may charge, at their power.
- An expensive hour costs more than the cheap run by at least *Battery cycle cost* (`cycle_cost_threshold_eur`) when a solar forecast is read, and by 1.5 times that when none is (a real-time price feed widens it further). The batteries hold their power until then.
+- An expensive hour costs at least *Battery cycle cost* (`cycle_cost_threshold_eur`, widened as for trading) more than the cheap run. The batteries hold their power until then.
 - The sale uses the most expensive stretch inside those hours, and never a period below 0.
 - A carried (not yet published) price is never used. A run that has started runs to its end.
 - With no prices, or too small a gap, every battery follows the house.
@@ -1708,9 +1708,7 @@ DECISIONS/MAINT-13-full-pack-is-complete.md.
 On a capacity-tariff site the maintenance charge is capped by the headroom left
 under `peak_cap_w`, and if the forecast goes over the cap the charge-only clamp
 is dropped so the battery can shave the peak instead. Money outranks the
-maintenance schedule. With one battery or several, the charge also stays
-within the room left in the 15-minute period, so a late meter reading does
-not let it run at full power.
+maintenance schedule.

 With two or more batteries, the one being emptied gives its drain rate and the
 others only add power when the house needs more; none charges while it drains
@@ -3599,7 +3597,7 @@ for a new install*.
 | Meter reading may be stuck | See *Meter reading may be stuck* under Notifications. |
 | Month peak | This month's highest 15-minute average, when it happened, and how close it is to your peak limit. Amber from 80 %. |
 | 15-minute periods measured this month | How many 15-minute periods the add-on has measured and saved this month. |
-| Peak guard, Load too high for battery, Battery at its peak reserve | What the add-on does to keep your peak down. *Idle, heading for …* is where this 15-minute period is heading. *At this rate … over …* means it would go over at the current rate. With *grid charge limited*, a charge from the grid is cut back so it does not. *Waiting for meter readings* after a restart means the battery does not charge until the add-on can measure the period again. A red peak row is an alarm while control keeps running, so the banner shows its title without *Not ready*. |
+| Peak guard, Load too high for battery, Battery at its peak reserve | What the add-on does to keep your peak down. *Idle, heading for …* is where this 15-minute period is heading. *Waiting for meter readings* after a restart means the battery does not charge until the add-on can measure the period again. A red peak row is an alarm while control keeps running, so the banner shows its title without *Not ready*. |
 | Battery level, Battery power, Grid power | The reading of that entity. *No usable reading* means the entity is missing, or its reading is too old. Check it in Developer Tools before replacing it. |
 | Inverter control | Whether the inverter can be controlled, and how much it can charge and give. |
 | *name*: battery power reading stopped changing | The reading did not change while the add-on asked for a change. It may be stuck, or the battery may be refusing. The add-on sets the inverters to 0 W until it changes. |
@@ -147,7 +147,7 @@ from dataclasses import dataclass
 from datetime import datetime

 from .arbiter import ACTUATOR_SITE, P_ARBITRAGE, Claim
-from .price import Absence, Uncertainty, price_option
+from .price import Absence, price_option

 _LOG = logging.getLogger("goodwe.arbitrage")

@@ -267,21 +267,6 @@ def threshold_eur_kwh(opts: dict) -> float:
    return v


-def weather_uncertainty(modes_on: bool, solar_fc, held: bool = False) -> frozenset:
-    """The "no weather" doubt (x1.5) a trade must clear. TARIFF-24.
-
-    Battery modes read a solar forecast; with one read (`solar_fc` not None) the
-    doubt is gone, and `held` (a run planned with a forecast is under way, see
-    `Controller.weather_held()`) keeps it gone until that run ends. Everything
-    else, and the modes without a forecast, keep it. One rule for the run plan,
-    the charge gate and Home's mirror. See
-    DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
-    """
-    if modes_on and (solar_fc is not None or held):
-        return frozenset()
-    return frozenset({Uncertainty.NO_WEATHER})
-
-
 def soc_bounds(opts: dict) -> tuple:
    """(floor, ceiling) in percent. The reserve arbitrage may not spend."""
    return (float(price_option(opts, "arbitrage_soc_floor")),
@@ -22,7 +22,7 @@ from . import arbitrage, messages, peakguard, uitext
 from .maintenance import CHARGE as M_CHARGE, DRAIN as M_DRAIN, HOLD as M_HOLD
 from .maintenance import IDLE as M_IDLE, next_slot_start
 from .packmode import CHEAP_HOURS, GRID_CHARGE_MODES, LEFTOVER_SOLAR, SOLAR_FIRST
-from .price import Absence, brussels, _cover_table
+from .price import Absence, Uncertainty, brussels, _cover_table
 from .static_tariff import static_plan
 from .tariff import BILLING_TZ
 from .uimodel import REGION_PRESETS, options_to_ui
@@ -212,25 +212,26 @@ def _price_mode_in_use(c):
    return False


-def price_windows(c, plan, verdict):
+def price_windows(c, plan, verdict, now=None):
    """`[(kind, start, end)]`: where the add-on itself buys ("cheap") and
    gives ("dear"). With battery modes on that is the kept `priceruns.RunPlan`
-    (`c.mode_runs`): the cheap run when charging in it pays, and every give
-    run. With them off it is the arbitrage verdict's two points, the ones
-    `trade_runs()` draws. Nothing is classified here."""
+    (`c.mode_runs`): the cheap run when charging in it pays and the trade gate
+    allows it (UX-53), and every give run. With them off it is the arbitrage
+    verdict's legs the add-on will take, the ones `trade_runs()` draws
+    (`trade_legs()`, given `now`). Nothing is classified here."""
    if getattr(c, "modes_on", False):
        rp = getattr(c, "mode_runs", None)
        if rp is None or not rp.on or not _price_mode_in_use(c):
            return []
        out = [("cheap", rp.cheap.start, rp.cheap.end)] \
-            if rp.charge_useful() else []
+            if rp.charge_useful() and getattr(c, "mode_gate", None) is None \
+            else []
        return out + [("dear", g.start, g.end) for g in rp.give]
    if verdict is None:
        return []
-    return [("cheap", verdict.cheapest.start,
-             _point_end(plan, verdict.cheapest)),
-            ("dear", verdict.dearest.start,
-             _point_end(plan, verdict.dearest))]
+    return [("cheap" if kind == "grid" else "dear", pt.start,
+             _point_end(plan, pt))
+            for kind, pt in trade_legs(c, plan, verdict, now)]


 def day_range(points):
@@ -277,11 +278,7 @@ def trade_verdict(c, plan, now):
        return None, "no_prices"
    verdict = plan.arbitrage(peak_guard_active=guard,
                             min_spread_eur_kwh=arbitrage.threshold_eur_kwh(c.o),
-                             uncertainty=arbitrage.weather_uncertainty(
-                                 bool(getattr(c, "modes_on", False)),
-                                 getattr(c, "solar_fc", None),
-                                 bool(getattr(c, "weather_held",
-                                              lambda _n: False)(now))),
+                             uncertainty=frozenset({Uncertainty.NO_WEATHER}),
                             now=now)
    return verdict.match(
        allowed=lambda v: (v, "allowed"),
@@ -310,6 +307,27 @@ def _point_end(plan, point):
    return point.start + timedelta(hours=1)


+def leg_taken(c, plan, pt, now):
+    """UX-53: will the add-on act on this point of the verdict? One in
+    progress is the verdict's own answer now. One still ahead is asked of the
+    same gate (`trade_verdict()`, the call the control cycle makes) at the
+    point's own start. A charge that comes after the last dear period meets a
+    flat remainder there and is refused, so it is not announced. When the gate
+    allows it, the point is still the cheapest (dearest) one: the points
+    before it are gone and it was the first extreme of the points from now."""
+    if now is None or pt.start <= now:
+        return True
+    return trade_verdict(c, plan, pt.start)[0] is not None
+
+
+def trade_legs(c, plan, verdict, now):
+    """`[(kind, point)]` by start: the verdict's charge ("grid") and give
+    ("give") legs that the add-on will take (`leg_taken()`)."""
+    legs = sorted((("grid", verdict.cheapest), ("give", verdict.dearest)),
+                  key=lambda kp: kp[1].start)
+    return [(k, pt) for k, pt in legs if leg_taken(c, plan, pt, now)]
+
+
 # Under this many kWh a block is not drawn: the cycle would not move it.
 MIN_KWH = 0.05

@@ -326,10 +344,8 @@ def trade_runs(c, plan, verdict, day0, day1, now, shadow):
    if any(inv.soc is None for inv in c.inverters):
        return [], [], "no_level"
    level = [float(inv.soc) for inv in c.inverters]
-    legs = sorted((("grid", verdict.cheapest), ("give", verdict.dearest)),
-                  key=lambda kp: kp[1].start)
    runs, later = [], []
-    for kind, pt in legs:
+    for kind, pt in trade_legs(c, plan, verdict, now):
        end = _point_end(plan, pt)
        if end <= now:
            continue
@@ -375,8 +391,9 @@ def mode_runs(c, day0, day1, now, shadow):
    them (`c.mode_runs`): the cheap run on the batteries that may charge
    from the grid, the give runs on Leftover solar and Cheap hours, and the
    sell run on those with selling on. Amounts are upper bounds ("up to"),
-    from the battery's own room, rating and the run's length. Returns
-    `(runs, no_trade_key)`."""
+    from the battery's own room, rating and the run's length. UX-53: no grid
+    charge is drawn while the trade gate refuses one (`c.mode_gate`, what the
+    control cycle found). Returns `(runs, no_trade_key)`."""
    rp = getattr(c, "mode_runs", None)
    if getattr(c, "mode_tick", None) is None:
        return [], None             # no cycle yet: nothing is known
@@ -385,6 +402,7 @@ def mode_runs(c, day0, day1, now, shadow):
    if not rp.on:
        return [], "not_worth"
    floor, ceiling = arbitrage.soc_bounds(c.o)
+    gate = getattr(c, "mode_gate", None)
    out = []
    for i, inv in enumerate(c.inverters):
        pm = c.pack_mode(inv)
@@ -401,8 +419,9 @@ def mode_runs(c, day0, day1, now, shadow):
        blocks = []
        # P4: with a day plan, the grid block is the planned shortfall.
        need = plan_need(c, inv.name)
-        if rp.charge_useful() and (need > 0.0 if need is not None
-                                   else pm.mode in GRID_CHARGE_MODES):
+        if gate is None and rp.charge_useful() and (
+                need > 0.0 if need is not None
+                else pm.mode in GRID_CHARGE_MODES):
            blocks.append(("grid", rp.cheap))
        sell = rp.sell if pm.sell and pm.can_sell else None
        for g in rp.give:
@@ -612,7 +631,7 @@ def build_plan(c, now, shadow, running, held=False, settled=True):
    runs, lines = [], []
    # The control cycle trades on the fresh plan only, so this does too.
    verdict, trade_why = trade_verdict(c, fresh, now)
-    bars = price_bars(seen, day0, day1, price_windows(c, fresh, verdict),
+    bars = price_bars(seen, day0, day1, price_windows(c, fresh, verdict, now),
                      now, days.kinds)
    modes_on = bool(getattr(c, "modes_on", False))
    if running:
@@ -963,8 +982,7 @@ def month_peak(c, now):
        ceiling = pg.ceiling_w or limit_w
    out["line"] = line_period(out["period_w"], ceiling, c.shadow,
                              unmeasured=getattr(c, "peak_unmeasured_s", 0.0)
-                              > 0.0,
-                              cut=getattr(c, "room_charge", False))
+                              > 0.0)
    return out


@@ -1368,19 +1386,13 @@ def line_peak_not_covered() -> str:
    return _t("peak_not_covered")


-def line_period(period_w, limit_w, shadow, unmeasured=False,
-                cut=False) -> str:
+def line_period(period_w, limit_w, shadow, unmeasured=False) -> str:
    step = _w(shadow, "step_in", kw=_kw(limit_w))
    if unmeasured:
        # SAFETY-90: the add-on started during this period.
        return _t("period_unmeasured") + " " + step
    if period_w is None:
        return step
-    if period_w > limit_w:
-        # SAFETY-125: the figure is the current rate, and a grid charge is
-        # what gets cut back.
-        return _t("period_over", kw=_kw(period_w)) + " " + (
-            _w(shadow, "charge_cut", kw=_kw(limit_w)) if cut else step)
    return _t("period", kw=_kw(period_w)) + " " + step


@@ -1453,8 +1465,6 @@ def _samples() -> list:
                ("plan", line_period(1240, 3500, sh)),
                ("plan", line_period(None, 3500, sh)),
                ("plan", line_period(1240, 3500, sh, unmeasured=True)),
-                ("plan", line_period(5814, 5413, sh)),
-                ("plan", line_period(5814, 5413, sh, cut=True)),
                ("plan", control_text(True, sh)),
                ("plan", control_text(False, sh))]
    out += [("plan", run_grid_why(0.1412)), ("plan", run_grid_amount(1.23)),
@@ -174,17 +174,57 @@ TARIFF_MAX_AGE_S = 3 * TARIFF_REFRESH_S


 def tariff_refresh_wanted(opts: dict) -> bool:
-    """Does this install need the background tariff refresh? (TARIFF-10, TARIFF-24)
+    """TARIFF-10. Does this install need the background tariff refresh at all?

-    Yes with a price feed, with trading on price armed, or with battery modes
-    on: the modes read `self.tariff_plan` for their price runs. With
-    `price_provider` off the refresh is pure arithmetic on `static_profile`, so
-    no term here adds an HTTPS call. It decides whether prices are looked up,
-    never whether energy moves. See DECISIONS/TARIFF-10-fetching-is-not-trading.md
-    and DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
+    THE DEFECT THIS PREVENTS, and it shipped: the gate below used to be
+    `arbitrage.enabled(opts)` alone. That option defaults to `false`, and
+    `run_tariff_refresh` is the only caller of `resolve_tariff()`, which is the
+    only caller of `price_history.carry()` - so on a shipped install with a
+    provider configured NOTHING was ever fetched, no plan was ever resolved,
+    `/data/price_history.json` was never created, the *Price history* row read
+    `empty` forever, and TARIFF-09's short-horizon warning could not fire
+    because there was no fetch to warn about. Measured over a 40 h soak of two
+    instances side by side: zero feed requests and `present: false` across all
+    802 samples on the shipped default, against a resolved plan from the same
+    feed on the instance with arbitrage armed. ⚠️ AND `DOCS.md` HAS
+    DESCRIBED THE BEHAVIOUR BELOW SINCE THE COMMIT THAT WROTE THE GATE:
+    OPT-04 (bdd7f18) added the refresh task, the `arbitrage.enabled()` guard on
+    it, and the sentence saying a configured provider still fetches, all in one
+    change. config.yaml has said it since TARIFF-02 (852fc7c).
+
+    Two terms, and they answer two different questions:
+
+      provider_configured(opts) -> "the operator asked for a price feed", so
+                                   fetch it, validate it and record the day
+                                   (§8.3). This is the term TARIFF-10 ADDS.
+      arbitrage.enabled(opts)   -> "the operator armed trading". This term is
+                                   what the gate USED to be, kept verbatim.
+
+    ⚠️ IT IS AN `or`, SO THE GATE IS A STRICT WIDENING. Every configuration
+    that started this task before still starts it; none that did not start it
+    stops anything. That matters because the second term is not redundant:
+    `price_provider: off` + a `static_profile` + `arbitrage_enabled: true` is a
+    configuration validate.py explicitly ACCEPTS, and it trades - measured, at
+    `cycle_cost_threshold_eur: 0.05` on a 0.20/0.284 day/night profile,
+    `ARBITRAGE_CHARGE -5000 W`. Dropping that term to make the gate read
+    `provider_configured(opts)` alone would leave `self.tariff_plan` at None on
+    that site forever and `decide()` would answer "no tariff plan has been
+    resolved yet" on every cycle - silently disarming a strategy the UI says is
+    running, which is the exact failure validate.py's OPT-04 rules exist to
+    refuse.
+
+    ⚠️ AND NO CONFIGURATION ACQUIRES A PERIODIC HTTPS CALL FROM THIS TICKET.
+    With `price_provider` off, `resolve_tariff()` returns `static_plan()` - pure
+    arithmetic, no socket - so the second term starts a task that fetches
+    nothing. The true shipped default (no provider, no arbitrage) starts no
+    task at all. What is fetched is decided by the FIRST term only.
+
+    ⚠️ THIS IS NOT A TRADING SWITCH. It decides whether prices are LOOKED UP.
+    Whether they move energy is `arbitrage.enabled()` at the one call site in
+    `cycle()`, and TARIFF-10 did not touch it: `arbitrage_enabled: false` still
+    means no trade, ever, on any configuration.
    """
-    return (provider_configured(opts) or arbitrage.enabled(opts)
-            or packmode.enabled(opts))
+    return provider_configured(opts) or arbitrage.enabled(opts)


 def load_options() -> dict:
@@ -960,10 +1000,11 @@ class Controller:
        # and whether last tick filed a mode trade (a run edge reseeds).
        self.mode_runs = None
        self._runs_key = None
-        # TARIFF-24: the end of the run that was under way while a forecast
-        # was read; until then losing the forecast does not widen the gap.
-        self._wx_free_to = None
        self.mode_tick = None
+        # UX-53: why the trade gate refused a grid charge this tick (`peak`,
+        # `not_worth`, `not_covered`), or None when it allowed one. Home reads
+        # it; nothing in control does.
+        self.mode_gate = None
        self._run_done = {}
        self._mode_trade_was = False
        self._charge_blocked_q = None
@@ -1217,8 +1258,6 @@ class Controller:
        # because `self.peak_guard` is a different cycle's decision by the time
        # the status page renders.
        self.arb_headroom_w = None
-        # SAFETY-125: a grid charge sized to the quarter's room this cycle.
-        self.room_charge = False
        # UX-13 P1: today's prices as the Home chart has seen them. Display
        # only; nothing reads it back into a decision.
        self.home_prices = homeview.DayPrices()
@@ -2231,28 +2270,6 @@ class Controller:
                probing=probing))
        return out

-    def _wx_track(self, now) -> None:
-        """TARIFF-24, once per cycle, before the plan: with a forecast read,
-        remember when the run now under way (cheap, give or sell) ends."""
-        if self.solar_fc is None:
-            return
-        rp = self.mode_runs
-        ends = []
-        if rp is not None and rp.on:
-            ends = [r.end for r in (rp.cheap, rp.sell)
-                    if r is not None and r.holds(now)]
-            g = rp.give_at(now)
-            if g is not None:
-                ends.append(g.end)
-        self._wx_free_to = max(ends) if ends else None
-
-    def weather_held(self, now) -> bool:
-        """TARIFF-24: no forecast now, but a run planned with one is under
-        way: it keeps its gap to its end. The wider gap applies from the next
-        run. Pure; Home asks the same (`homeview.trade_verdict()`)."""
-        return (self.solar_fc is None and self._wx_free_to is not None
-                and now < self._wx_free_to)
-
    def _price_runs(self, now, packs, floor_pct, ceiling_pct):
        """The kept run plan, rebuilt at most once per price slot (15 min) or
        when the prices or a battery's choice change; a run under way is
@@ -2266,11 +2283,9 @@ class Controller:
        slot = int(now.timestamp() // 900)
        key = (id(plan), slot, tuple((p.name, p.use, p.mode, p.sell)
                                     for p in packs))
-        held = self.weather_held(now)
        if self.fc_entity is not None:
-            # P4: a forecast arriving or going rebuilds the plan at once (and
-            # so does the end of a run that held the gap, TARIFF-24).
-            key += (self.solar_fc is None, held)
+            # P4: a forecast arriving or going rebuilds the plan at once.
+            key += (self.solar_fc is None,)
        if key != self._runs_key:
            done_c = self._run_done.get("charge", (None, set()))[1]
            done_s = self._run_done.get("sell", (None, set()))[1]
@@ -2279,7 +2294,7 @@ class Controller:
            required = price_required_spread(
                arbitrage.threshold_eur_kwh(self.o),
                price_uncertainty_of(plan.read.product)
-                | arbitrage.weather_uncertainty(True, self.solar_fc, held))
+                | {Uncertainty.NO_WEATHER})
            ref = self._ref_cheap
            if ref is not None and now - ref.end > REF_CHEAP_KEEP:
                ref = self._ref_cheap = None
@@ -2348,7 +2363,6 @@ class Controller:
        quarter), exactly the gate `arbitrage.decide()` has."""
        floor_pct, ceiling_pct = arbitrage.soc_bounds(self.o)
        packs = self._mode_packs(maint_results)
-        self._wx_track(now)
        runs = self._price_runs(now, packs, floor_pct, ceiling_pct)
        guard = arbitrage.guard_state(self.peak_guard)
        plan = self.fresh_tariff_plan(now)
@@ -2359,8 +2373,7 @@ class Controller:
            return plan.arbitrage(
                peak_guard_active=active,
                min_spread_eur_kwh=arbitrage.threshold_eur_kwh(self.o),
-                uncertainty=arbitrage.weather_uncertainty(
-                    True, self.solar_fc, self.weather_held(now)),
+                uncertainty=frozenset({Uncertainty.NO_WEATHER}),
                now=now).match(
                    allowed=lambda _v: True, refused=lambda _v: False)
        if guard is not None and plan is not None and runs is not None:
@@ -2371,6 +2384,7 @@ class Controller:
            charge_ok = sell_ok and allowed(guard)
            trade_why = (None if charge_ok else "peak" if sell_ok
                         else "not_worth")
+        self.mode_gate = None if charge_ok else trade_why
        price_now = None
        if plan is not None:
            try:
@@ -3232,19 +3246,17 @@ class Controller:
        return floor

    def _charge_headroom(self, floor: float, claims) -> float:
-        """SAFETY-84: a cheap-window charge pulls no more than the quarter's
-        room under the peak aim (`charge_room_w()`), so it yields just enough
-        to the peak guard; at N>=2 nothing under a site stop (its 0 W would
-        need the other pack to give). SAFETY-125: at N=1 too, owner
-        2026-10-29; the stop rule stays N>=2 only."""
-        if len(self.inverters) > 1 and any(
-                c.kind == SET and c.actuator == ACTUATOR_SITE
-                and c.priority > P_MAINT_SHAPE for c in claims):
+        """SAFETY-84: at N>=2 a cheap-window charge pulls no more than the
+        quarter's headroom under the peak aim (`charge_headroom_w()`), so it
+        yields just enough to the peak guard, and nothing under a site stop
+        (its 0 W would need the other pack to give). N=1 is unchanged."""
+        if len(self.inverters) < 2:
+            return floor
+        if any(c.kind == SET and c.actuator == ACTUATOR_SITE
+               and c.priority > P_MAINT_SHAPE for c in claims):
            return 0.0
-        room = peakguard.charge_room_w(self.peak_guard, self._peak_proj)
-        floor = floor if room is None else min(floor, room)
-        self.room_charge = self.room_charge or floor > 0.0
-        return floor
+        room = peakguard.charge_headroom_w(self.peak_guard)
+        return floor if room is None else min(floor, room)

    def _charge_ceiling(self, claims):
        """SAFETY-84: the site `hi` for a cheap-window charge at N>=2, or None.
@@ -4889,7 +4901,6 @@ class Controller:
        # decision presented as current.
        self.arb, self.arb_at = None, now
        self.arb_headroom_w = None
-        self.room_charge = False
        # OPT-11 P3: with battery modes on, each battery's mode decides who
        # trades (`_mode_roles()`, `_mode_trade()`, below, which read the
        # same headroom), and this site-wide trade is not run.
@@ -4900,9 +4911,7 @@ class Controller:
            # `arbitrage.sized_from_meter()` in `_shadow_settle()`, so the
            # caveat on the recorded watts can never be answered from a
            # different cycle's guard than the watts were.
-            # SAFETY-125: a late meter reading's seconds count, as the bill.
-            self.arb_headroom_w = peakguard.charge_room_w(self.peak_guard,
-                                                          self._peak_proj)
+            self.arb_headroom_w = peakguard.charge_headroom_w(self.peak_guard)
        if site_trade:
            floor_pct, ceiling_pct = arbitrage.soc_bounds(self.o)
            charge_w, discharge_w = self.trade_power_w(floor_pct, ceiling_pct)
@@ -4957,7 +4966,6 @@ class Controller:
            arb_claim = arbitrage.claim(self.arb)
            if arb_claim is not None:
                claims.append(arb_claim)
-            self.room_charge = self.arb.action == arbitrage.CHARGE
            # Edge-logged, for the peak guard's reason: the action log holds 40
            # lines and a trade lasts a whole hour, so a line per cycle would
            # flush the context that explains it. The transition is what an
@@ -5177,8 +5185,6 @@ class Controller:
        mode_trade, trade_was = False, self._mode_trade_was
        if self.modes_on:
            mode_trade = self._mode_trade(claims, now)
-            self.room_charge = self.room_charge or (
-                mode_trade and self.arb.action == arbitrage.CHARGE)
        self._mode_trade_was = mode_trade
        self._charge_track(claims, maint_results)
        _live96 = set(self.live_units())
@@ -7072,15 +7078,6 @@ class Controller:
                            "text": messages.row_peak_guard_on(
                                _pg.floor_w or 0.0, _pg.ceiling_w,
                                shadow=self.shadow)})
-            elif _pg.projected_w is not None:
-                # SAFETY-125: "under" only when it is; over the limit at this
-                # rate, a grid charge is cut back to the quarter's room.
-                out.append({"ok": True, "warn": False, "id": "peak_guard",
-                            "text": messages.row_peak_guard_idle(
-                                _pg.projected_w, _pg.ceiling_w,
-                                month_peak=(_pg.ceiling_from
-                                            == peakguard.CEILING_MONTH_PEAK),
-                                cut=self.room_charge and not self.shadow)})
            else:
                out.append({"ok": True, "warn": False, "id": "peak_guard",
                            "text": _pg.explain()})
@@ -8059,9 +8056,11 @@ async def amain() -> None:
        # ESP32 heartbeat. A fetch on that path is a supplier's TLS timeout able
        # to push this add-on towards layer 1's 30 s veto. See TARIFF_REFRESH_S.
        #
-        # ⚠️ STARTED FOR A PROVIDER, FOR ARMED TRADING OR FOR BATTERY MODES:
-        # see `tariff_refresh_wanted()` above and DECISIONS/TARIFF-10 and
-        # TARIFF-24 for why each term is there.
+        # ⚠️ STARTED WHEN A PROVIDER IS CONFIGURED, *OR* WHEN TRADING IS ARMED
+        # - TARIFF-10, and it used to be the second term alone. `arbitrage_
+        # enabled` ships `false`, so a site that had selected a price feed
+        # fetched nothing at all; the whole argument, the measurement and what
+        # the `or` is protecting are in `tariff_refresh_wanted()` above.
        #
        # ⚠️ IT DOES NOT ARM ANYTHING. Fetching a price and trading on one are
        # two decisions; this is the first, and `cycle()`'s
@@ -1170,18 +1170,8 @@ def row_periods_measured(n) -> str:
              f"Gemeten kwartieren deze maand: {getoond}")


-def row_peak_guard_idle(projected_w, limit_w, month_peak: bool,
-                        cut: bool = False) -> str:
-    """The projection first and the limit second (SAFETY-38's ordered pair).
-    SAFETY-125: over the limit at this rate it says so, and `cut` that a
-    grid charge is limited to the room left."""
-    if float(projected_w) > float(limit_w):
-        doing, doet = (("grid charge limited", "laden beperkt") if cut
-                       else ("idle", "in rust"))
-        return Bi(f"Peak guard: {doing}, at this rate {watts(projected_w)}, "
-                  f"over {watts(limit_w)}",
-                  f"Piekbewaking: {doet}, aan dit tempo "
-                  f"{watts(projected_w)}, boven {watts(limit_w)}")
+def row_peak_guard_idle(projected_w, limit_w, month_peak: bool) -> str:
+    """The projection first and the limit second (SAFETY-38's ordered pair)."""
    limit = (f"this month's {watts(limit_w)} peak" if month_peak
             else f"the {watts(limit_w)} peak limit")
    grens = (f"de maandpiek van {watts(limit_w)}" if month_peak
@@ -1573,11 +1563,6 @@ def status_samples() -> list:
        ("row_periods_measured", GREEN, row_periods_measured("unreadable")),
        ("row_peak_guard_idle", GREEN, row_peak_guard_idle(1300, 2500, True)),
        ("row_peak_guard_idle", GREEN, row_peak_guard_idle(1300, 2500, False)),
-        ("row_peak_guard_idle", GREEN, row_peak_guard_idle(5814, 5413, True)),
-        ("row_peak_guard_idle", GREEN, row_peak_guard_idle(5814, 5413, True,
-                                                           cut=True)),
-        ("row_peak_guard_idle", GREEN, row_peak_guard_idle(3814, 3500, False,
-                                                           cut=True)),
        ("row_peak_guard_quiet", GREEN, row_peak_guard_quiet()),
        ("row_peak_guard_unmeasured", AMBER, row_peak_guard_unmeasured()),
        *(("row_peak_guard_blind", AMBER, row_peak_guard_blind(k))
@@ -1136,21 +1136,6 @@ def charge_headroom_w(decision) -> float | None:
    return max(0.0, -float(decision.wanted_w))


-def charge_room_w(decision, projection) -> float | None:
-    """SAFETY-125: `charge_headroom_w()` with the seconds since the last
-    meter reading counted at that reading, so a late reading near a
-    quarter's end is not read as room for a grid charge (SAFETY-99).
-    DECISIONS/SAFETY-125-grid-charge-under-the-month-peak.md."""
-    room = charge_headroom_w(decision)
-    if not room or projection is None or projection.block_start is None:
-        return room
-    left = QUARTER_S - float(projection.elapsed_s)
-    if left <= 0.0:
-        return room
-    late_ws = max(0.0, float(projection.held_w)) * uncovered_s(projection)
-    return max(0.0, room - late_ws / left)
-
-
 def shaping_suspended(decision, peak_forecast_w, cap_w) -> bool:
    """Must the maintenance charge-only shaping stand down this cycle?

@@ -1103,8 +1103,12 @@ class TariffPlan:
                f"the tariff is flat - every one of the {len(firm)} firm "
                f"points, spanning {_whole_hours(firm)} hours, costs "
                f"{firm[0].eur_per_kwh:.4f} EUR/kWh, so buying low and "
-                f"selling high is arithmetically impossible. §9.2: a fully "
-                f"fixed product is self-consumption only")
+                f"selling high is arithmetically impossible"
+                # UX-53: only a real fixed product is "fully fixed". A
+                # dynamic or day/night site whose remaining periods happen to
+                # be equal trades again when they differ.
+                + (". §9.2: a fully fixed product is self-consumption only"
+                   if self.product is PriceProduct.FIXED else ""))

        # REFUSAL 5, NEW IN FCST-03 (AC3). One widening path, driven by the set
        # of active uncertainty sources: the product's own (§9.2 row 2, derived
@@ -367,11 +367,11 @@
    "run": {
      "grid_what": "Charges up to {kwh} from the grid.",
      "grid_what_would": "Would charge up to {kwh} from the grid.",
-      "grid_why": "Lowest published price, {eur} per kWh.",
+      "grid_why": "Lowest price left, {eur} per kWh.",
      "grid_amount": "Costs up to {eur}.",
      "give_what": "Gives up to {kwh}, to the house first.",
      "give_what_would": "Would give up to {kwh}, to the house first.",
-      "give_why": "Highest published price, {eur} per kWh.",
+      "give_why": "Highest price left, {eur} per kWh.",
      "sell_what": "Sells up to {kwh}, to the house first.",
      "sell_what_would": "Would sell up to {kwh}, to the house first.",
      "cheap_why": "Cheapest hours, about {eur} per kWh.",
@@ -416,9 +416,6 @@
    "step_in_would": "The batteries would step in above {kw}.",
    "period": "This 15-minute period is heading for {kw}.",
    "period_unmeasured": "Part of this 15-minute period was not measured.",
-    "period_over": "At this rate this 15-minute period reaches {kw}.",
-    "charge_cut": "The grid charge is cut back to stay under {kw}.",
-    "charge_cut_would": "The grid charge would be cut back to stay under {kw}.",
    "prices": {
      "now": "Price now {eur} per kWh, all in.",
      "today": "Today: lowest {lo} at {lo_at}, highest {hi} at {hi_at}.",
@@ -307,11 +307,11 @@
    "run": {
      "grid_what": "Laadt tot {kwh} van het net.",
      "grid_what_would": "Zou tot {kwh} van het net laden.",
-      "grid_why": "Laagste gepubliceerde prijs, {eur} per kWh.",
+      "grid_why": "Laagste prijs die nog over is, {eur} per kWh.",
      "grid_amount": "Kost tot {eur}.",
      "give_what": "Levert tot {kwh}, eerst aan het huis.",
      "give_what_would": "Zou tot {kwh} leveren, eerst aan het huis.",
-      "give_why": "Hoogste gepubliceerde prijs, {eur} per kWh.",
+      "give_why": "Hoogste prijs die nog over is, {eur} per kWh.",
      "sell_what": "Verkoopt tot {kwh}, eerst aan het huis.",
      "sell_what_would": "Zou tot {kwh} verkopen, eerst aan het huis.",
      "cheap_why": "Goedkoopste uren, ongeveer {eur} per kWh.",
@@ -351,9 +351,6 @@
    "step_in_would": "De batterijen zouden bijspringen boven {kw}.",
    "period": "Dit kwartier gaat richting {kw}.",
    "period_unmeasured": "Een deel van dit kwartier is niet gemeten.",
-    "period_over": "Aan dit tempo komt dit kwartier op {kw}.",
-    "charge_cut": "Laadt minder van het net om onder {kw} te blijven.",
-    "charge_cut_would": "Zou minder van het net laden om onder {kw} te blijven.",
    "prices": {"now": "Prijs nu {eur} per kWh, alles inbegrepen.", "today": "Vandaag: laagste {lo} om {lo_at}, hoogste {hi} om {hi_at}.", "none": "Geen prijzen voor vandaag."},
    "tomorrow": {"known": "De prijzen van morgen zijn binnen.", "unknown": "De prijzen van morgen komen meestal na 13:00."},
    "region": {"preset": "Heffingen en btw: {region}, cijfers van {year}.", "own": "Heffingen en btw: uw eigen bedrag."},
@@ -1,5 +1,5 @@
 name: GoodWe RS485 Controller
-version: "0.19.2"
+version: "0.19.0"
 slug: goodwe_controller
 description: >-
  Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a
@@ -936,8 +936,6 @@ def _s45_assigned(name, clear=("None",)):


 _s45_head_src = _s45_assigned("arb_headroom_w")
-# SAFETY-125: the guard's headroom with a late reading's seconds counted.
-S125_ROOM = "peakguard.charge_room_w(self.peak_guard, self._peak_proj)"
 print(f"    main.py has {len(_s45_calls)} `arbitrage.decide(` call site(s); "
      f"charge_headroom_w= is {_s45_arg}, and self.arb_headroom_w is assigned "
      f"from {_s45_head_src}")
@@ -946,7 +944,7 @@ check("main.py passes the guard's OWN measured headroom at its one "
      "transcription of it, so a mutation back to a literal or to max_w is red "
      "rather than silent",
      _s45_arg == ["self.arb_headroom_w"]
-      and _s45_head_src == [S125_ROOM])
+      and _s45_head_src == ["peakguard.charge_headroom_w(self.peak_guard)"])
 # ⚠️ AND THE HOIST DID NOT MOVE IT OUT OF THE CYCLE. An `arb_headroom_w` set
 # once in `__init__` and never refreshed would satisfy the pin above and would
 # size every trade from the guard decision of whatever cycle happened to run
@@ -962,7 +960,8 @@ check("...and the assignment is INSIDE the same `cycle()` that makes the call, "
      "and not one carried from an arbitrary earlier one",
      any(isinstance(n, ast.Assign)
          and [ast.unparse(t) for t in n.targets] == ["self.arb_headroom_w"]
-          and ast.unparse(n.value) == S125_ROOM
+          and ast.unparse(n.value)
+          == "peakguard.charge_headroom_w(self.peak_guard)"
          for n in ast.walk(_s45_cycle)))


@@ -523,7 +523,7 @@ _lo = min(_q[:96], key=lambda p: p.eur_per_kwh)
 check("quarter-hour prices: the charge block, its price and the price line's "
      "lowest are the same 15-minute period",
      _grid and _grid[0]["from"] == homeview.hhmm(_lo.start)
-      and _grid[0]["why"] == f"Lowest published price, €{_lo.eur_per_kwh:.2f} "
+      and _grid[0]["why"] == f"Lowest price left, €{_lo.eur_per_kwh:.2f} "
                             "per kWh."
      and f"Today: lowest €{_lo.eur_per_kwh:.2f} at "
          f"{homeview.hhmm(_lo.start)}," in s_q["plan"]["price_line"]
@@ -540,12 +540,6 @@ rp.Hass.state = _sensor
 rp_start = [UTC0]
 FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
           "cycle_cost_threshold_eur": 0.20}
-# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
-# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
-# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
-# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
-# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
-GATE_030 = {"cycle_cost_threshold_eur": 0.30}


 def seed_profile(c):
@@ -603,8 +597,7 @@ def invariants(tag, rows, c):


 # Sunny: 40 kWh forecast. B (Leftover solar) at 30 % needs nothing.
-rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0},
-                       extra=GATE_030)
+rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
 charge = invariants("sunny", rows, c)
 _last = nth(rows, -1, "a cycle")
 print(f"    sunny: verdict {present(_last) and _last['plan'] and _last['plan'].verdict}, "
@@ -614,35 +607,6 @@ check("sunny: a day plan is made, and says sunny",
          for r in rows))
 check("sunny: no grid charge at all", not charge)

-# TARIFF-24 round 2: the same day at the cycle cost 0.20 itself. With the
-# forecast read the gap needed is 0.20 (not 1.5 x = 0.30), so the midday
-# quarter 0.339 against the evening 0.551 (gap 0.21, between 1x and 1.5x) is
-# a planned top-up for B (Leftover solar) up to its planned level.
-rows_g, st_, c_g = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
-charge_g = invariants("gap between 1x and 1.5x", rows_g, c_g)
-_first_g = nth(charge_g, 0, "a charge cycle")
-_gaps = [min(g.mean_eur_kwh for g in r["runs"].give)
-         - r["runs"].cheap.mean_eur_kwh for r in charge_g
-         if r["runs"] is not None and r["runs"].give]
-print(f"    gap 0.20 <= gap < 0.30: {len(charge_g)} charge cycles, run gap "
-      f"{min(_gaps, default=0):.3f}, B to "
-      f"{max((r['soc']['b'] for r in rows_g), default=0):.1f} %")
-check("a forecast day whose price gap lies between 1x and 1.5x the cycle "
-      "cost (0.20 < 0.21 < 0.30) plans a cheap run: B charges from the grid "
-      "inside it, only B, and only up to its planned level",
-      present(_first_g) and len(_gaps) == len(charge_g)
-      and all(0.20 <= g < 0.30 for g in _gaps)
-      and all(r["runs"].cheap.holds(r["now"]) for r in charge_g)
-      and all(r["roles"][B] == modetrade.CHARGE for r in charge_g)
-      and all(r["roles"][A] != modetrade.CHARGE for r in charge_g)
-      and max(r["soc"]["b"] for r in rows_g) <= 45.64 + 2.0)
-check("...and the same day with no forecast read does not (it needs 0.30): "
-      "the old gate, kept for a day without a forecast",
-      not [r for r in run_day(SF_LS, fc=None,
-                              soc0={"a": 60.0, "b": 30.0})[0]
-           if r["action"] == arbitrage.CHARGE
-           and r["now"].astimezone(L).hour == 12])
-
 # Dark: 1 kWh. B buys the evening's shortfall only, in the cheap run.
 rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0})
 charge = invariants("dark", rows, c)
@@ -659,8 +623,7 @@ check("dark: A rests while B charges", all(r["roles"][A] == modetrade.REST
                                           for r in charge))

 # Cheap hours on a partly sunny day: ignores the plan, fills as in P3.
-rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0},
-                       extra=GATE_030)
+rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0})
 charge = invariants("cheap hours, partly", rows, c)
 top = max(r["soc"]["b"] for r in rows)
 print(f"    cheap hours partly: B reached {top:.1f} %")
@@ -685,8 +648,7 @@ check("forecast lost mid-run: Leftover solar was charging, and stops within "

 # The forecast is far too high (40 kWh, and there is no sun at all): no grid
 # charge, so B covers less of the evening - a money risk, never a safety one.
-rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0},
-                       extra=GATE_030)
+rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0})
 invariants("forecast too high", rows, c)
 check("forecast too high: no grid charge, and B still keeps its power for "
      "the dear run", not [r for r in rows if r["action"]
@@ -696,7 +658,7 @@ check("forecast too high: no grid charge, and B still keeps its power for "

 # A refusal wins over the plan.
 rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
-                       refuse=("b",), extra=GATE_030)
+                       refuse=("b",))
 invariants("refusal", rows, c)
 check("refusal: B refuses to charge, so the plan's charge ends and B is "
      "never a charger after it", rows and not [
@@ -243,16 +243,12 @@ check("no opposite-direction split on any of these cycles",
 # ============================================================================ #
 print("\n4. battery modes on, no probe: byte-identical to release/1.0 bf9019e")
 # Printed by tools/opt20_scen.py on release/1.0 bf9019e (2026-10-15),
-# goodwe-addon-checks:1. SAFETY-125 (0.19.2) moved the two runs that charge
-# against the peak aim: the rig's P1 sample is 0.35 s old, and a grid charge
-# now counts those seconds, so ch_ch's quarters land on 3450.0 W where they
-# landed 1.3-1.4 W over it (bf9019e: 15fc25dd...), and ch_ch_maint's first,
-# partial quarter charges a little less at its end (bf9019e: e46e3c66...).
+# goodwe-addon-checks:1.
 AT_BASE = {
    "sf_ch": "422d6578a7decf1ae3749edd1898ff3cd0541d904c95f636cdd9b1de8c1a07c9",
-    "ch_ch": "2b5879ec95810c39a5f0f82c04b9f8e358ea03ddce4ba187cc2b7e0885dfcbfa",
+    "ch_ch": "15fc25dd34186e56d34b752d37c9e8613295ba737938c92454acca08c83080fb",
    "ch_ch_maint":
-        "e56eddabdb785f81793e7afa525f8e6da237b0b2165860aa8e0f8a6499b275a9",
+        "e46e3c666dd63ab33b56e83c0a560c07cec7774a9a70560f55c62a6ae6f55920",
 }
 _got = sc.no_probe_digests()
 for _k in AT_BASE:
@@ -260,8 +256,7 @@ for _k in AT_BASE:
          f"{_got[_k][:16]}")
 check("with no refusal every share, grid, trade sentence, role and plant "
      "power of a scripted cheap run equals bf9019e's (A Solar first, A "
-      "charging, A in maintenance charge; the last two as SAFETY-125 moved "
-      "them)", _got == AT_BASE)
+      "charging, A in maintenance charge)", _got == AT_BASE)

 print()
 if fails:
@@ -609,10 +609,6 @@ print("\n5. modes off: byte-identical to release/1.0 e3e4ba6")
 #   AT_BASE      the same rows through `ident.trade_digest()`, equal to what
 #                e3e4ba6 gives through it;
 #   AT_NOW       this tree's own digests with nothing hidden.
-# SAFETY-125 (0.19.2) moved the two lag pins: their P1 sample is 0.35 s old on
-# every cycle, and a grid charge now counts those seconds at the held reading,
-# so 16 of 1080 cycles charge about 1.7 W less (before: n1_lag f6c67b35...
-# masked, 78aac892... full; n2_lag as n2). n1 and n2 still equal e3e4ba6.
 AT_BASE_OLD = {
    "n1": "71245b227ca40bada4f71f57ea6154475f4b0bd60239c9ad4f80bffb0094514c",
    "n2": "56cf28010b06765c29e5479abb815d7503d570b39240d82dfc818efa90c93722",
@@ -622,14 +618,14 @@ AT_BASE_OLD = {
 AT_BASE = {
    "n1": "33886ef03f364852883f0370230e6e04823fbb46a4704f88ca75bf9082d98c01",
    "n2": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
-    "n1_lag": "28e3182ae73c52dae0e65b2495bc04b2b71003889bf9de1a394b047d2c0e0edf",
-    "n2_lag": "45bfb095b5707a91316f56afc408dba616afc729ce4c83a10b337f36948fa3f2",
+    "n1_lag": "f6c67b351bd732fb69e62cafbfdb2bcff6032f5d8845836659d096b8c677d3c0",
+    "n2_lag": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
 }
 AT_NOW = {
    "n1": "939b3d47bbd64fa50e3d70538f092fb98e5c4bd5ead85a7fc696a1dbb514039e",
    "n2": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
-    "n1_lag": "1827918d570bfa0cc371c35dbbb64378b4937557061e7e1a396aba7663e68117",
-    "n2_lag": "6acc1d1b5a11f3481c7a30d384612f37b59f8e5e9cf89204edd07d09a5b90d8d",
+    "n1_lag": "78aac892975be81a7ceac0c000ed441a731bd4f42ff9f729996cbee53d6b7f02",
+    "n2_lag": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
 }
 _cmd_digest = ident.trade_digest
 _rows5 = {k: ident.run(**ident.SCENARIOS[k])[0] for k in AT_BASE}
@@ -640,8 +636,7 @@ for _k in AT_BASE:
          f"{_got[_k][:16]}")
 check("with battery modes off every command, integrator, allocation and "
      "trade action equals e3e4ba6's (the sentence masked as above), also when "
-      "every quarter boundary's cycle still sees the old P1 block (there, as "
-      "SAFETY-125 moved it)",
+      "every quarter boundary's cycle still sees the old P1 block",
      _got == AT_BASE)
 check("...the mask is needed and nothing more: unmasked, the digests differ "
      "from e3e4ba6's printed ones, and equal this tree's own pins, so a "
@@ -19,9 +19,7 @@ DECISIONS/SAFETY-121-bound-every-quarter.md.
 1. The rig's shape (1 s meter that lags the battery, 1 s battery lag, house
   800 W, rating 2500 W, limit 2500 W, margin 50, charge 2000 W, no
   forecast), 2 h, three seeds: no notification, the cap held, every command
-   the same as without the fix; without the fix it warns. SAFETY-125 sized
-   the N=1 charge to the room, which removed this hand-back; these runs keep
-   the old sizing, and one run checks that with it nothing hands back.
+   the same as without the fix; without the fix it warns.
 2. A genuine integrator bound still warns: the loop in charge with the house
   over the rating (at once, as before), and the loop at its rail after a
   hand-back (after the settle).
@@ -142,29 +140,10 @@ def house(seed, base=800.0, step=None):
    return load


-_SIZED_CH = Controller._charge_headroom
-
-
-def _n1_unsized(self, floor, claims):
-    """The N=1 cheap-window charge as before SAFETY-125: not sized to the
-    quarter's room, so the guard steps in at each quarter's end and hands
-    back - the shape this file grades the settle on."""
-    return floor if len(self.inverters) < 2 \
-        else _SIZED_CH(self, floor, claims)
-
-
 def run(load, *, n=1, dur=7200.0, delay=1, extra=None, cheap=True, cut=None,
-        charging=True, blind=0.0, sized=False):
+        charging=True, blind=0.0):
    """One run of `n` inverters of 2500 W; `charging=False`: no maintenance,
-    the loop in charge; `blind`: no meter reading until that second.
-    SAFETY-125 sizes the N=1 charge to the room, so it no longer hands back
-    at a quarter's end; an N=1 charge here keeps the old sizing unless
-    `sized`, so the hand-back this file is about still happens."""
-    if n == 1 and charging and not sized:
-        return patched(Controller, "_charge_headroom", _n1_unsized)(
-            lambda: run(load, n=n, dur=dur, delay=delay, extra=extra,
-                        cheap=cheap, cut=cut, charging=charging,
-                        blind=blind, sized=True))
+    the loop in charge; `blind`: no meter reading until that second."""
    extra = dict(extra or {})
    s84.OPT = dict(OPT0, peak_cap_w=int(CAP * n), peak_margin_w=50,
                   maintenance_charge_w=2000)
@@ -252,15 +231,6 @@ check("non-vacuous: without the fix every run warns, at a quarter's edge",
      all(len(notes(c)) >= 1 for _r, c in OLD.values())
      and all(min(t % QUARTER, QUARTER - t % QUARTER) <= 40
              for _r, c in OLD.values() for t in notes(c)))
-_sz = run(house(1), sized=True)
-print(f"    SAFETY-125's sizing, seed 1: guard step-ins "
-      f"{guard_steps(_sz[1])}, notifications {notes(_sz[1])}, highest "
-      f"quarter {max(quarters(_sz[1]), default=0.0):.0f} W")
-check("SAFETY-125: with the N=1 charge sized to the room the guard does not "
-      "step in at the quarter's end, nothing warns and the cap holds",
-      not any(r[-1][1] and r[-1][1][0] for r in _sz[0])
-      and notes(_sz[1]) == [] and any(r[1] < -1000.0 for r in _sz[0])
-      and len(quarters(_sz[1])) == 8 and max(quarters(_sz[1])) < CAP)

 # ============================================================================ #
 print("\n2. a genuine integrator bound still warns")
@@ -1,565 +0,0 @@
-"""Runnable check for SAFETY-125.  `python3 test_safety125.py`
-
-A meter reading that is late near a quarter's end left seconds the
-projection did not count (SAFETY-99), and `charge_headroom_w()` read them as
-room: a grid charge went back to full power in the quarter's last seconds and
-the billed quarter went over the aim, above a banked month peak or the cap.
-And the peak guard's row said "under" while the period was over the limit at
-the current rate. DECISIONS/SAFETY-125-grid-charge-under-the-month-peak.md.
-
-Drives the REAL Controller (read_inputs + cycle, the tariff task on a
-day/night profile, a P1 meter on a simulated clock) in the live shape: modes
-on, inverter-a Cheap hours at 5000 W charging harder than asked (as it did
-live), inverter-b Solar first, a house of 1 kW, cap 3500 W, margin 50 W.
-
-1. `charge_room_w()` on its own.
-2. A reading 30 s late at each quarter's end: every quarter at or under the
-   aim, with a month peak banked above the cap and with none, with the P1
-   projection and with a `peak_forecast_entity`; the charge is cut late in
-   the quarter and back in the next one.
-3. The same for a price trade with modes off, and a maintenance charge at N=2.
-4. A healthy meter: the quarters as before, and the row and the month-peak
-   line say what is true.
-5. The words on their own.
-6. One inverter: the maintenance charge is sized to the room too (owner
-   2026-10-29), on a 5 s and a 10 s meter, with and without a banked peak
-   and with late readings; the guard no longer steps in during it.
-7. The row during an N=2 maintenance charge and in shadow mode.
-8. Edge cases: a reading past its 30 s hold (blind), a start mid-quarter,
-   the summer-time change, the forecast entity in W, a 10 s meter, the
-   quarter's last second.
-
-Mutations (MUTATION.md, purged copies) are listed in the pull request.
-"""
-
-import asyncio
-import logging
-import os
-import sys
-import tempfile
-import types
-from datetime import datetime, timedelta, timezone
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-sys.path.insert(0, os.path.join(HERE, "tools"))
-logging.disable(logging.WARNING)
-
-import opt11_identity as rig                                   # noqa: E402
-import opt11p3_replay as rp                                    # noqa: E402
-import safety84_identity as s84                                # noqa: E402
-import app.main as m                                           # noqa: E402
-import app.p1 as p1mod                                         # noqa: E402
-from named_absence import first, nth, present                  # noqa: E402
-from app import homeview, messages, peakguard, tariff          # noqa: E402
-from app import price as _price, static_tariff as _st          # noqa: E402
-from app.main import Controller                                # noqa: E402
-from app.p1 import make_sample, split_signed                   # noqa: E402
-from app.store import unit_key                                 # noqa: E402
-from app.tariff import QUARTER_S, Projection                   # noqa: E402
-
-fails = []
-
-
-def check(name, cond):
-    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
-    if not cond:
-        fails.append(name)
-
-
-PEAK = 5413.17          # October's banked peak on the live site
-AIM_PEAK = PEAK - 50.0
-AIM_CAP = 3500.0 - 50.0
-TOL = 10.0              # W over the aim a quarter may land (SAFETY-81)
-FC = "sensor.piek_prognose_kwartier"
-L = timezone(timedelta(hours=1))
-START = datetime(2026, 10, 29, 0, 0, tzinfo=L).astimezone(timezone.utc)
-PROFILE = ('{"periods": ['
-           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
-           ' "eur_per_kwh": 0.2333},'
-           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
-           ' "eur_per_kwh": 0.2801}]}')
-
-
-def opts(*, fc=False, modes=True, arb=False):
-    o = dict(rp.options(modes, arb, 2))
-    o.update(cycle_cost_threshold_eur=0.03, static_profile=PROFILE,
-             peak_cap_w=3500, peak_margin_w=50)
-    o["inverters"][0].update(max_w=5000, capacity_kwh=15.36)
-    o["inverters"][1].update(max_w=4600, capacity_kwh=20.48)
-    if fc:
-        o["peak_forecast_entity"] = FC
-    return o
-
-
-class Harder(rp.Plant):
-    """Charges harder than asked, as inverter-a did live (asked -4271 W,
-    measured about -4750 W; asked -5000 W, about -5210 W)."""
-
-    def step(self, dt, floor):
-        c = self.cmd
-        if c < 0:
-            self.cmd = max(c * 1.11, -5216.0)
-        try:
-            super().step(dt, floor)
-        finally:
-            self.cmd = c
-
-
-async def _no_fetch(*a, **k):
-    raise AssertionError("the tariff task reached for a price feed")
-
-
-class OnItsOwn(rp.Plant):
-    """Charges 5000 W whatever it is asked (shadow mode: nothing is
-    written, the inverter charges on its own)."""
-
-    def step(self, dt, floor):
-        self.cmd = -5000.0
-        super().step(dt, floor)
-
-
-def drive(o, *, peak=None, late=0.0, minutes=31, every=0, start=None,
-          period=0.0, fc_unit="kW", plant=Harder):
-    """The real Controller from `start` (00:00 local) for `minutes` at a 1 s
-    cycle (OPT-15's lag). `late`: no P1 telegram in each quarter's last
-    `late` s; `period`: one telegram every `period` s (0: every cycle).
-    -> (controller, rows, {quarter start: true grid average}, samples), the
-    samples taken every `every` cycles from the second quarter (the first
-    starts before the first reading): (projection, ceiling, engaged,
-    peak_guard row, month-peak line)."""
-    store = rp._Store()
-    for u, mode in (("a", "cheap_hours"), ("b", "solar_first")):
-        store.data[unit_key(f"inverter-{u}", "pack_use")] = True
-        store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode
-        store.data[unit_key(f"inverter-{u}", "pack_sell")] = False
-    rows, samples, sums = [], [], {}
-    t0 = start or START
-
-    async def go():
-        lag = rp.Lag()
-        hass = rp.Hass(("a", "b"), lambda t: 1000.0, {"a": 11.0, "b": 10.0},
-                       limits={"a": (-5000.0, 5000.0),
-                               "b": (-4600.0, 4600.0)}, lag=lag)
-        hass.plants["a"].__class__ = plant
-        fc_kw = [0.0]
-
-        async def state(e):
-            # The HA quarter projection, in kW like the live template.
-            return None if e != FC else {
-                "state": (f"{fc_kw[0]:.3f}" if fc_unit == "kW"
-                          else f"{fc_kw[0] * 1000.0:.0f}"),
-                "attributes": {"unit_of_measurement": fc_unit}}
-        hass.state = state
-        tmp = tempfile.mkdtemp(prefix="s125-")
-        db = os.path.join(tmp, "tariff.db")
-        if peak is not None:
-            tariff.PeakStore(db)._db.execute(
-                "INSERT INTO monthly_peak VALUES (?, ?, ?, NULL)",
-                (tariff.month_key(t0), peak,
-                 "2026-10-21T20:15:00+00:00")).connection.commit()
-        c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
-                       peak_db_path=db,
-                       price_history_path=os.path.join(tmp, "ph.json"))
-        c.inverters[0].dev_min, c.inverters[0].dev_max = -5000.0, 5000.0
-        c.inverters[1].dev_min, c.inverters[1].dev_max = -4600.0, 4600.0
-        c.auto = True
-        real = m.datetime, homeview.datetime, p1mod.time
-        clock, simt = [t0], [0.0]
-
-        class _DT(real[0]):
-            @classmethod
-            def now(cls, tz=None):
-                return clock[0] if tz is None else clock[0].astimezone(tz)
-        m.datetime = homeview.datetime = _DT
-        p1mod.time = types.SimpleNamespace(monotonic=lambda: 1e6 + simt[0])
-        real_load = _price.load_prices, _st.load_prices
-        _price.load_prices = _st.load_prices = _no_fetch
-        task = asyncio.create_task(c.run_tariff_refresh())
-        try:
-            hass.advance(0.0, 10.0)
-            t, n = 0.0, 0
-            while t < minutes * 60:
-                now = t0 + timedelta(seconds=t)
-                hass.t, simt[0], clock[0] = t, t, now
-                if t == 0.0:
-                    for _ in range(500):
-                        if c.tariff_plan is not None:
-                            break
-                        await asyncio.sleep(0)
-                q = int(now.timestamp() // QUARTER_S)
-                acc = sums.setdefault(q, [0.0, 0])
-                g_now = hass.grid()
-                fc_kw[0] = (acc[0] + g_now * (QUARTER_S - acc[1])) \
-                    / QUARTER_S / 1000.0
-                if now.timestamp() % QUARTER_S < QUARTER_S - late \
-                        and t >= lag.p1_s \
-                        and (not period or t % period < 1e-9):
-                    imp, exp = split_signed(hass._past(lag.meter_s
-                                                       + lag.p1_s)[0])
-                    c.p1.submit(make_sample(
-                        "ha_signed", imp, exp, phases=1,
-                        ingest_ts=now - timedelta(seconds=lag.p1_s),
-                        ingest_mono=1e6 + t))
-                await c.read_inputs(now_mono=t)
-                await c.cycle()
-                hass.advance(lag.tick, 10.0)
-                acc[0] += max(0.0, hass.grid())
-                acc[1] += 1
-                rows.append((now, c.target, hass.plants["a"].p,
-                             getattr(c.arb, "action", None)))
-                pg = c.peak_guard
-                if every and n % every == 0 and t >= QUARTER_S \
-                        and pg is not None and pg.projected_w is not None:
-                    row = first((r["text"] for r in c.checks(now)
-                                 if r["id"] == "peak_guard"), "guard row")
-                    samples.append((pg.projected_w, pg.ceiling_w, pg.engaged,
-                                    row, homeview.month_peak(c, now)["line"]))
-                t += lag.tick
-                n += 1
-        finally:
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
-            m.datetime, homeview.datetime, p1mod.time = real
-            _price.load_prices, _st.load_prices = real_load
-        return c
-    c = asyncio.run(go())
-    full = {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"):
-            s / k for q, (s, k) in sorted(sums.items()) if k >= QUARTER_S}
-    return c, rows, full, samples
-
-
-def into(now):
-    return now.timestamp() % QUARTER_S
-
-
-# ============================================================================ #
-print("1. charge_room_w(): a late reading's seconds count at that reading")
-_dec = peakguard.decide(
-    Projection(5800.0, 5800.0, 450.0, 1.0, True, START, 5800.0),
-    batt_w=-4800.0, cap_w=3500, margin_w=50,
-    reading=types.SimpleNamespace(is_observed=True, peak_w=PEAK),
-    achievable_w=9600.0, soc=50.0, soc_floor=20.0)
-_room = peakguard.charge_headroom_w(_dec)
-_late = Projection(5800.0, 5800.0, 450.0, 430.0 / 450.0, False, START,
-                   5800.0)
-print(f"    headroom {_room:.0f} W; 20 s late, 450 s left: "
-      f"{peakguard.charge_room_w(_dec, _late):.0f} W")
-check("with every second counted it is charge_headroom_w() exactly",
-      peakguard.charge_room_w(
-          _dec, Projection(5800.0, 5800.0, 450.0, 1.0, True, START, 5800.0))
-      == _room and _room > 0.0)
-check("20 s late at a 5800 W reading with 450 s left: 5800 x 20 / 450 W "
-      "less room",
-      abs(peakguard.charge_room_w(_dec, _late)
-          - (_room - 5800.0 * 20.0 / 450.0)) < 1e-6)
-check("never below 0 W, and an export held counts nothing",
-      peakguard.charge_room_w(_dec, Projection(
-          5800.0, 5800.0, 880.0, 850.0 / 880.0, False, START, 5800.0)) == 0.0
-      and peakguard.charge_room_w(_dec, Projection(
-          5800.0, 5800.0, 450.0, 430.0 / 450.0, False, START, -900.0))
-      == _room)
-check("None, blind (0 W) and no projection pass through",
-      peakguard.charge_room_w(None, _late) is None
-      and peakguard.charge_room_w(_dec, None) == _room
-      and peakguard.charge_room_w(
-          peakguard.PeakDecision(engaged=True, floor_w=0.0, ceiling_w=3500.0,
-                                 ceiling_from="cap", blind="frozen"),
-          _late) == 0.0)
-
-
-# ============================================================================ #
-def graded(label, full, aim):
-    print(f"    {label}: quarters "
-          f"{ {k: round(v, 1) for k, v in full.items()} } W, aim {aim:.0f}")
-    return len(full) >= 2 and all(v <= aim + TOL for v in full.values())
-
-
-def cut_and_back(rows):
-    """The charge is off in each quarter's last 5 s, and back (A charging
-    over 2 kW) within the next quarter's first minute."""
-    ends = [r for r in rows if into(r[0]) >= QUARTER_S - 5]
-    starts = {}
-    for r in rows:
-        if into(r[0]) < 60:
-            q = int(r[0].timestamp() // QUARTER_S)
-            starts[q] = starts.get(q, False) or r[2] < -2000.0
-    return (present(first(iter(ends), "a quarter end"))
-            and all(r[1] > -1.0 for r in ends)
-            and len(starts) >= 2 and all(starts.values()))
-
-
-print("\n2. a reading 30 s late at each quarter's end, the live shape")
-GAP = {}
-for name, kw, aim in (
-        ("month peak 5413 W banked, P1 projection",
-         dict(peak=PEAK), AIM_PEAK),
-        ("month peak banked, peak_forecast_entity (kW)",
-         dict(peak=PEAK, fc=True), AIM_PEAK),
-        ("no peak banked (aim = cap - margin), P1 projection",
-         dict(), AIM_CAP),
-        ("no peak banked, peak_forecast_entity", dict(fc=True), AIM_CAP)):
-    fc = kw.pop("fc", False)
-    _c, _rows, _full, _s = drive(opts(fc=fc), late=30.0, **kw)
-    GAP[name] = (_c, _rows, _full)
-    check(f"{name}: every quarter at or under the aim "
-          f"({aim:.0f} W, +{TOL:.0f} W landing)", graded(name, _full, aim))
-    check(f"{name}: the charge is off in the quarter's last seconds and "
-          f"back in the next quarter", cut_and_back(_rows))
-_c_fc = GAP["month peak banked, peak_forecast_entity (kW)"][0]
-check("the forecast entity is read, in kW, as the live template (SAFETY-118), "
-      "and the cheap run's charge does not depend on it",
-      _c_fc.peak_fc is not None and _c_fc.peak_fc > 1000.0
-      and [r[1] for r in GAP["month peak banked, peak_forecast_entity (kW)"]
-           [1]] == [r[1] for r in GAP[
-               "month peak 5413 W banked, P1 projection"][1]])
-
-
-# ============================================================================ #
-print("\n3. the same for a price trade (modes off) and a maintenance charge")
-_ca, _ra, _fa = drive(opts(modes=False, arb=True), peak=PEAK, late=30.0)[:3]
-check("modes off, price trading on, a reading 30 s late: every quarter at "
-      "or under the aim", graded("trade", _fa, AIM_PEAK)
-      and any(r[3] == "ARBITRAGE_CHARGE" for r in _ra))
-
-
-def late_feed(gap, every=0.0, look=None):
-    """safety84's cheap-window feed, no telegram in each quarter's last
-    `gap` s, and one only every `every` s (0: every cycle). `look(c, t)`
-    runs first, on the state the previous cycle left."""
-    feed = s84.feed(True)
-
-    def before(c, t):
-        if look is not None:
-            look(c, t)
-        if ((rig.BASE.timestamp() + t) % QUARTER_S < QUARTER_S - gap
-                and (not every or t % every < 1e-9)) \
-                or not getattr(c.hass, "_s84", False):
-            feed(c, t)
-    return before
-
-
-def rig_quarters(rows, load):
-    """The safety84 rig's whole quarters: the true average import (W)."""
-    qs = {}
-    for r in rows:
-        q = int((rig.BASE.timestamp() + r[0]) // QUARTER_S)
-        a = qs.setdefault(q, [0.0, 0])
-        a[0] += max(0.0, load(r[0]) - sum(v for _u, v in r[2]))
-        a[1] += 1
-    return {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"):
-            s / k for q, (s, k) in sorted(qs.items())
-            if k * rig.TICK >= QUARTER_S}
-
-
-for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
-    _mr, _mc = s84.run(2, load=lambda t, h=house: h, dur=2700.0,
-                       month_peak=peak, before=late_feed(30.0))
-    _mf = rig_quarters(_mr, lambda t, h=house: h)
-    check(f"N=2 maintenance charge, house {house:.0f} W, "
-          f"{'peak banked' if peak else 'no peak banked'}, a reading 30 s "
-          f"late: every quarter at or under the aim",
-          graded("maintenance", _mf, aim)
-          and any(mm.phase == "charge" for mm in _mc.maints))
-
-
-# ============================================================================ #
-print("\n4. a healthy meter: the quarters, and the words")
-for name, kw, aim, kw_text in (("month peak banked", dict(peak=PEAK),
-                                AIM_PEAK, "5.4 kW"),
-                               ("no peak banked", dict(), AIM_CAP, "3.5 kW")):
-    _c, _rows, _full, _s = drive(opts(), every=10, **kw)
-    check(f"{name}: every quarter at or under the aim",
-          graded(name, _full, aim))
-    over = [s for s in _s if not s[2] and s[0] > s[1]]
-    under = [s for s in _s if not s[2] and s[0] <= s[1]]
-    _o, _u = first(iter(over), "an over sample"), \
-        first(iter(under), "an under sample")
-    print(f"    over the limit at this rate ({len(over)} samples): "
-          f"{_o[3] if present(_o) else _o!s} / "
-          f"{_o[4] if present(_o) else _o!s}")
-    print(f"    under it ({len(under)}): "
-          f"{_u[3] if present(_u) else _u!s} / "
-          f"{_u[4] if present(_u) else _u!s}")
-    check(f"{name}: over the limit at this rate the guard row never says "
-          f"'under'; it says the grid charge is limited",
-          present(_o) and all(
-              "under" not in s[3] and "Peak guard: grid charge limited, "
-              "at this rate" in s[3] and " over " in s[3] for s in over))
-    check(f"{name}: ...and the month-peak line says the rate, and that the "
-          f"grid charge is cut back to stay under {kw_text}",
-          present(_o) and all(
-              s[4].startswith("At this rate this 15-minute period reaches")
-              and s[4].endswith("The grid charge is cut back to stay "
-                                f"under {kw_text}.") for s in over))
-    check(f"{name}: under the limit both read as before",
-          present(_u) and all(
-              s[3].startswith("Peak guard: idle, heading for")
-              and " under " in s[3]
-              and s[4].startswith("This 15-minute period is heading for")
-              and s[4].endswith(f"The batteries step in above {kw_text}.")
-              for s in under))
-
-
-# ============================================================================ #
-print("\n5. the words on their own")
-_en = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True)
-_cut = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True,
-                                    cut=True)
-_ok = messages.row_peak_guard_idle(5200.0, 5413.0, month_peak=True)
-print(f"    {_en}\n    {_cut}\n    {_ok}")
-check("over, nothing cut: 'idle, at this rate ..., over ...'",
-      _en == "Peak guard: idle, at this rate 5 814 W, over 5 413 W")
-check("over, a grid charge cut",
-      _cut == "Peak guard: grid charge limited, at this rate 5 814 W, "
-              "over 5 413 W")
-check("under: the 0.19.1 sentence, unchanged",
-      _ok == "Peak guard: idle, heading for 5 200 W, under this month's "
-             "5 413 W peak")
-check("the Dutch forms say the same",
-      _cut.nl == "Piekbewaking: laden beperkt, aan dit tempo 5 814 W, "
-                 "boven 5 413 W"
-      and _en.nl.startswith("Piekbewaking: in rust, aan dit tempo"))
-check("the month-peak line in shadow mode says 'would'",
-      homeview.line_period(5814.0, 5413.0, True, cut=True).endswith(
-          "The grid charge would be cut back to stay under 5.4 kW.")
-      and homeview.line_period(5814.0, 5413.0, False).endswith(
-          "The batteries step in above 5.4 kW."))
-
-
-# ============================================================================ #
-print("\n6. one inverter: the maintenance charge is sized to the room too")
-# The start-up quarter on a 10 s meter: the charge's first step is not seen
-# until the second reading, so it may land up to START_TOL over the aim; the
-# same at N=2 and before this fix. Every later quarter is graded at TOL.
-START_TOL = 15.0
-N1 = {}
-for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
-    for late, every in ((0.0, 0.0), (30.0, 0.0), (20.0, 10.0)):
-        _r, _c = s84.run(1, load=lambda t, h=house: h, dur=2700.0,
-                         month_peak=peak, before=late_feed(late, every))
-        _q = rig_quarters(_r, lambda t, h=house: h)
-        N1[peak, late, every] = (_r, _c)
-        _vals = list(_q.values())
-        _tag = (f"N=1, {'peak banked' if peak else 'no peak banked'}, "
-                f"{'10 s' if every else '5 s'} meter, "
-                f"{'late ' + format(late, '.0f') + ' s' if late else 'healthy'}")
-        print(f"    {_tag}: quarters "
-              f"{ {k: round(v, 1) for k, v in _q.items()} } W, aim {aim:.0f}")
-        check(f"{_tag}: every quarter at or under the aim",
-              len(_vals) == 3
-              and all(v <= aim + TOL for v in _vals[1:])
-              and nth(_vals, 0, "a first quarter")
-              <= aim + (START_TOL if every else TOL)
-              and any(mm.phase == "charge" for mm in _c.maints))
-_hr, _hc = N1[5413.0, 0.0, 0.0]
-_eng = sum(1 for r in _hr if r[-1][1] and r[-1][1][0])
-print(f"    healthy, peak banked: guard engaged on {_eng} of {len(_hr)} "
-      f"cycles; A charges on "
-      f"{sum(1 for r in _hr if dict(r[2])['a'] < -1.0)} cycles")
-check("N=1: the guard no longer steps in during the charge (no hand-back), "
-      "and the battery charges on every cycle, at no more than its rate",
-      _eng == 0 and all(-2000.0 <= dict(r[2])["a"] < -1.0 for r in _hr)
-      and not any("suspended" in e for e in _hc.events))
-
-
-# ============================================================================ #
-print("\n7. the row during an N=2 maintenance charge and in shadow mode")
-_rows7 = []
-
-
-def _look(c, t):
-    pg = c.peak_guard
-    if t >= QUARTER_S and pg is not None and pg.projected_w is not None \
-            and not pg.engaged and pg.projected_w > pg.ceiling_w:
-        _rows7.append(first((r["text"] for r in c.checks()
-                             if r["id"] == "peak_guard"), "guard row"))
-
-
-def _steps(t):
-    """4000 W, 800 W more for the first 30 s of every minute."""
-    return 4000.0 + (800.0 if t % 60.0 < 30.0 else 0.0)
-
-
-_m2r, _m2c = s84.run(2, load=_steps, dur=1800.0, month_peak=5413.0,
-                     before=late_feed(0.0, look=_look))
-_m2q = rig_quarters(_m2r, _steps)
-print(f"    N=2 maintenance charge, house steps 4000/4800 W: "
-      f"{len(_rows7)} over-the-limit rows, e.g. "
-      f"{first(iter(_rows7), 'a row')}; quarters "
-      f"{ {k: round(v, 1) for k, v in _m2q.items()} } W")
-check("N=2 maintenance charge, over the limit at this rate: the row says the "
-      "grid charge is limited",
-      present(first(iter(_rows7), "a row")) and all(
-          r.startswith("Peak guard: grid charge limited, at this rate")
-          for r in _rows7)
-      and all(v <= 5363.0 + TOL for v in _m2q.values()))
-_sh_o = dict(opts(), shadow_mode="on")
-_csh, _rsh, _fsh, _ssh = drive(_sh_o, peak=PEAK, minutes=17, every=10,
-                               plant=OnItsOwn)
-_sh_over = [s for s in _ssh if not s[2] and s[0] > s[1]]
-_sh1 = first(iter(_sh_over), "an over sample")
-print(f"    shadow mode, the inverter charging 5000 W on its own: "
-      f"{len(_sh_over)} over samples, e.g. "
-      f"{_sh1[3] if present(_sh1) else _sh1!s} / "
-      f"{_sh1[4] if present(_sh1) else _sh1!s}")
-check("shadow mode: nothing is cut on the wire, so the row says 'idle', "
-      "never 'grid charge limited', and the line says 'would'",
-      _csh.shadow and present(_sh1) and all(
-          s[3].startswith("Peak guard: idle, at this rate")
-          and "would" in s[4] for s in _sh_over))
-
-
-# ============================================================================ #
-print("\n8. edge cases")
-_e45 = drive(opts(), peak=PEAK, late=45.0)
-check("a reading 45 s late, past the 30 s hold (the guard goes blind): every "
-      "quarter at or under the aim", graded("late 45 s", _e45[2], AIM_PEAK))
-_e07 = drive(opts(), peak=PEAK, late=30.0, minutes=24,
-             start=START + timedelta(minutes=7))
-check("a start at 00:07, mid-quarter, then 30 s late: the next quarter at or "
-      "under the aim",
-      len(_e07[2]) == 1 and all(v <= AIM_PEAK + TOL
-                                for v in _e07[2].values()))
-print(f"    start at 00:07: {_e07[2]}")
-_dst = drive(opts(), peak=PEAK, late=30.0,
-             start=datetime(2026, 10, 25, 0, 45, tzinfo=timezone.utc))
-check("across the end of summer time (2026-10-25 01:00 UTC), 30 s late: "
-      "every quarter at or under the aim", graded("DST", _dst[2], AIM_PEAK))
-_ew = drive(opts(fc=True), peak=PEAK, late=30.0, fc_unit="W")
-check("the forecast entity in W: read as W, and the charge as with kW",
-      _ew[0].peak_fc is not None and _ew[0].peak_fc > 1000.0
-      and [r[1] for r in _ew[1]] == [r[1] for r in GAP[
-          "month peak banked, peak_forecast_entity (kW)"][1]])
-_e10 = drive(opts(), peak=PEAK, period=10.0)
-_e10v = list(_e10[2].values())
-print(f"    10 s meter: {_e10[2]}")
-check("a 10 s meter: every quarter after the start-up one at or under the "
-      "aim, and that one within START_TOL",
-      len(_e10v) == 2 and all(v <= AIM_PEAK + TOL for v in _e10v[1:])
-      and nth(_e10v, 0, "a first quarter") <= AIM_PEAK + START_TOL)
-_p_end = Projection(5800.0, 5800.0, 899.5, 898.5 / 899.5, False, START,
-                    5800.0)
-check("0.5 s left and 1 s late: finite, the formula, at its floor of 0 W",
-      peakguard.charge_room_w(_dec, _p_end) == max(
-          0.0, _room - 5800.0 * 1.0 / 0.5))
-_d_end = peakguard.decide(
-    Projection(5800.0, 5800.0, 900.0, 1.0, True, START, 5800.0),
-    batt_w=-4800.0, cap_w=3500, margin_w=50,
-    reading=types.SimpleNamespace(is_observed=True, peak_w=PEAK),
-    achievable_w=9600.0, soc=50.0, soc_floor=20.0)
-check("no second left: no room is measured (None), and nothing divides by 0",
-      peakguard.charge_room_w(_d_end, Projection(
-          5800.0, 5800.0, 900.0, 890.0 / 900.0, False, START, 5800.0))
-      is None)
-
-print()
-if fails:
-    print(f"{len(fails)} FAILED:")
-    for f in fails:
-        print(f"  - {f}")
-    sys.exit(1)
-print("all checks passed")
@@ -476,18 +476,13 @@ print("\n8. the N=1 and N=2 digests")
 # loop's bound just after the guard hands back are gone; every command and
 # claim is the same (test_safety119.py part 6). SAFETY-121 re-pinned all six
 # again: only OUTPUT_CLAMP rows (test_safety119.py part 6).
-# SAFETY-125 (0.19.2, owner 2026-10-29) re-pinned n1_charge and
-# n1_charge_banked: at N=1 the cheap-window charge is now sized to the
-# quarter's room, as at N=2, so the guard no longer steps in and discharges.
-# The banked quarters go 3461.9 -> 3450.0 W (aim 3450) and 3938.9 -> 3950.0
-# W (aim 3950). n1_charge_dear (no cheap window) is unchanged.
 PINNED = {
    "n1_charge":
-        "00f0a16b3ac1bd2830e9e0aaac8923fd9d1736c2bc6c543669bdd35b2fb542e9",
+        "0ed25c856456b97acb07a39299a8cb7b1a762c4d0005b88a0823c03057a80be5",
    "n1_charge_dear":
        "c25340b56060d4581f7204e200b07e7c8618711be2baca3b1667b7ebeb600dc3",
    "n1_charge_banked":
-        "09a08298d35195380ff427cdd2448d9212119be4692db26b2b1a45957fdf3300",
+        "2619acdd06b04e56c000b168d64e1d044346c6ba3f929c94258d6ad8189ec609",
    "n2_charge":
        "b16d692128f14bcce3d87b142d290e0d6b13724289680e44a05215c9eaa24a7c",
    "n2_charge_dear":
@@ -501,9 +496,8 @@ for k in PINNED:
          f"{_now[k][:16]}")
 check("⭐ at N=1 a charge in and out of a cheap window and under a banked "
      "month peak is byte-identical to 9d5b7d1 (commands, reasons and every "
-      "claim; the log as re-pinned by SAFETY-121; in a cheap window as "
-      "SAFETY-125 re-pinned it), and N=2 outside a cheap window matches its "
-      "SAFETY-85 pin",
+      "claim; the log as re-pinned by SAFETY-121), and N=2 outside a cheap "
+      "window matches its SAFETY-85 pin",
      all(_now[k] == PINNED[k] for k in ("n1_charge", "n1_charge_dear",
                                         "n1_charge_banked",
                                         "n2_charge_dear")))
@@ -522,9 +522,7 @@ print("\n9. N=1 is byte-identical to release/1.0 b8ddfd7")
 # log. The loop's bound just after a hand-back is not counted, so OUTPUT_CLAMP
 # rows are gone or count fewer; every command and claim is the same
 # (test_safety119.py part 6). SAFETY-121 re-pinned the same three again:
-# only OUTPUT_CLAMP rows (test_safety119.py part 6). SAFETY-125 (0.19.2)
-# re-pinned n1_charge_low: the N=1 cheap-window charge is sized to the
-# quarter's room, so the banked quarter goes 3458.9 -> 3450.0 W (aim 3450).
+# only OUTPUT_CLAMP rows (test_safety119.py part 6).
 PINNED = {   # tools/safety87_identity.py on b8ddfd7
    "n1_under":
        "d2395ef8d74fb23607ad864d5a4bf62c03044bbd9367e873675d7ad10e8c169f",
@@ -535,7 +533,7 @@ PINNED = {   # tools/safety87_identity.py on b8ddfd7
    "n1_under_banked":
        "a2876c7cc873bc4c974d2b4bd98e23bba2d007b84545587d2fe0b713b0a6249b",
    "n1_charge_low":
-        "c3af6218cc14c072e08b09550b153502dafec806009a92ba9032738b9ac9fa61",
+        "91336e3c0314985a3b00f314c79b5ffb5a740d218de3ad44f88a4db6e4235b32",
    "n1_hold":
        "0a1df347754c69166b20d04c15ee878bbcefb02abb824b9b452334f68f03e46d",
 }
@@ -544,8 +542,8 @@ for k in PINNED:
    print(f"    {k} {'same' if _now[k] == PINNED[k] else 'DIFFERS'}")
 check("⭐ every N=1 digest (claims, commands, the guard's decision and the "
      "log) equals b8ddfd7's (the log as re-pinned by SAFETY-121), under, "
-      "crossing and above the reserve, in a charge (as SAFETY-125 re-pinned "
-      "it) and a HOLD, and under a banked peak",
+      "crossing and above the reserve, in a charge and a HOLD, and under a "
+      "banked peak",
      _now == PINNED)

 # ============================================================================ #
@@ -1,374 +0,0 @@
-"""Runnable check for TARIFF-24.  `python3 test_tariff24.py`
-
-Battery modes on, a day/night `static_profile`, no price feed and the site trade
-switch off used to start no tariff task: `Controller.tariff_plan` stayed None,
-`mode_runs` stayed None, Leftover solar and Cheap hours never charged from the
-grid, and the Batteries screen said "No prices" while Home priced the day from
-the profile itself. DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
-
-1. The startup gate: `tariff_refresh_wanted()` by configuration, and the guard
-   `amain()` really puts on the task (read from its source, not retyped).
-2. End to end, on the real Controller and the real `run_tariff_refresh()` task,
-   started only if `amain()`'s own guard says so: night period, one battery
-   Leftover solar and one Cheap hours.
-3. The same with a gap below the cycle cost.
-4. Home and the Batteries screen agree.
-5. UX-55: with every battery Solar first Home no longer says "no prices have
-   arrived" on a static profile, and still does with no profile and no feed.
-6. Nothing else moved: modes off starts no task; the gate rows in part 1 keep
-   the arbitrage and feed cases as before.
-
-Mutations (MUTATION.md, purged copies, graded over this file): the gate
-reverted to `provider or arbitrage` fails 18 checks in parts 1 to 5; `True`
-fails the modes-off rows; `bool(opts.get(...))` fails the exact-true row;
-dropping the arbitrage term fails the arbitrage rows.
-"""
-
-import ast
-import asyncio
-import logging
-import os
-import sys
-import tempfile
-import time
-from datetime import datetime, timedelta, timezone
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-sys.path.insert(0, os.path.join(HERE, "tools"))
-logging.disable(logging.WARNING)
-
-import opt11p3_replay as rp                                    # noqa: E402
-from named_absence import first, nth, present                  # noqa: E402
-import app.main as m                                           # noqa: E402
-from app import homeview, modetrade, packmode                  # noqa: E402
-from app import price as _price, static_tariff as _st          # noqa: E402
-from app.main import Controller, tariff_refresh_wanted         # noqa: E402
-from app.p1 import make_sample, split_signed                   # noqa: E402
-from app.store import unit_key                                 # noqa: E402
-
-fails = []
-
-
-def check(name, cond):
-    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
-    if not cond:
-        fails.append(name)
-
-
-A, B = "inverter-a", "inverter-b"
-
-# A Belgian-style day/night tariff, example values: dear 07:00-22:00, cheap
-# 22:00-07:00, every day. The gap is 0.08 EUR/kWh.
-PROFILE = ('{"periods": ['
-           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
-           ' "eur_per_kwh": 0.22},'
-           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
-           ' "eur_per_kwh": 0.30}]}')
-# A Friday in winter time (+01:00), 23:00 local: inside the night period.
-L = timezone(timedelta(hours=1))
-NIGHT = datetime(2026, 10, 30, 23, 0, tzinfo=L).astimezone(timezone.utc)
-
-
-def opts(*, modes=True, arb=False, profile=PROFILE, provider=None,
-         cost=0.05):
-    o = dict(rp.options(modes, arb, 2))
-    o["cycle_cost_threshold_eur"] = cost
-    if profile is not None:
-        o["static_profile"] = profile
-    if provider is not None:
-        o["price_provider"] = provider
-    return o
-
-
-# --------------------------------------------------------------------------- #
-# The guard amain() puts on the tariff task, read from amain()'s source.
-# --------------------------------------------------------------------------- #
-def _guards_of(node, guards=()):
-    """[(guards, coroutine name)] for every create_task(...) under `node`."""
-    out = []
-    for child in ast.iter_child_nodes(node):
-        if isinstance(child, ast.If):
-            test = ast.unparse(child.test)
-            for stmt in child.body:
-                out += _guards_of(stmt, guards + (test,))
-            for stmt in child.orelse:
-                out += _guards_of(stmt, guards + (f"not ({test})",))
-            continue
-        if isinstance(child, ast.Call) and \
-                ast.unparse(child.func).endswith("create_task") and child.args:
-            arg = child.args[0]
-            name = (arg.func.attr if isinstance(arg, ast.Call)
-                    and isinstance(arg.func, ast.Attribute)
-                    else ast.unparse(arg))
-            out.append((guards, name))
-            continue
-        out += _guards_of(child, guards)
-    return out
-
-
-_TREE = ast.parse(open(os.path.join(HERE, "app", "main.py"),
-                       encoding="utf-8").read())
-_AMAIN = first((n for n in ast.walk(_TREE)
-                if isinstance(n, ast.AsyncFunctionDef) and n.name == "amain"),
-               "amain() in main.py")
-_TASK_GUARDS = [g for g, n in _guards_of(_AMAIN) if n == "run_tariff_refresh"]
-
-
-def task_started(o) -> bool:
-    """Would amain() start the tariff refresh task for options `o`?"""
-    if len(_TASK_GUARDS) != 1:
-        return False
-    return all(bool(eval(g, vars(m), {"opts": o})) for g in _TASK_GUARDS[0])
-
-
-# --------------------------------------------------------------------------- #
-print("1. the startup gate")
-check("amain() starts the tariff refresh from exactly one guard, and that "
-      "guard can be decided from the options alone",
-      len(_TASK_GUARDS) == 1 and len(_TASK_GUARDS[0]) >= 1
-      and all(isinstance(eval(g, vars(m), {"opts": opts()}), bool)
-              for g in _TASK_GUARDS[0]))
-GATE = [
-    # label, options, task wanted
-    ("modes on + static day/night only", opts(), True),
-    ("modes on + a fixed price only",
-     opts(profile='{"periods": [{"name": "all", "days": "all", "from": '
-                  '"00:00", "to": "24:00", "eur_per_kwh": 0.27}]}'), True),
-    ("modes on, nothing else", opts(profile=None), True),
-    ("modes off + arbitrage off + no feed (static profile)",
-     opts(modes=False), False),
-    ("modes off + arbitrage off + no feed, no profile",
-     opts(modes=False, profile=None), False),
-    ("modes off + arbitrage on", opts(modes=False, arb=True), True),
-    ("modes off + a feed", opts(modes=False, provider="generic_dayahead"),
-     True),
-    ("modes on + a feed", opts(provider="generic_dayahead"), True),
-    ("modes on + arbitrage on", opts(arb=True), True),
-]
-for label, o, want in GATE:
-    got = tariff_refresh_wanted(o)
-    print(f"    wanted={got!s:5}  started={task_started(o)!s:5}  {label}")
-    check(f"{label}: tariff_refresh_wanted() is {want}", got is want)
-    check(f"{label}: amain() starts the task exactly as that says",
-          task_started(o) is want)
-check("battery_modes_enabled has to be exactly true (packmode.enabled()): "
-      "'true' as text or 1 does not start the task",
-      not tariff_refresh_wanted(dict(opts(), battery_modes_enabled="true"))
-      and not tariff_refresh_wanted(dict(opts(), battery_modes_enabled=1)))
-
-
-# --------------------------------------------------------------------------- #
-# The real Controller over a few minutes of a night: the task starts only if
-# amain()'s own guard says so; then read_inputs() + cycle() as the control
-# loop runs them.
-# --------------------------------------------------------------------------- #
-CHOICE = {"a": (True, "leftover_solar", False),
-          "b": (True, "cheap_hours", False)}
-
-
-FETCHES = []
-
-
-async def _no_fetch(*a, **k):
-    FETCHES.append(a)
-    raise AssertionError("the tariff task reached for a price feed")
-
-
-def drive(o, *, start=NIGHT, minutes=20, soc0=None, choice=CHOICE,
-          house_w=300.0, tick=5.0):
-    """-> (controller, rows, task_was_started)."""
-    store = rp._Store()
-    for u, (use, mode, sell) in choice.items():
-        store.data[unit_key(f"inverter-{u}", "pack_use")] = use
-        store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode
-        store.data[unit_key(f"inverter-{u}", "pack_sell")] = sell
-    rows = []
-
-    async def go():
-        hass = rp.Hass(("a", "b"), lambda t: house_w,
-                       soc0 or {"a": 40.0, "b": 40.0})
-        tmp = tempfile.mkdtemp(prefix="t24-")
-        c = Controller(dict(o), hass, store, rp._Pub(),
-                       stop=asyncio.Event(),
-                       peak_db_path=os.path.join(tmp, "tariff.db"),
-                       price_history_path=os.path.join(tmp, "ph.json"))
-        for i in c.inverters:
-            i.dev_min, i.dev_max = -5000.0, 5000.0
-        c.auto = True
-        real_dt, real_hv = m.datetime, homeview.datetime
-        clock = [start]
-
-        class _DT(real_dt):
-            @classmethod
-            def now(cls, tz=None):
-                return clock[0] if tz is None else clock[0].astimezone(tz)
-
-        m.datetime = homeview.datetime = _DT
-        _real_load = _price.load_prices, _st.load_prices
-        _price.load_prices = _st.load_prices = _no_fetch
-        started = task_started(o)
-        task = (asyncio.create_task(c.run_tariff_refresh())
-                if started else None)
-        try:
-            t = 0.0
-            while t < minutes * 60:
-                now = start + timedelta(seconds=t)
-                hass.t = t
-                clock[0] = now
-                if t == 0.0 and started:
-                    for _ in range(500):     # let the task do its first pass
-                        if c.tariff_plan is not None:
-                            break
-                        await asyncio.sleep(0)
-                imp, exp = split_signed(hass.grid())
-                c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
-                                        ingest_ts=now,
-                                        ingest_mono=time.monotonic()))
-                await c.read_inputs(now_mono=t)
-                await c.cycle()
-                hass.advance(tick, 10.0)
-                rows.append(dict(
-                    now=now, runs=c.mode_runs, tick=c.mode_tick,
-                    plan=c.fresh_tariff_plan(now),
-                    action=getattr(c.arb, "action", None),
-                    p={u: p.p for u, p in hass.plants.items()},
-                    soc={u: p.soc for u, p in hass.plants.items()}))
-                t += tick
-            # What the two screens say at the end, while the clock is still
-            # the simulated one.
-            c.home_plan = homeview.build_plan(c, clock[0], False, True)
-            c.battery_cards = homeview.battery_rows(c, False, True)
-        finally:
-            if task is not None:
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
-            m.datetime, homeview.datetime = real_dt, real_hv
-            _price.load_prices, _st.load_prices = _real_load
-        return c, started
-
-    c, started = asyncio.run(go())
-    return c, rows, started
-
-
-def charging_b(rows):
-    """Cycles in which the Cheap hours battery was charging (grid: no sun and
-    a 300 W house in this scenario)."""
-    return [r for r in rows if r["p"]["b"] < -200.0]
-
-
-def why_of(c, name):
-    card = first((b for b in c.battery_cards if b["name"] == name),
-                 f"a card for {name}")
-    return card["why_key"]
-
-
-# --------------------------------------------------------------------------- #
-print("\n2. end to end, night, modes on, static day/night, no feed, no arbitrage")
-c1, r1, started1 = drive(opts())
-_last = nth(r1, -1, "the last cycle")
-_first1 = nth(r1, 0, "the first cycle")
-print(f"    tariff task started by amain's guard: {started1}")
-print(f"    tariff_plan: {None if c1.tariff_plan is None else c1.tariff_plan.words}")
-print(f"    mode_runs: {_last['runs']}")
-print(f"    mode_tick reason / roles: "
-      f"{None if _last['tick'] is None else (_last['tick'].why, dict(_last['tick'].roles))}")
-print(f"    Batteries screen why_key: A {why_of(c1, A)}, B {why_of(c1, B)}")
-print(f"    cycles with B charging: {len(charging_b(r1))} of {len(r1)}, "
-      f"B soc {_first1['soc']['b']:.1f} -> {_last['soc']['b']:.1f}")
-check("the tariff refresh task is started", started1)
-check("...and it adds no network call: with price_provider off the feed "
-      "loader is never reached (it is replaced by one that fails)",
-      not FETCHES and not _price.provider_configured(opts()))
-check("a fresh tariff plan with prices is held", present(_last)
-      and _last["plan"] is not None and _last["plan"].has_prices)
-check("the price runs exist (mode_runs is not None) and carry a cheap run "
-      "that holds in the night period",
-      present(_last) and _last["runs"] is not None and _last["runs"].on
-      and _last["runs"].cheap is not None
-      and _last["runs"].cheap.holds(_last["now"]))
-check("the Cheap hours battery charges from the grid in the night period",
-      len(charging_b(r1)) > len(r1) // 2
-      and present(_last, _first1)
-      and _last["soc"]["b"] > _first1["soc"]["b"] + 0.3)
-check("...and the Leftover solar battery does not (no sun, no forecast)",
-      not any(r["p"]["a"] < -200.0 for r in r1))
-check("...the reason is not 'no prices': neither battery reads no_prices",
-      why_of(c1, A) != "no_prices" and why_of(c1, B) != "no_prices")
-check("...only the Cheap hours battery got the grid charge role",
-      present(_last) and _last["tick"] is not None
-      and _last["tick"].roles.get(B) == modetrade.CHARGE
-      and _last["tick"].roles.get(A) != modetrade.CHARGE)
-
-# --------------------------------------------------------------------------- #
-print("\n3. the same with a gap below the cycle cost")
-c3, r3, started3 = drive(opts(cost=0.20))
-_l3 = nth(r3, -1, "the last cycle")
-print(f"    started {started3}; mode_runs {_l3['runs']}; "
-      f"why A {why_of(c3, A)}, B {why_of(c3, B)}")
-check("the task is started and the plan is there, so mode_runs is not None",
-      started3 and present(_l3) and _l3["plan"] is not None
-      and _l3["runs"] is not None)
-check("the reason is the gap: no_spread ('Prices differ too little'), "
-      "never no_prices, on both batteries",
-      why_of(c3, A) == "no_spread" and why_of(c3, B) == "no_spread"
-      and present(_l3) and _l3["runs"] is not None
-      and not _l3["runs"].on)
-check("...and no battery charges from the grid",
-      not charging_b(r3) and not any(r["p"]["a"] < -200.0 for r in r3))
-
-# --------------------------------------------------------------------------- #
-print("\n4. Home and the Batteries screen agree")
-hp = c1.home_plan
-_bars = [b for b in hp["prices"] if b["eur_kwh"] is not None]
-_words = {b["why_key"]: b["why"] for b in c1.battery_cards}
-print(f"    Home: has_prices {hp['has_prices']}, {len(_bars)} priced bars, "
-      f"verdict {hp['verdict_key']}, lines {hp['lines']}")
-print(f"    Batteries: {[(b['name'], b['why_key'], b['why']) for b in c1.battery_cards]}")
-check("Home prices the day, and the Batteries screen does not say it has no "
-      "prices", hp["has_prices"] and _bars
-      and all(b["why_key"] != "no_prices" for b in c1.battery_cards))
-check("Home's plan has the grid charge block for the Cheap hours battery "
-      "(the 'trade' verdict) and no 'no prices have arrived' line",
-      hp["verdict_key"] == "trade"
-      and any(r["kind"] == "grid" for r in hp["runs"])
-      and not any("no prices have arrived" in ln for ln in hp["lines"]))
-hp3 = c3.home_plan
-check("with the gap too small both say so: Home 'price gap is too small', "
-      "the batteries 'differ too little'; neither says no prices",
-      any("price gap is too small" in ln for ln in hp3["lines"])
-      and all(b["why_key"] == "no_spread" for b in c3.battery_cards))
-
-# --------------------------------------------------------------------------- #
-print("\n5. UX-55: every battery Solar first, static day/night, no feed")
-SF = {"a": (True, "solar_first", False), "b": (True, "solar_first", False)}
-c5, r5, s5 = drive(opts(), choice=SF, minutes=5)
-print(f"    Home lines: {c5.home_plan['lines']}")
-check("Home no longer says 'no prices have arrived' with every battery Solar "
-      "first on a static profile",
-      s5 and not any("no prices have arrived" in ln
-                     for ln in c5.home_plan["lines"]))
-c5b, r5b, s5b = drive(opts(profile=None), choice=SF, minutes=5)
-print(f"    no profile, no feed: started {s5b}, Home lines "
-      f"{c5b.home_plan['lines']}")
-check("...and with no profile and no feed there are truly no prices, and "
-      "Home still says so",
-      any("no prices have arrived" in ln for ln in c5b.home_plan["lines"]))
-
-# --------------------------------------------------------------------------- #
-print("\n6. nothing else moved")
-c6, r6, s6 = drive(opts(modes=False), choice={}, minutes=5)
-check("modes off, arbitrage off, no feed: no task, no plan, no price runs "
-      "(as before)", not s6 and c6.tariff_plan is None
-      and all(r["runs"] is None for r in r6))
-
-print()
-if fails:
-    print(f"{len(fails)} FAILED:")
-    for f in fails:
-        print(f"  - {f}")
-    sys.exit(1)
-print("all checks passed")
@@ -1,439 +0,0 @@
-"""Runnable check for TARIFF-24 round 2 (AUDIT-02 F1).  `python3 test_tariff24_weather.py`
-
-With battery modes on, the price gap a mode needs was always widened x1.5
-(`Uncertainty.NO_WEATHER`) even with a solar forecast read. Now the doubt is
-added only when no usable forecast is read (`arbitrage.weather_uncertainty()`),
-in the run plan (`_price_runs()`), the charge gate (`_mode_roles()`) and Home's
-mirror (`homeview.trade_verdict()`). Modes off is untouched.
-DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
-
-1. The rule itself, and that modes off keeps the doubt.
-2. Day/night 0.34/0.26 (gap 0.08), modes on, real Controller, night period:
-   with a forecast at cycle cost 0.07 the cheap run is planned and the Cheap
-   hours battery charges; without one, or with a stale one, the same cost needs
-   0.105 and the reason is `not_worth` / "Prices differ too little".
-3. A dynamic day with a 0.12 gap at cost 0.10: on with a forecast, not worth
-   without.
-4. The forecast coming (the gate follows in the same cycle) and going mid-run:
-   a run under way keeps its gap to its end, the next run needs the wider one;
-   a forecast unavailable for one or two reads mid-run does not stop or
-   restart the charge.
-5. Home agrees with control in each case (Batteries Why, Home line, and
-   `trade_verdict()`, Home's mirror of the gate).
-
-Mutations (MUTATION.md, purged copies, graded over this file): the doubt always
-added (the old code) fails parts 2 to 5; never added fails the without-forecast
-rows; Home's mirror left on the old rule fails part 5.
-"""
-
-import asyncio
-import logging
-import math
-import os
-import sys
-import tempfile
-import time
-from datetime import datetime, timedelta, timezone
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-sys.path.insert(0, os.path.join(HERE, "tools"))
-logging.disable(logging.WARNING)
-
-import opt11p3_replay as rp                                    # noqa: E402
-from named_absence import first, nth, present                  # noqa: E402
-import app.main as m                                           # noqa: E402
-from app import arbitrage, homeview, modetrade                 # noqa: E402
-from app.main import Controller                                # noqa: E402
-from app.p1 import make_sample, split_signed                   # noqa: E402
-from app.price import (PricePoint, PriceProduct, PriceRead,    # noqa: E402
-                       Uncertainty, brussels)
-from app.static_tariff import TariffPlan                       # noqa: E402
-from app.store import unit_key                                 # noqa: E402
-
-fails = []
-
-
-def check(name, cond):
-    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
-    if not cond:
-        fails.append(name)
-
-
-A, B = "inverter-a", "inverter-b"
-PROFILE = ('{"periods": ['
-           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
-           ' "eur_per_kwh": 0.26},'
-           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
-           ' "eur_per_kwh": 0.34}]}')
-L = timezone(timedelta(hours=1))
-NIGHT = datetime(2026, 10, 30, 23, 0, tzinfo=L).astimezone(timezone.utc)
-CHOICE = {"a": (True, "leftover_solar", False),
-          "b": (True, "cheap_hours", False)}
-FC_TODAY, FC_TOMORROW = "sensor.fc_today", "sensor.fc_tomorrow"
-TARIFF_REFRESH_S = m.TARIFF_REFRESH_S
-
-
-def opts(cost, *, arb=False, sensors=True):
-    o = dict(rp.options(True, arb, 2))
-    o.update(cycle_cost_threshold_eur=cost, static_profile=PROFILE)
-    if sensors:
-        o.update(pv_forecast_entity=FC_TODAY,
-                 pv_forecast_tomorrow_entity=FC_TOMORROW)
-    return o
-
-
-def dynamic_points(start):
-    """A dynamic day-ahead shape, 0.16 .. 0.28 (gap 0.12), 15-minute points."""
-    out, t = [], start.replace(minute=0, second=0, microsecond=0)
-    for _ in range(48 * 4):
-        h = brussels(t).hour + brussels(t).minute / 60
-        p = 0.22 + 0.06 * math.cos((h - 19) / 24 * 2 * math.pi)
-        out.append(PricePoint(start=brussels(t), eur_per_kwh=round(p, 4),
-                              provisional=False))
-        t += timedelta(minutes=15)
-    return out
-
-
-def sensor(kwh, at):
-    return {"state": f"{kwh}", "attributes": {"unit_of_measurement": "kWh"},
-            "last_updated": at.isoformat(), "last_reported": at.isoformat()}
-
-
-def forecast_mode(mode, t, now):
-    """What the two forecast sensors read: 'fresh', 'stale', 'gone', or a
-    function of the simulated seconds that returns one of those."""
-    if callable(mode):
-        mode = mode(t)
-    if mode == "gone":
-        return {"state": "unavailable", "attributes": {}}
-    at = now if mode == "fresh" else now - timedelta(hours=5)
-    return at
-
-
-def take(c, now):
-    """What Home and the Batteries screen say now, and Home's mirror of the
-    gate (it reads the trade switch, so ask it as a site that has it on next
-    to the modes)."""
-    keep = c.o
-    c.o = dict(keep, arbitrage_enabled=True)
-    try:
-        mirror, why = homeview.trade_verdict(c, c.fresh_tariff_plan(now), now)
-    finally:
-        c.o = keep
-    return dict(home=homeview.build_plan(c, now, False, True),
-                cards=homeview.battery_rows(c, False, True),
-                mirror=mirror, mirror_why=why)
-
-
-def drive(o, *, fc="fresh", points=None, minutes=20, tick=5.0,
-          house_w=300.0, soc0=None, snap_at=()):
-    """-> (controller, rows). `points`: a feed-shaped plan injected every
-    cycle (no task); else the static profile via the real tariff task."""
-    store = rp._Store()
-    for u, (use, mode, sell) in CHOICE.items():
-        for k, val in (("pack_use", use), ("pack_mode", mode),
-                       ("pack_sell", sell)):
-            store.data[unit_key(f"inverter-{u}", k)] = val
-    rows = []
-    snaps = {}
-
-    class H(rp.Hass):
-        async def state(self, e):
-            now = NIGHT + timedelta(seconds=self.t)
-            if fc is None:
-                return None
-            at = forecast_mode(fc, self.t, now)
-            if isinstance(at, dict):
-                return at
-            return sensor(0.0 if e == FC_TODAY else 12.0, at)
-
-    async def go():
-        hass = H(("a", "b"), lambda t: house_w, soc0 or {"a": 40.0, "b": 40.0})
-        tmp = tempfile.mkdtemp(prefix="t24w-")
-        c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
-                       peak_db_path=os.path.join(tmp, "tariff.db"),
-                       price_history_path=os.path.join(tmp, "ph.json"))
-        for i in c.inverters:
-            i.dev_min, i.dev_max = -5000.0, 5000.0
-        c.auto = True
-        real_dt, real_hv = m.datetime, homeview.datetime
-        clock = [NIGHT]
-
-        class _DT(real_dt):
-            @classmethod
-            def now(cls, tz=None):
-                return clock[0] if tz is None else clock[0].astimezone(tz)
-
-        m.datetime = homeview.datetime = _DT
-        pts = None if points is None else points
-        task = None
-        if pts is None:
-            task = asyncio.create_task(c.run_tariff_refresh())
-        try:
-            t = 0.0
-            while t < minutes * 60:
-                now = NIGHT + timedelta(seconds=t)
-                hass.t = t
-                clock[0] = now
-                if pts is not None:
-                    c.tariff_plan = TariffPlan(
-                        PriceRead.series(pts, PriceProduct.DAY_AHEAD,
-                                         "generic_dayahead", now), None,
-                        "provider")
-                    c.tariff_at = now
-                elif t == 0.0 or t % TARIFF_REFRESH_S == 0.0:
-                    # The task's own 30 min wait is wall clock, so the
-                    # simulated clock restarts it: one refresh per period.
-                    if task is not None and t > 0.0:
-                        task.cancel()
-                        try:
-                            await task
-                        except asyncio.CancelledError:
-                            pass
-                        task = asyncio.create_task(c.run_tariff_refresh())
-                    for _ in range(500):
-                        if c.tariff_plan is not None and (
-                                c.tariff_at is not None and c.tariff_at >= now):
-                            break
-                        await asyncio.sleep(0)
-                imp, exp = split_signed(hass.grid())
-                c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
-                                        ingest_ts=now,
-                                        ingest_mono=time.monotonic()))
-                await c.read_inputs(now_mono=t)
-                await c.cycle()
-                hass.advance(tick, 10.0)
-                rp_ = c.mode_runs
-                rows.append(dict(
-                    t=t, now=now, fc_none=c.solar_fc is None,
-                    runs_on=None if rp_ is None else rp_.on,
-                    reason=None if rp_ is None else rp_.reason,
-                    roles=dict(c.mode_tick.roles) if c.mode_tick else {},
-                    why=None if c.mode_tick is None else c.mode_tick.why,
-                    charging=hass.plants["b"].p < -200.0,
-                    soc_b=hass.plants["b"].soc,
-                    cheap_end=None if rp_ is None or rp_.cheap is None
-                    else rp_.cheap.end))
-                if t in snap_at:
-                    snaps[t] = take(c, now)
-                t += tick
-            last = take(c, clock[0])
-            c.home_plan, c.cards = last["home"], last["cards"]
-            c.mirror, c.mirror_why = last["mirror"], last["mirror_why"]
-            c.snaps = snaps
-        finally:
-            if task is not None:
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
-            m.datetime, homeview.datetime = real_dt, real_hv
-        return c
-
-    return asyncio.run(go()), rows
-
-
-def why_of(c, name):
-    card = first((b for b in c.cards if b["name"] == name), f"card {name}")
-    return card["why_key"]
-
-
-# --------------------------------------------------------------------------- #
-print("1. the rule")
-NW = frozenset({Uncertainty.NO_WEATHER})
-check("modes on with a forecast read: no doubt", arbitrage.weather_uncertainty(
-    True, object()) == frozenset())
-check("modes on with no forecast (None): the doubt", arbitrage.weather_uncertainty(
-    True, None) == NW)
-check("modes off, forecast or not: the doubt, as before",
-      arbitrage.weather_uncertainty(False, object()) == NW
-      and arbitrage.weather_uncertainty(False, None) == NW)
-
-# --------------------------------------------------------------------------- #
-print("\n2. day/night 0.34 / 0.26 (gap 0.08), night period")
-c1, r1 = drive(opts(0.07), fc="fresh")
-l1 = nth(r1, -1, "last cycle")
-print(f"    forecast read, cost 0.07: mode_runs on={l1['runs_on']} "
-      f"reason={l1['reason']}; B charging {sum(r['charging'] for r in r1)} of "
-      f"{len(r1)}; Why A {why_of(c1, A)} B {why_of(c1, B)}")
-check("with a forecast at cost 0.07 the cheap run is planned (needed 0.07 < "
-      "0.08) and the Cheap hours battery charges in the night period",
-      present(l1) and not l1["fc_none"] and l1["runs_on"] is True
-      and sum(r["charging"] for r in r1) > len(r1) // 2
-      and l1["roles"].get(B) == modetrade.CHARGE)
-for label, mode in (("no forecast sensor reads", "gone"),
-                    ("a stale forecast", "stale")):
-    c, rr = drive(opts(0.07), fc=mode)
-    ll = nth(rr, -1, "last cycle")
-    print(f"    {label}, cost 0.07: on={ll['runs_on']} reason={ll['reason']}; "
-          f"B charging {sum(r['charging'] for r in rr)}; Why A "
-          f"{why_of(c, A)} B {why_of(c, B)}")
-    check(f"{label}: the same cost needs 0.105 > 0.08, so not_worth and "
-          f"'Prices differ too little', no grid charge",
-          present(ll) and ll["fc_none"] and ll["runs_on"] is False
-          and ll["reason"] == "not_worth"
-          and why_of(c, A) == "no_spread" and why_of(c, B) == "no_spread"
-          and not any(r["charging"] for r in rr))
-c0, r0 = drive(opts(0.07, sensors=False), fc=None)
-check("no forecast sensor configured at all: not_worth too (as 0.19.0)",
-      present(nth(r0, -1)) and r0[-1]["runs_on"] is False)
-c2, r2 = drive(opts(0.10), fc="fresh")
-check("at the shipped cost 0.10 even a forecast does not make 0.08 enough "
-      "(needs 0.10): still not_worth, honestly",
-      present(nth(r2, -1)) and r2[-1]["runs_on"] is False
-      and r2[-1]["reason"] == "not_worth")
-
-# --------------------------------------------------------------------------- #
-print("\n3. a dynamic day, gap 0.12, cost 0.10")
-pts = dynamic_points(NIGHT - timedelta(hours=1))
-cd, rd = drive(opts(0.10), fc="fresh", points=pts)
-cn, rn = drive(opts(0.10), fc="gone", points=pts)
-_ld, _ln = nth(rd, -1, "last cycle"), nth(rn, -1, "last cycle")
-print(f"    with forecast: on={_ld['runs_on']} reason={_ld['reason']}; "
-      f"without: on={_ln['runs_on']} reason={_ln['reason']}")
-check("with a forecast the run plan is on (needs 0.10 < 0.12)",
-      present(nth(rd, -1)) and rd[-1]["runs_on"] is True
-      and why_of(cd, A) != "no_spread")
-check("without one it is not_worth (needs 0.15 > 0.12) and says so",
-      present(nth(rn, -1)) and rn[-1]["runs_on"] is False
-      and rn[-1]["reason"] == "not_worth"
-      and why_of(cn, B) == "no_spread")
-
-# --------------------------------------------------------------------------- #
-print("\n4. the forecast going and coming mid-run (a run under way keeps its gap)")
-CUT = 600.0                      # 10 min in
-SOC = {"a": 40.0, "b": 60.0}     # B's cheap run is then about 2 h
-
-
-def going(t):
-    return "fresh" if t < CUT else "gone"
-
-
-def coming(t):
-    return "gone" if t < CUT else "fresh"
-
-
-def flap(n_reads):
-    """Unavailable for `n_reads` forecast reads (60 s apart) from CUT."""
-    return lambda t: "gone" if CUT <= t < CUT + 60.0 * n_reads else "fresh"
-
-
-MID, AFTER = 3000.0, 7800.0
-cg, rg = drive(opts(0.07), fc=going, minutes=135, soc0=SOC,
-               snap_at=(MID, AFTER))
-cc, rc = drive(opts(0.07), fc=coming, minutes=25)
-_end = nth([r["cheap_end"] for r in rg if r["cheap_end"] is not None], 0,
-           "the cheap run's end")
-_end_t = (_end - NIGHT).total_seconds() if present(_end) else 1e9
-lost = [r for r in rg if r["fc_none"]]
-print(f"    going: cheap run ends at t={_end_t:.0f} s; forecast lost from "
-      f"t={lost[0]['t'] if lost else None}")
-check("going: the run planned with the forecast ends before the snapshot "
-      "taken after it (the scenario is long enough)",
-      present(_end) and CUT + 300.0 < _end_t < AFTER - 300.0 and bool(lost)
-      and lost[0]["t"] - CUT <= 60.0)
-check("going: the forecast read is lost mid-run and the run under way KEEPS "
-      "its gap: the plan stays on and B keeps charging, cycle after cycle, "
-      "until B is full or the run ends",
-      all(r["runs_on"] is True and (r["roles"].get(B) == modetrade.CHARGE
-                                    or r["soc_b"] >= 94.0)
-          for r in rg if r["fc_none"] and r["t"] < _end_t - 60.0)
-      and all(r["charging"] or r["soc_b"] >= 94.0 for r in rg
-              if 60.0 <= r["t"] < _end_t - 60.0)
-      and max(r["soc_b"] for r in rg if r["fc_none"]) >= 90.0)
-check("going: from the run's end the wider gap is back: the next run is "
-      "not_worth (needs 0.105 at 0.07), no new run, and no grid charge",
-      all(r["runs_on"] is False and r["reason"] == "not_worth"
-          for r in rg if r["t"] >= _end_t + 30.0)
-      and not any(r["charging"] for r in rg if r["t"] >= _end_t + 60.0))
-_sm, _sa = cg.snaps.get(MID), cg.snaps.get(AFTER)
-check("going, Home agrees mid-run: its mirror still allows, the Batteries "
-      "screen says it charges from the grid, and Home does not say the gap "
-      "is too small",
-      _sm is not None and _sm["mirror"] is not None
-      and first((b for b in _sm["cards"] if b["name"] == B),
-                "a card")["why_key"] == "grid_charge"
-      and not any("price gap is too small" in ln
-                  for ln in _sm["home"]["lines"]))
-check("going, Home agrees after the run: its mirror refuses, the Batteries "
-      "screen says 'differ too little' and Home says the gap is too small",
-      _sa is not None and _sa["mirror"] is None
-      and first((b for b in _sa["cards"] if b["name"] == B),
-                "a card")["why_key"] == "no_spread"
-      and any("price gap is too small" in ln for ln in _sa["home"]["lines"]))
-for n in (1, 2):
-    cf, rf = drive(opts(0.07), fc=flap(n), minutes=30, soc0=SOC,
-                   snap_at=(CUT + 30.0,))
-    gone = [r for r in rf if r["fc_none"]]
-    print(f"    flap, {n} read(s) lost: {len(gone)} cycles without a "
-          f"forecast; B charging in {sum(r['charging'] for r in rf)} of "
-          f"{len(rf)}")
-    check(f"flap: the forecast is unavailable for {n} read(s) mid-run: the "
-          f"plan stays on and B charges without a break (no stop, no "
-          f"restart)",
-          bool(gone) and all(r["runs_on"] is True for r in rf)
-          and all(r["charging"] and r["roles"].get(B) == modetrade.CHARGE
-                  for r in rf if r["t"] >= 60.0))
-    sf = cf.snaps.get(CUT + 30.0)
-    check(f"flap, {n} read(s): Home agrees while the read is lost (mirror "
-          f"allows, Batteries 'charges from the grid')",
-          sf is not None and sf["mirror"] is not None
-          and first((b for b in sf["cards"] if b["name"] == B),
-                    "a card")["why_key"] == "grid_charge")
-
-
-def flips(rows):
-    """Cycles where the forecast read changed, and whether the plan and the
-    charge gate changed in that very cycle."""
-    out = []
-    for i in range(1, len(rows)):
-        if rows[i]["fc_none"] != rows[i - 1]["fc_none"]:
-            out.append((i, rows[i]["t"], rows[i]["runs_on"],
-                        rows[i]["charging"], rows[i - 1]["charging"]))
-    return out
-
-
-fcm = flips(rc)
-print(f"    coming: forecast read arrives at cycle/t {fcm}")
-check("coming (no run under way before): not_worth until the read is back, "
-      "then on in the same cycle, and the battery charges",
-      len(fcm) == 1 and fcm[0][1] - CUT <= 60.0 and fcm[0][2] is True
-      and all(r["runs_on"] is False for r in rc if r["fc_none"])
-      and all(r["runs_on"] is True for r in rc if not r["fc_none"])
-      and any(r["charging"] for r in rc if r["t"] >= fcm[0][1] + 40.0))
-
-# --------------------------------------------------------------------------- #
-print("\n5. Home agrees with control")
-CASES = (("forecast, cost 0.07", c1, r1, True),
-         ("no forecast, cost 0.07", *drive(opts(0.07), fc="gone"), False),
-         ("dynamic, forecast", cd, rd, True),
-         ("dynamic, no forecast", cn, rn, False))
-for label, cx, rx, on in CASES:
-    last = nth(rx, -1, "last cycle")
-    hp = cx.home_plan
-    mirror_ok = cx.mirror is not None
-    print(f"    {label}: control on={last['runs_on']}; Home mirror "
-          f"{'allows' if mirror_ok else 'refuses'} ({cx.mirror_why}); "
-          f"lines {hp['lines'][:1]}; Why B {why_of(cx, B)}")
-    check(f"{label}: Home's mirror of the gate allows exactly when control "
-          f"plans", present(last) and mirror_ok is on
-          and last["runs_on"] is on)
-    check(f"{label}: the Batteries screen and the Home line say the gap is "
-          f"too small exactly when control does",
-          (why_of(cx, B) == "no_spread") is (not on)
-          and any("price gap is too small" in ln for ln in hp["lines"])
-          is (not on))
-    if label.startswith("dynamic"):
-        continue    # its cheap run is tomorrow morning: not on today's chart
-    check(f"{label}: Home draws a grid charge block exactly when control "
-          f"charges", any(r["kind"] == "grid" for r in hp["runs"]) is on)
-
-print()
-if fails:
-    print(f"{len(fails)} FAILED:")
-    for f in fails:
-        print(f"  - {f}")
-    sys.exit(1)
-print("all checks passed")
@@ -0,0 +1,589 @@
+"""Runnable check for UX-53.  `python3 test_ux53.py`
+
+Home draws a grid charge only where the add-on will take it.
+
+1. Modes on (F-1): inside a cheap run that is under way, the trade gate
+   (`TariffPlan.arbitrage()`, as `Controller._mode_roles()` asks it) refuses
+   with `not_worth`. The control cycle files that as `Controller.mode_gate`,
+   and Home draws no charge, and marks no cheap quarter, from then on. With
+   the gate open the charge is drawn as before. The real `_mode_roles()` runs
+   at each instant, so the page is graded against the decision it makes.
+2. Modes off (F-2): the verdict's charge comes after its last dear period.
+   Home asks the same gate at the charge's own start (`homeview.leg_taken()`):
+   a flat remainder is refused there, so no charge is drawn and no quarter is
+   marked cheap. A charge the gate allows at its start is drawn as before, and
+   so is the sale.
+3. Wording, English and Dutch: "lowest price left", and "a fully fixed
+   product" only for a real fixed product.
+4. Day/night and price-off pages are the same as before.
+
+Mutations (MUTATION.md, purged copies): listed in the pull request.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+from app import arbitrage, homeview, modetrade, packmode        # noqa: E402
+from app.main import Controller                                 # noqa: E402
+from app.peakguard import PeakDecision                          # noqa: E402
+from app.price import (PricePoint, PriceProduct, PriceRead,     # noqa: E402
+                       Uncertainty, brussels)
+from app.static_tariff import TariffPlan, static_plan           # noqa: E402
+from app.store import unit_key                                  # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+UTC = timezone.utc
+
+
+class _Store:
+    def __init__(self):
+        self.data = {}
+
+    def set(self, k, v):
+        self.data[k] = v
+
+    def get(self, k, d=None):
+        return self.data.get(k, d)
+
+    def set_time(self, k, v):
+        self.data[k] = v.isoformat()
+
+    def get_time(self, k):
+        v = self.data.get(k)
+        return None if v is None else datetime.fromisoformat(v)
+
+
+class _Pub:
+    enabled = False
+
+    def publish(self, _v):
+        pass
+
+    def close(self):
+        pass
+
+
+class _Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def number(self, _e, invert=False):
+        return None
+
+    async def state(self, _e):
+        return None
+
+    async def set_number(self, _e, _v):
+        return True
+
+    async def call(self, *_a):
+        return True
+
+    async def states(self):
+        return []
+
+
+BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+        "meter_source": "off", "max_w": 5000, "shadow_mode": "off",
+        "maintenance_enabled": False, "arbitrage_enabled": True,
+        "cycle_cost_threshold_eur": 0.10,
+        "inverters": [
+            {"name": "inverter-a", "setpoint_entity": "number.a",
+             "soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
+             "max_w": 2500, "capacity_kwh": 2.0},
+            {"name": "inverter-b", "setpoint_entity": "number.b",
+             "soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
+             "max_w": 2500, "capacity_kwh": 2.0}]}
+
+# Tuesday 27 October 2026 in Brussels (UTC+1 since 25 October).
+DAY0 = datetime(2026, 10, 26, 23, 0, tzinfo=UTC)
+
+
+def at(h, m=0, s=0):
+    return DAY0 + timedelta(hours=h, minutes=m, seconds=s)
+
+
+def quarters(price_of, days=2, product=PriceProduct.DAY_AHEAD):
+    """48 hours of 15-minute prices; `price_of(local_hour_float)` -> EUR/kWh."""
+    pts = []
+    for i in range(96 * days):
+        t = DAY0 + timedelta(minutes=15 * i)
+        pts.append(PricePoint(brussels(t), price_of((i % 96) / 4.0), False))
+    return TariffPlan(PriceRead.series(tuple(pts), product,
+                                       "generic_dayahead", DAY0), None,
+                      "provider")
+
+
+def make(opts, plan, now, *, modes=None, soc=(50.0, 50.0)):
+    c = Controller(dict(opts), _Hass(), _Store(), _Pub(), stop=asyncio.Event())
+    c.auto = True
+    for i, inv in enumerate(c.inverters):
+        inv.soc, inv.batt, inv.last_write = soc[i], 0.0, 0.0
+        inv.dev_min, inv.dev_max = -5000.0, 5000.0
+    c.grid = 500.0
+    c.tariff_plan, c.tariff_at = plan, now
+    c.peak_guard = PeakDecision(engaged=False, floor_w=None, ceiling_w=3500.0,
+                                ceiling_from="cap", projected_w=800.0)
+    c.arb_headroom_w = 3000.0
+    if modes:
+        for inv in c.inverters:
+            c.store.data[unit_key(inv.name, packmode.MODE_KEY)] = modes
+    return c
+
+
+def build(c, now):
+    return homeview.build(c, level="ok", checks=[], now=now)["plan"]
+
+
+def kinds_at(plan_json, label):
+    return [b["kind"] for b in plan_json["prices"] if b["label"] == label]
+
+
+def grid_blocks(plan_json):
+    return [r for r in plan_json["runs"] if r["kind"] == "grid"]
+
+
+# --------------------------------------------------------------------------- #
+print("1. modes on: the gate refuses inside a cheap run (F-1)")
+# All-in prices: 0.10 everywhere, 20:00 0.01, 20:15 0.09, 21:00-22:00 0.22. The
+# cheap run is 20:00-20:30. At 20:00 the spread is 0.21. From 20:15 the quarters
+# ahead are 0.09 to 0.22: 0.13 does not clear the 0.15 this cycle needs (0.10
+# widened by 1.5 for the missing weather forecast).
+def f1_price(h):
+    if h == 20.0:
+        return 0.01
+    if h == 20.25:
+        return 0.09
+    if 21.0 <= h < 22.0:
+        return 0.22
+    return 0.10
+
+
+F1_PLAN = quarters(f1_price, days=1)
+c1 = make(dict(BASE, battery_modes_enabled=True), F1_PLAN, at(19, 0, 5),
+          modes=packmode.CHEAP_HOURS)
+
+
+def f1(now):
+    """One real control tick of `_mode_roles()` at `now`, then Home."""
+    c1.tariff_at = now
+    tick = c1._mode_roles(now, None)
+    return tick, build(c1, now)
+
+
+t_pre, p_pre = f1(at(19, 0, 5))        # builds the run plan
+t_open, p_open = f1(at(20, 0, 5))
+print(f"    20:00:05 roles {t_open.roles}, action {t_open.action}, "
+      f"gate {c1.mode_gate}, runs {c1.mode_runs.cheap}")
+check("gate open (20:00): the control cycle charges, mode_gate is None, and "
+      "Home draws the charge on both batteries, 20:00 to 20:30",
+      t_open.action == modetrade.CHARGE and c1.mode_gate is None
+      and {r["battery"] for r in grid_blocks(p_open)} == {0, 1}
+      and all(r["from"] == "20:00" and r["to"] == "20:30"
+              for r in grid_blocks(p_open)))
+check("...and marks the run's two quarters cheap on the chart",
+      kinds_at(p_open, "20:00") == ["cheap"]
+      and kinds_at(p_open, "20:15") == ["cheap"])
+t_mid, p_mid = f1(at(20, 7, 30))
+check("gate still open at 20:07: the charge goes on and is still drawn",
+      t_mid.action == modetrade.CHARGE and c1.mode_gate is None
+      and len(grid_blocks(p_mid)) == 2)
+c1.inverters[0].soc = c1.inverters[1].soc = 52.0
+t_ref, p_ref = f1(at(20, 17, 52))
+print(f"    20:17:52 roles {t_ref.roles}, action {t_ref.action}, why "
+      f"{t_ref.why}, gate {c1.mode_gate}, run {c1.mode_runs.cheap}")
+check("the run is still kept (20:00-20:30) and the gate refuses with "
+      "not_worth at 20:17: no charge, why not_worth",
+      c1.mode_runs.cheap.holds(at(20, 17, 52)) and c1.mode_gate == "not_worth"
+      and t_ref.action is None and t_ref.why == "not_worth"
+      and all(r != modetrade.CHARGE for r in t_ref.roles.values()))
+check("Home draws no charge block for the refused part, on any battery",
+      grid_blocks(p_ref) == [] and not any(
+          r["what"].startswith("Charges") for r in p_ref["runs"]))
+check("...marks no quarter from 20:15 cheap, keeps the 20:00 quarter it "
+      "did charge in, and keeps the give run marked dear",
+      kinds_at(p_ref, "20:00") == ["cheap"]
+      and kinds_at(p_ref, "20:15") == ["mid"]
+      and kinds_at(p_ref, "20:30") == ["mid"]
+      and kinds_at(p_ref, "21:00") == ["dear"])
+saved = c1.mode_gate
+c1.mode_gate = None                     # what Home did before UX-53
+p_old = build(c1, at(20, 17, 52))
+c1.mode_gate = saved
+check("the same moment without the gate record draws the charge again (the "
+      "defect, shown): so the fixture is the F-1 case",
+      len(grid_blocks(p_old)) == 2 and kinds_at(p_old, "20:15") == ["cheap"])
+row = homeview.battery_rows(c1, False, True)[0]
+check("the battery card says what Home now says: it rests (role hold), and "
+      "does not say it charges",
+      t_ref.roles["inverter-a"] == modetrade.HOLD
+      and row["why_key"] in ("saves", "saves_later"))
+t_n, p_n = f1(at(20, 31, 0))
+check("after the run: nothing is drawn, as before",
+      grid_blocks(p_n) == [] and c1.mode_gate == "not_worth")
+
+# Other refusals of the gate are followed the same way: no charge is drawn
+# while the control cycle's gate says no.
+c1b = make(dict(BASE, battery_modes_enabled=True), F1_PLAN, at(20, 0, 5),
+           modes=packmode.CHEAP_HOURS)
+c1b.tariff_at = at(20, 0, 5)
+c1b.peak_guard = PeakDecision(engaged=True, floor_w=1000.0, ceiling_w=3500.0,
+                              ceiling_from="cap", projected_w=3600.0)
+tb = c1b._mode_roles(at(20, 0, 5), None)
+check("the peak guard holding refuses the charge (gate 'peak'): the cycle "
+      "does not charge and Home draws no charge",
+      c1b.mode_gate == "peak" and tb.action is None
+      and grid_blocks(build(c1b, at(20, 0, 5))) == [])
+c1c = make(dict(BASE, battery_modes_enabled=True), F1_PLAN, at(20, 0, 5),
+           modes=packmode.CHEAP_HOURS)
+c1c.peak_guard = None
+tc = c1c._mode_roles(at(20, 0, 5), None)
+check("a peak guard that measures nothing refuses it too (gate "
+      "'not_covered'): no charge, none drawn",
+      c1c.mode_gate == "not_covered" and tc.action is None
+      and grid_blocks(build(c1c, at(20, 0, 5))) == [])
+c1d = make(dict(BASE, battery_modes_enabled=True), F1_PLAN, at(20, 0, 5),
+           modes=packmode.CHEAP_HOURS)
+c1d.arb_headroom_w = None
+td = c1d._mode_roles(at(20, 0, 5), None)
+check("a refusal that is not the gate (no measured headroom yet) is not the "
+      "gate's: mode_gate stays None and the charge is still drawn",
+      c1d.mode_gate is None and td.why == "headroom"
+      and len(grid_blocks(build(c1d, at(20, 0, 5)))) == 2)
+
+# --------------------------------------------------------------------------- #
+print("\n2. modes off: a charge after the last dear period (F-2)")
+NO_WEATHER = frozenset({Uncertainty.NO_WEATHER})
+
+
+def decide_at(c, now, soc=50.0):
+    """What the control cycle does at `now` on the plan (modes off)."""
+    return arbitrage.decide(
+        c.tariff_plan, now, peak_guard_active=False, charge_headroom_w=5000.0,
+        soc=soc, min_spread_eur_kwh=arbitrage.threshold_eur_kwh(c.o),
+        uncertainty=NO_WEATHER, charge_w=2500.0, discharge_w=2500.0,
+        soc_floor_pct=10.0, soc_ceiling_pct=90.0)
+
+
+OFF = dict(BASE)
+
+
+def f2_price(h):
+    return 0.54 if 21.5 <= h < 21.75 else 0.24
+
+
+F2_PLAN = quarters(f2_price, days=1)
+c2 = make(OFF, F2_PLAN, at(21, 36, 0))
+p2 = build(c2, at(21, 36, 0))
+g2 = [r for r in p2["runs"] if r["kind"] == "give"]
+v2, _w = homeview.trade_verdict(c2, F2_PLAN, at(21, 36, 0))
+print(f"    21:36 verdict: cheapest {homeview.hhmm(v2.cheapest.start)}, "
+      f"dearest {homeview.hhmm(v2.dearest.start)}")
+check("the fixture: at 21:36 the verdict's cheapest quarter (21:45) comes "
+      "after its dearest (21:30, in progress), and the rest of the day is flat",
+      homeview.hhmm(v2.cheapest.start) == "21:45"
+      and homeview.hhmm(v2.dearest.start) == "21:30")
+check("the add-on sells in 21:30, and at 21:45 it does nothing: idle, the "
+      "tariff is flat",
+      decide_at(c2, at(21, 30, 5)).action == arbitrage.DISCHARGE
+      and decide_at(c2, at(21, 45, 5)).action is None
+      and "the tariff is flat" in decide_at(c2, at(21, 45, 5)).reason)
+check("Home draws the sale in progress and NO charge at 21:45",
+      len(g2) == 2 and all(r["from"] == "21:30" for r in g2)
+      and grid_blocks(p2) == [])
+check("...and marks 21:30 dear and 21:45 not cheap",
+      kinds_at(p2, "21:30") == ["dear"] and kinds_at(p2, "21:45") == ["mid"])
+real = homeview.leg_taken
+homeview.leg_taken = lambda *a, **k: True        # Home before UX-53
+p2_old = build(c2, at(21, 36, 0))
+homeview.leg_taken = real
+check("without the question to the gate the page draws the 21:45 charge "
+      "(the defect, shown): so the fixture is the F-2 case",
+      [r["from"] for r in grid_blocks(p2_old)] == ["21:45", "21:45"]
+      and kinds_at(p2_old, "21:45") == ["cheap"])
+
+# A charge the gate allows at its own start is still drawn, with the sale.
+def q_price(h):
+    return {20.0: 0.10, 20.5: 0.12, 21.0: 0.59, 21.5: 0.54}.get(h, 0.24)
+
+
+Q_PLAN = quarters(q_price, days=1)
+c3 = make(OFF, Q_PLAN, at(20, 20, 0))
+p3 = build(c3, at(20, 20, 0))
+v3, _w = homeview.trade_verdict(c3, Q_PLAN, at(20, 20, 0))
+check("gate allows (20:20, charge 20:30, sale 21:00): both are drawn, and "
+      "the add-on does charge at 20:30 and sell at 21:00",
+      [r["from"] for r in grid_blocks(p3)] == ["20:30", "20:30"]
+      and [r["from"] for r in p3["runs"] if r["kind"] == "give"] == ["21:00"] * 2
+      and decide_at(c3, at(20, 30, 5)).action == arbitrage.CHARGE
+      and decide_at(c3, at(21, 0, 5)).action == arbitrage.DISCHARGE
+      and kinds_at(p3, "20:30") == ["cheap"] and kinds_at(p3, "21:00") == ["dear"])
+check("...and the charge in progress at 20:30 is drawn too",
+      len(grid_blocks(build(c3, at(20, 35, 0)))) == 2)
+
+# Every probe on a day-ahead day: the charge is drawn exactly where the add-on
+# will take it. "Takes it" is the control cycle's own `decide()` at the start
+# of the charge's period, on the same plan.
+def sweep(plan, opts, lo, hi, step=15):
+    rows = []
+    for m in range(lo, hi, step):
+        now = at(0, 0, 0) + timedelta(minutes=m, seconds=7)
+        c = make(opts, plan, now)
+        v, _w = homeview.trade_verdict(c, plan, now)
+        if v is None:
+            rows.append((now, None, None, None))
+            continue
+        legs = homeview.trade_legs(c, plan, v, now)
+        drawn = {k: homeview.hhmm(pt.start) for k, pt in legs}
+        rows.append((now, v, drawn, [k for k, _pt in legs]))
+    return rows
+
+
+def takes(c, plan, kind, pt, now):
+    """True when decide() acts in that leg's first moment (or now, when it
+    is already under way)."""
+    t = max(now, pt.start + timedelta(seconds=5))
+    d = decide_at(c, t)
+    return d.action == (arbitrage.CHARGE if kind == "grid"
+                        else arbitrage.DISCHARGE)
+
+
+bad, nlegs, nsuppressed = [], 0, 0
+for now, v, drawn, kinds in sweep(F2_PLAN, OFF, 0, 24 * 60):
+    if v is None:
+        continue
+    c = make(OFF, F2_PLAN, now)
+    for kind, pt in (("grid", v.cheapest), ("give", v.dearest)):
+        nlegs += 1
+        shown = kind in kinds
+        if not shown:
+            nsuppressed += 1
+        if shown != takes(c, F2_PLAN, kind, pt, now):
+            bad.append((homeview.hhmm(now), kind, shown))
+print(f"    {nlegs} verdict legs over a day, {nsuppressed} not drawn, "
+      f"{len(bad)} where Home and decide() disagree {bad[:3]}")
+check("over a whole day of 15-minute probes, a leg is drawn exactly when "
+      "decide() acts on it at its start; and some are not drawn",
+      not bad and nsuppressed > 0)
+
+# The same, on 40 random days of 15-minute prices (rounded to a cent, so there
+# are ties), today only, every quarter probed: Home and decide() agree on every
+# leg, and the page does drop some.
+import random                                                     # noqa: E402
+rnd = random.Random(53)
+n_leg = n_drop = 0
+disagree = []
+for day in range(40):
+    shape = [round(rnd.choice((0.10, 0.18, 0.24, 0.24, 0.30, 0.45, 0.60))
+                   + rnd.randrange(0, 3) * 0.01, 2) for _ in range(96)]
+    if day % 2:
+        shape = [shape[i // 4 * 4] for i in range(96)]      # hour-constant
+    plan = quarters(lambda h, sh=shape: sh[int(h * 4)], days=1)
+    c = make(OFF, plan, at(0, 0, 0))
+    for q in range(96):
+        now = at(0, 0, 0) + timedelta(minutes=15 * q, seconds=7)
+        v, _w = homeview.trade_verdict(c, plan, now)
+        if v is None:
+            continue
+        kinds = [k for k, _pt in homeview.trade_legs(c, plan, v, now)]
+        for kind, pt in (("grid", v.cheapest), ("give", v.dearest)):
+            n_leg += 1
+            shown = kind in kinds
+            n_drop += not shown
+            if shown != takes(c, plan, kind, pt, now):
+                disagree.append((day, homeview.hhmm(now), kind, shown))
+print(f"    40 random days: {n_leg} verdict legs, {n_drop} not drawn, "
+      f"{len(disagree)} disagreements with decide() {disagree[:3]}")
+check("40 random 15-minute days, every quarter: a leg is drawn exactly "
+      "when decide() acts on it at its start",
+      not disagree and n_leg > 3000 and n_drop > 0)
+
+# A charge tomorrow: announced only when the add-on will take it. Today's
+# dear period is 21:00 (0.50, then 0.30). Tomorrow opens with a dear hour
+# (0.45) and the cheapest quarter comes right after it, at 01:00 (0.24).
+def two_days(tomorrow):
+    pts = []
+    for i in range(96 * 2):
+        t = DAY0 + timedelta(minutes=15 * i)
+        h = (i % 96) / 4.0
+        price = (0.50 if h == 21.0 else 0.30) if i < 96 else tomorrow(h)
+        pts.append(PricePoint(brussels(t), price, False))
+    return TariffPlan(PriceRead.series(tuple(pts), PriceProduct.DAY_AHEAD,
+                                       "generic_dayahead", DAY0), None,
+                      "provider")
+
+
+def tomorrow_lines(plan, now):
+    c = make(OFF, plan, now)
+    return [x for x in build(c, now)["lines"] if x.startswith("Tomorrow")]
+
+
+T_FLAT = two_days(lambda h: 0.45 if h < 1.0 else 0.24)
+T_WITH = two_days(lambda h: 0.45 if h < 1.0 else (0.50 if h == 18.0 else 0.24))
+l_with = tomorrow_lines(T_WITH, at(21, 5, 0))
+l_flat = tomorrow_lines(T_FLAT, at(21, 5, 0))
+print(f"    tomorrow lines: with a later dear period {l_with}; without {l_flat}")
+check("tomorrow's charge (01:00) is announced when a dearer period follows "
+      "it, and not when the rest of tomorrow is flat",
+      len(l_with) == 1 and "01:00" in l_with[0] and l_flat == [])
+check("...and the add-on charges at 01:00 on the first and does not on the "
+      "second",
+      decide_at(make(OFF, T_WITH, at(21, 5, 0)),
+                at(25, 0, 5)).action == arbitrage.CHARGE
+      and decide_at(make(OFF, T_FLAT, at(21, 5, 0)),
+                    at(25, 0, 5)).action is None)
+
+# --------------------------------------------------------------------------- #
+print("\n3. wording, English and Dutch")
+c6 = make(OFF, Q_PLAN, at(20, 20, 0))
+en = homeview.build(c6, level="ok", checks=[], now=at(20, 20, 0),
+                    lang="en")["plan"]
+nl = homeview.build(c6, level="ok", checks=[], now=at(20, 20, 0),
+                    lang="nl")["plan"]
+gw_en = [r["why"] for r in en["runs"] if r["kind"] == "grid"]
+gw_nl = [r["why"] for r in nl["runs"] if r["kind"] == "grid"]
+dw_en = [r["why"] for r in en["runs"] if r["kind"] == "give"]
+dw_nl = [r["why"] for r in nl["runs"] if r["kind"] == "give"]
+print(f"    {gw_en[:1]} {gw_nl[:1]} {dw_en[:1]} {dw_nl[:1]}")
+check("the charge says 'lowest price left', English and Dutch",
+      gw_en and set(gw_en) == {"Lowest price left, \u20ac0.12 per kWh."}
+      and set(gw_nl) == {"Laagste prijs die nog over is, \u20ac0,12 per kWh."})
+check("...and the sale 'highest price left'",
+      set(dw_en) == {"Highest price left, \u20ac0.59 per kWh."}
+      and set(dw_nl) == {"Hoogste prijs die nog over is, \u20ac0,59 per kWh."})
+check("...and no 'published' is left in the run words of either language",
+      all("ublished" not in str(homeview.uitext.words(l)["home_words"]["run"])
+          and "gepubliceerd" not in str(
+              homeview.uitext.words(l)["home_words"]["run"])
+          for l in ("en", "nl")))
+check("the short words fit the plan-line rule: one sentence of at most 12 "
+      "words",
+      all(len(x.split()) <= 12 for x in gw_en + gw_nl + dw_en + dw_nl))
+
+NOW6 = at(21, 45, 5)
+FLAT_DYN = quarters(lambda h: 0.24, days=1)
+r_dyn = FLAT_DYN.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.10,
+                           uncertainty=NO_WEATHER, now=NOW6).match(
+    allowed=lambda v: None, refused=lambda v: v.reason)
+FIXED = {"periods": [{"name": "all", "from": "00:00", "to": "24:00",
+                      "days": "all", "eur_per_kwh": 0.30}]}
+FIXED_PLAN = static_plan({"static_profile": json.dumps(FIXED)}, at(0), at(36),
+                         now=at(0))
+r_fix = FIXED_PLAN.arbitrage(peak_guard_active=False,
+                             min_spread_eur_kwh=0.10, uncertainty=NO_WEATHER,
+                             now=NOW6).match(allowed=lambda v: None,
+                                             refused=lambda v: v.reason)
+DN = {"periods": [{"name": "day", "from": "07:00", "to": "22:00",
+                   "days": "all", "eur_per_kwh": 0.34},
+                  {"name": "night", "from": "22:00", "to": "07:00",
+                   "days": "all", "eur_per_kwh": 0.26}]}
+DN_FLAT = static_plan({"static_profile": json.dumps(DN)}, at(23, 0), at(30),
+                      now=at(23, 0))        # 23:00 to 06:00: night only
+r_dn = DN_FLAT.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.10,
+                         uncertainty=NO_WEATHER, now=at(23, 10)).match(
+    allowed=lambda v: None, refused=lambda v: v.reason)
+print(f"    dynamic: {r_dyn}\n    day/night: {r_dn}\n    fixed: {r_fix}")
+check("a dynamic site whose remaining quarters are equal is refused as flat, "
+      "and is not called a fully fixed product",
+      r_dyn and r_dyn.startswith("the tariff is flat - every one of the ")
+      and "fully fixed" not in r_dyn and "fixed product" not in r_dyn
+      and r_dyn.endswith("arithmetically impossible"))
+check("...a day/night site whose remaining hours are all night: the same",
+      r_dn and r_dn.startswith("the tariff is flat")
+      and "fixed" not in r_dn)
+check("...a site with a real fixed product is still told so",
+      r_fix and r_fix.endswith(
+          "§9.2: a fully fixed product is self-consumption only")
+      and FIXED_PLAN.product is PriceProduct.FIXED
+      and DN_FLAT.product is PriceProduct.STATIC
+      and FLAT_DYN.product is PriceProduct.DAY_AHEAD)
+
+# --------------------------------------------------------------------------- #
+print("\n4. day/night, hourly and price-off pages")
+def old_vs_new(plan, opts, hours=24):
+    """Verdict legs the page drew before (both, when there is a verdict) and
+    the ones it draws now, probed every 30 minutes."""
+    same = diff = none = 0
+    for m in range(0, hours * 60, 30):
+        now = at(0) + timedelta(minutes=m, seconds=7)
+        c = make(opts, plan, now)
+        v, _w = homeview.trade_verdict(c, plan, now)
+        if v is None:
+            none += 1
+            continue
+        if len(homeview.trade_legs(c, plan, v, now)) == 2:
+            same += 1
+        else:
+            diff += 1
+    return same, diff, none
+
+
+DN_OPTS = dict(OFF, cycle_cost_threshold_eur=0.02,
+               static_profile=json.dumps(DN))
+DN_48 = static_plan(DN_OPTS, at(0), at(48), now=at(0))
+s_dn = old_vs_new(DN_48, DN_OPTS)
+print(f"    day/night, 48 h plan, 48 probes: same {s_dn[0]}, changed "
+      f"{s_dn[1]}, no verdict {s_dn[2]}")
+check("day/night (a 48-hour plan, as the refresh builds it): at every probe "
+      "that has a verdict both legs are drawn, as before; and there are some",
+      s_dn[1] == 0 and s_dn[0] >= 20)
+HOURLY = quarters(lambda h: [.24, .22, .21, .20, .21, .22, .24, .27, .26, .22,
+                             .18, .16, .15, .14, .16, .19, .23, .28, .33, .36,
+                             .34, .29, .26, .24][int(h)], days=2)
+HR_OPTS = dict(OFF, cycle_cost_threshold_eur=0.05)
+s_hr = old_vs_new(HOURLY, HR_OPTS)
+print(f"    hourly shape on a 48 h plan: same {s_hr[0]}, changed {s_hr[1]}, "
+      f"no verdict {s_hr[2]}")
+check("an hourly-shaped day-ahead feed with tomorrow known: both legs are "
+      "drawn at every probe with a verdict, as before",
+      s_hr[1] == 0 and s_hr[0] >= 20)
+s_one = old_vs_new(quarters(lambda h: [.24, .22, .21, .20, .21, .22, .24, .27,
+                                       .26, .22, .18, .16, .15, .14, .16, .19,
+                                       .23, .28, .33, .36, .34, .29, .26,
+                                       .24][int(h)], days=1), HR_OPTS)
+print(f"    the same with today only: same {s_one[0]}, changed {s_one[1]}, "
+      f"no verdict {s_one[2]}")
+check("...and with today only, the probes that change are the ones where "
+      "the cheapest quarter left is after the last dear one (F-2)",
+      s_one[1] > 0 and s_one[0] > 0)
+c7 = make(dict(OFF, arbitrage_enabled=False), DN_48, at(12, 0, 0))
+p7 = build(c7, at(12, 0, 0))
+check("price trading off (a day/night site, modes off): no charge or sale "
+      "is drawn and no bar is marked, as before",
+      [r for r in p7["runs"] if r["kind"] in ("grid", "give")] == []
+      and {b["kind"] for b in p7["prices"]} == {"mid"})
+c8 = make(dict(OFF, arbitrage_enabled=False, battery_modes_enabled=True),
+          DN_48, at(12, 0, 0), modes=packmode.SOLAR_FIRST)
+c8._mode_roles(at(12, 0, 0), None)
+p8 = build(c8, at(12, 0, 0))
+check("modes on, every battery Solar first (the owner's setting): no grid "
+      "charge is drawn, and the gate record changes nothing",
+      grid_blocks(p8) == [] and {b["kind"] for b in p8["prices"]} == {"mid"})
+c9 = make(dict(OFF, battery_modes_enabled=True), DN_48, at(12, 0, 0),
+          modes=packmode.SOLAR_FIRST)
+check("a controller that never ran a cycle has no gate record, and the "
+      "default is 'no refusal' (None)",
+      getattr(c9, "mode_gate", "missing") is None)
+
+print(f"fails: {len(fails)}")
+sys.exit(1 if fails else 0)