Merge PR #206 : PRICE-02 the price verdict skips ended periods

PRICE-02 review: keep an open buy over midnight in the real-year replay; say which variant the kWh figure is
The production-shaped plan sees tomorrow from 13:00, so most buys are sold the next day or later. The ledger forgot the open buy at each midnight and booked 46 of 51 sales as holdings: 5 trips, +1.21 EUR. Carried over, the same decisions give 51 trips, +13.81 EUR, all clearing the threshold. Decisions are unchanged and identical on the old and new verdict. No assertion changed. DECISIONS: 27.5 -> 42.6 kWh is the refresh-:00, tomorrow-known variant; give the range of the other three. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Bdqr7PiaHcBnzPituu2yTC
2026-10-22 18:57:37 +02:00 · 2026-10-22 16:48:43 +02:00 · 2026-10-22 14:59:13 +02:00 · 2026-10-22 10:37:43 +02:00 · 2026-10-22 08:37:39 +02:00 · 2026-10-22 08:20:50 +02:00
49 changed files with 4136 additions and 416 deletions
@@ -4,9 +4,9 @@ The guide technicians carry is the PDF:

 **`docs/GoodWe-RS485-Field-Guide.pdf`** — 10 pages, A4, print it double-sided.

-⚠️ **Outdated: it is v0.1.0.** Its `slew_w` row is corrected in `build_guide.py`
-and `field-guide.html`, but the PDF has not been rebuilt (see below). Where the
-guide disagrees with `goodwe_controller/DOCS.md`, DOCS.md wins.
+⚠️ **Outdated: the content is still v0.1.0.** The PDF was rebuilt on 2026-10-17
+for the EMS-port wording and the `slew_w` row only. Where the guide disagrees with
+`goodwe_controller/DOCS.md`, DOCS.md wins.

 It covers, in the order the work is done: pre-visit checks, hardware, firmware,
 add-on install and configuration, how to read the Web UI, the six commissioning
@@ -156,7 +156,7 @@ that looks hung gets deleted.
 **A GoodWe "-20" / G2 inverter cannot be driven by this.**

 Platform comes from characters 6–8 of the serial number. Only
-`ESU EMU ESA BPS BPU EMJ IJL` — platform 105, the AA55-era meter bus — are
+`ESU EMU ESA BPS BPU EMJ IJL` — platform 105, the AA55-era generation — are
 supported. SBP G2 (`SPB`/`SPN`) and ES G2 (`ESN`/`ESC`) are platform 745, a
 different protocol. The reference unit is `BPS`.

@@ -1,8 +1,8 @@
 # GoodWe RS485 Controller — Home Assistant add-on repository

 Replaces a GoodWe battery inverter's vendor controller with a local one: holds
-net grid exchange at zero by emulating the inverter's smart meter over RS485,
-and runs the monthly battery maintenance cycle the vendor box was doing.
+net grid exchange at zero by sending the inverter a grid reading over its RS485
+EMS port, and runs the monthly battery maintenance cycle the vendor box was doing.

 ```
 repository.yaml            add-on repository metadata
@@ -30,7 +30,7 @@ goodwe_controller/         the add-on
                           returns, run against its own release image
 firmware/goodwe-master.yaml  ESPHome config for the T-CAN485
 estop/rs485_log.py           optional RS485 e-stop / bus witness
-docs/GoodWe-RS485-Field-Guide.pdf  the guide techs carry (10pp, A4; outdated)
+docs/GoodWe-RS485-Field-Guide.pdf  the guide techs carry (10pp, A4; rebuilt 2026-10-17, content still v0.1.0 and outdated)
 docs/build_guide.py          its single source - rebuilds the HTML and PDF
 FIELD-GUIDE.md             how to edit and rebuild the guide
 docs/RELEASE.md            how a change reaches the battery - `master` is
@@ -118,17 +118,17 @@ the platform tag:

 | tag | platform | verdict |
 |---|---|---|
-| `ESU EMU ESA BPS BPU EMJ IJL` | 105 — ES/EM/BP, AA55-era meter bus | **supported** |
+| `ESU EMU ESA BPS BPU EMJ IJL` | 105 — ES/EM/BP, AA55-era | **supported** |
 | `SPB SPN` | 745 — SBP **G2** (`GW…-SBP-20`) | no |
 | `ESN ESC` | 745 — ES **G2** (`GW…-ES-20`) | no |
 | `ETU EHU BTU …` | 205/745/753 — ET/EH/BT hybrids | no |
 | `SDT DST MSU NSU …` | PV-only inverters — no battery to control | no |

-A "-20" or "G2" suffix means a different platform with a different meter
+A "-20" or "G2" suffix means a different platform with a different
 protocol. The tags come from the `goodwe` library's `PLATFORM_105_MODELS`, which
 is also what Home Assistant's own integration uses to pick a protocol.

- GoodWe **ES / BP family** inverters (AA55 / RS485 meter-bus generation)
+- GoodWe **ES / BP family** inverters (AA55 generation)
 - The protocol is **reverse-engineered**. There is no vendor contract, and a
  firmware change on GoodWe's side could break every installation at once. Say
  so when you sell it.
@@ -154,7 +154,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
    <table style="margin-bottom:2mm">
      <tr><th style="width:34mm">Tag</th><th>Platform</th><th style="width:30mm">Verdict</th></tr>
      <tr><td><code>ESU EMU ESA BPS<br>BPU EMJ IJL</code></td>
-          <td><b>Platform 105</b> — ES / EM / BP, AA55-era meter bus</td>
+          <td><b>Platform 105</b> — ES / EM / BP, AA55-era</td>
          <td><b>SUPPORTED</b></td></tr>
      <tr><td><code>SPB SPN</code></td><td>SBP <b>G2</b> (GW…-SBP-20) — platform 745</td><td><b>NO</b></td></tr>
      <tr><td><code>ESN ESC</code></td><td>ES <b>G2</b> (GW…-ES-20) — platform 745</td><td><b>NO</b></td></tr>
@@ -162,7 +162,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
      <tr><td><code>SDT DST MSU NSU …</code></td><td>PV-only inverters — <b>no battery to control</b></td><td><b>NO</b></td></tr>
    </table>
    <p style="margin:0"><small>Reference unit: <code>95000BPS225W0290</code> → <code>BPS</code> → supported.
-    A “-20” or “G2” suffix in the model name means a different platform with a different meter
+    A “-20” or “G2” suffix in the model name means a different platform with a different
    protocol. <b>If the tag is not on the supported list, stop — do not quote the job.</b></small></p>
  </div>

@@ -208,13 +208,13 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
 <!-- ============ PAGE 3 ============ -->
 <div class="page" id="p3">
  <h2>Steps 1–3 — Hardware</h2>
-  <div class="warn"><b>Qualified persons only.</b> Mains AC and battery DC are present. The meter bus
+  <div class="warn"><b>Qualified persons only.</b> Mains AC and battery DC are present. The RS485 EMS port
  is low-voltage but sits inside an energised installation.</div>

  <div class="step">
    <h3><span class="num">1</span> Survey and record</h3>
    <ol class="do">
-      <li><b>Photograph</b> the meter-port wiring before touching it.</li>
+      <li><b>Photograph</b> the EMS-port wiring before touching it.</li>
      <li>Identify the RS485 pair (A/B) running to the vendor controller.</li>
      <li>Record inverter model + serial, battery capacity (Ah) and nominal voltage.</li>
    </ol>
@@ -226,7 +226,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
    <ol class="do">
      <li>Bring the system to <b>0 W</b> — battery neither charging nor discharging (check the
          inverter display).</li>
-      <li>Disconnect the vendor controller from the meter port.</li>
+      <li>Disconnect the vendor controller from the inverter's EMS port.</li>
      <li>Leave it physically mounted but unplugged — that keeps the install reversible and gives
          you a rollback story.</li>
    </ol>
@@ -237,7 +237,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
  <div class="step">
    <h3><span class="num">3</span> Fit and power the T-CAN485</h3>
    <ol class="do">
-      <li>Wire <b>A→A, B→B</b> to the meter port, plus its own supply.</li>
+      <li>Wire <b>A→A, B→B</b> to the EMS port, plus its own supply.</li>
      <li>If fitting the e-stop, connect its USB-RS485 adapter to the <b>same pair, in parallel</b>.</li>
      <li>Power the T-CAN485 <b>last</b>.</li>
    </ol>
@@ -119,7 +119,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
    <table style="margin-bottom:2mm">
      <tr><th style="width:34mm">Tag</th><th>Platform</th><th style="width:30mm">Verdict</th></tr>
      <tr><td><code>ESU EMU ESA BPS<br>BPU EMJ IJL</code></td>
-          <td><b>Platform 105</b> — ES / EM / BP, AA55-era meter bus</td>
+          <td><b>Platform 105</b> — ES / EM / BP, AA55-era</td>
          <td><b>SUPPORTED</b></td></tr>
      <tr><td><code>SPB SPN</code></td><td>SBP <b>G2</b> (GW…-SBP-20) — platform 745</td><td><b>NO</b></td></tr>
      <tr><td><code>ESN ESC</code></td><td>ES <b>G2</b> (GW…-ES-20) — platform 745</td><td><b>NO</b></td></tr>
@@ -127,7 +127,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
      <tr><td><code>SDT DST MSU NSU …</code></td><td>PV-only inverters — <b>no battery to control</b></td><td><b>NO</b></td></tr>
    </table>
    <p style="margin:0"><small>Reference unit: <code>95000BPS225W0290</code> → <code>BPS</code> → supported.
-    A “-20” or “G2” suffix in the model name means a different platform with a different meter
+    A “-20” or “G2” suffix in the model name means a different platform with a different
    protocol. <b>If the tag is not on the supported list, stop — do not quote the job.</b></small></p>
  </div>

@@ -173,13 +173,13 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
 <!-- ============ PAGE 3 ============ -->
 <div class="page" id="p3">
  <h2>Steps 1–3 — Hardware</h2>
-  <div class="warn"><b>Qualified persons only.</b> Mains AC and battery DC are present. The meter bus
+  <div class="warn"><b>Qualified persons only.</b> Mains AC and battery DC are present. The RS485 EMS port
  is low-voltage but sits inside an energised installation.</div>

  <div class="step">
    <h3><span class="num">1</span> Survey and record</h3>
    <ol class="do">
-      <li><b>Photograph</b> the meter-port wiring before touching it.</li>
+      <li><b>Photograph</b> the EMS-port wiring before touching it.</li>
      <li>Identify the RS485 pair (A/B) running to the vendor controller.</li>
      <li>Record inverter model + serial, battery capacity (Ah) and nominal voltage.</li>
    </ol>
@@ -191,7 +191,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
    <ol class="do">
      <li>Bring the system to <b>0 W</b> — battery neither charging nor discharging (check the
          inverter display).</li>
-      <li>Disconnect the vendor controller from the meter port.</li>
+      <li>Disconnect the vendor controller from the inverter's EMS port.</li>
      <li>Leave it physically mounted but unplugged — that keeps the install reversible and gives
          you a rollback story.</li>
    </ol>
@@ -202,7 +202,7 @@ figcaption { font-size:9pt; color:#5b6169; margin-top:1.2mm; }
  <div class="step">
    <h3><span class="num">3</span> Fit and power the T-CAN485</h3>
    <ol class="do">
-      <li>Wire <b>A→A, B→B</b> to the meter port, plus its own supply.</li>
+      <li>Wire <b>A→A, B→B</b> to the EMS port, plus its own supply.</li>
      <li>If fitting the e-stop, connect its USB-RS485 adapter to the <b>same pair, in parallel</b>.</li>
      <li>Power the T-CAN485 <b>last</b>.</li>
    </ol>
@@ -1,5 +1,67 @@
 # Changelog

+## 0.18.2
+
+**A patch bump: one fix to how the 15-minute demand forecast sensor is read, 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.18.1 also
+start 0.18.2. Only a forecast sensor with no power unit needs a look (below).
+The change below applies with one inverter or two.
+
+**A forecast sensor with no power unit.** If your 15-minute demand forecast
+sensor has no unit, or a unit that is not power (for example kWh), the add-on
+now ignores that forecast. The log warns once, and the Home and Settings pages
+say so while it lasts. Pick a sensor that reads in W or kW.
+
+Contents of this release, in merge order since 0.18.1 (`780c1f6`):
+
+| | |
+|---|---|
+| `09a5485` | The 15-minute demand forecast sensor is now read in its own unit, W or kW, and the old rule that took any value below 50 as kW is gone. With no unit, or a unit that is not power, the forecast is not used, and the log and the pages say so; the settings page no longer says a kW sensor is taken as watts ([[SAFETY-118]], #198) |
+
+### Known issues
+
+- A false "Battery is not keeping up" can still show when the peak guard pauses a maintenance charge ([[SAFETY-92]]).
+- A battery capped at a low limit with a perfectly flat reading can still trip the stale check ([[SAFETY-74]]).
+- A battery whose reading at rest is beyond about ±175 W is still not caught when it refuses ([[SAFETY-97]]).
+- The peak guard can still back off near the end of a 15-minute period when a meter reading is late, by less than 30 s ([[SAFETY-99]]).
+- Two inverters: the maintenance charge can switch on and off while the house is above the peak aim ([[SAFETY-88]]).
+- Two inverters: the "circulating" figure counts a battery's reading at rest ([[SAFETY-98]]).
+- Two inverters: a drain that starts during a big step in house use can send the other battery to full power, and about 1 kW goes to the grid for about 10 s ([[SAFETY-104]]).
+- Two inverters: when a battery comes back during a maintenance charge, the grid can step by several kW at once ([[SAFETY-101]]).
+- Two inverters: when a battery drops out during a solar surplus, the others can swing by up to 1.5 kW in a simulation ([[SAFETY-105]]).
+- Two inverters: after a drain ends, a change in house use can go unanswered for about 9 s, because some readings are old ([[SAFETY-106]]).
+- Two inverters: when one battery's level is missing, both batteries are held at 0 W, and for about 15 s the last command stays on ([[SAFETY-108]]).
+- Two inverters: if one battery's level stays missing for 12 h, the other battery's cycle can be marked failed, with a 7-day wait and a notice, though it is healthy. This comes from reading the code; it has not been seen on a site ([[MAINT-17]]).
+- When the 15-minute demand forecast sensor counts the battery's own charge, the maintenance charge runs at about half the power the peak limit leaves, so it takes about twice as long. Seen on a site: about 1.2 kW instead of 2.5 kW, and the peak limit was kept ([[SAFETY-111]]).
+- One inverter: after a link drop, the battery's own safety stop to 0 W can be taken as a refusal, and the site stays at 0 W for up to 15 min ([[SAFETY-102]]).
+- After a Home Assistant restart, control still waits until Home Assistant has finished starting, which can take several minutes, though the readings are already there ([[SAFETY-115]]).
+- While Home Assistant is not answering, the page can list inverters as refusing commands and sensors as missing, and send you to Developer Tools, though they are fine ([[UX-37]]).
+- If Home Assistant hangs or stops, the page keeps saying "Waiting for Home Assistant" and never turns into an alarm ([[SAFETY-113]]).
+- Right after Home Assistant has started, the page can say for about 4 s that an inverter cannot be controlled, and the first command can come late ([[SAFETY-114]]).
+- After a Home Assistant restart, the controller status sensor can still say "running" while the add-on cannot control. It was seen once, and the cause is not known ([[SAFETY-116]]).
+- Battery modes on: after a planned top-up from the grid, the Batteries screen can say "Enough sun is forecast" ([[UX-32]]).
+- Battery modes on: the forecast line "we count on" can show more sun than the plan counts, because the plan takes house use off first ([[UX-33]]).
+- Battery modes on: before a planned top-up, the Today list shows a smaller "gives" amount than the plan will use; it grows as the charge happens ([[UX-34]]).
+- Two inverters, battery modes on: while the other battery is in its maintenance charge, a battery's card can say it charges from the grid while it stays at 0 W ([[OPT-18]]).
+- Two inverters, battery modes on: while a battery refuses to charge in a cheap run, the action log on the page gets about 8 lines an hour for its retries, and the page hint says "waiting for a better price" ([[UX-38]]).
+- A battery in a safety stop, or one the add-on cannot reach, can still be started for a cycle, and its drain then waits about 12 h and ends in a failed-cycle notice. This comes from reading the code; it has not been seen on a site ([[MAINT-19]]).
+- On the Settings page, the rows of the solar forecast lists are labelled "Phase 1", "Phase 2" instead of "Sensor 1", "Sensor 2" ([[UX-27]]).
+- In the solar forecast list, a blank or repeated row makes "source 2 of 2" count differently from the rows on the Settings page ([[UX-28]]).
+- The solar forecast message says "has no reading" also when the sensor shows a number that is too old or in the wrong unit ([[UX-29]]).
+- If you use only the forecast lists, two Settings notes sit on the single-sensor field, and one of them tells you to set that field ([[UX-30]]).
+- After a restart during a price outage, the "No prices" message can say "yet" when prices did come in earlier ([[UX-39]]).
+- On the new settings page, you cannot see whether a price service token is set. Check the Configuration tab ([[UX-41]]).
+- On the classic settings page, the first click on Save after editing a field can do nothing. Click again ([[UX-42]]).
+- The price chart on the Home page shows one bar per hour, the average of four 15-minute prices, while the add-on decides on the 15-minute prices ([[UX-45]]).
+
+### 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.18.1

 **A patch bump: two small fixes to the settings page, and no option changes.**
@@ -0,0 +1,89 @@
+# PRICE-02 - the trading verdict skips price periods that have ended
+
+**Status: for review.** Tests: `test_price02.py`. Found by AUDIT-01 (F1).
+
+The refresh floors the plan to the top of the hour, so on the 15-minute feed
+it holds the periods of this hour that are already over. The verdict took the
+cheapest and dearest over every point. With modes off it could aim at a period
+that had passed and then do nothing, for up to 45 min plus the refresh lag.
+With modes on the `allowed()` gate could be open only because of such a period.
+
+Decision: `TariffPlan.arbitrage(now=...)` drops the points whose period has
+ended (`end <= now`, the span `price._cover_table()` gives, as
+`priceruns.firm_slots()` does). Its three callers pass their own `now`:
+`arbitrage.decide()`, `Controller._mode_roles()` and `homeview.trade_verdict()`.
+
+- Taken in the verdict, not when the plan is built: a plan built at 03:00 is
+  still used at 03:20, and the Home chart keeps the day's earlier bars.
+- An hourly point that is still current stays in. But an hourly or static plan
+  is rebuilt every 30 min counted from add-on start, so it is usually off the
+  hour and, until the next refresh, holds the hour that has just ended. That
+  hour is dropped too (round 3, owner-accepted 2026-10-22). On a day/night
+  tariff all day hours tie and the old verdict took the first, the ended one,
+  so it paused the trade every hour until the refresh: 91 on/off changes over
+  2 days with the refresh at :10, 4 now (4 before as well, with the refresh on
+  the hour). With the refresh on the hour nothing changes.
+- `now` is required: keyword-only, no default, like the other three arguments. A
+  caller that could leave it out would get the elapsed periods back and the
+  defect with them. A test that wants the whole series passes an instant before it.
+- The sentences of this verdict in `arbitrage.py` (status row and action log,
+  English only) say "price period" where they said "hour": the idle one now
+  reads "now is not the cheapest or the dearest price period". The UI texts
+  that say "cheapest hour" (AUDIT-01 T1-T5) are not touched here.
+- Not changed here: F2 (static profile sampled at HH:00) and F3 (carried value).
+
+Measured: with price off, every command over the modes-off replay is
+byte-identical. On a static tariff rebuilt on the hour it is too; rebuilt 20
+min off the hour the commands differ (digest 79f06d6381ff3358 on release/1.0,
+18de19d9fe919fe5 here), for the reason above. On the dynamic replay every command is
+the same too; only a sale's sentence quotes a smaller "above the cheapest"
+figure once the first cheap period is over. The identity pins in
+`test_modes_p3.py` and `test_price_run_fixes.py` hide just that figure and the
+word change (`opt11p3_identity.trade_digest()`).
+
+## Ties (round 2)
+
+The verdict takes `min`/`max` over the points still ahead and the first one wins
+a tie, so with equal prices it is the first period still ahead, which is the
+current one. Before, it was the first of the whole plan, often one that had
+ended. Two effects follow, and both are the card's intent, not a side effect:
+
+- Equal quarters (hour-constant data, or a feed that prints the same price in
+  several quarters) now act in every quarter of the cheap (or dear) block,
+  not in the first only. Test: `test_price02.py` part 6.
+- After the cheapest period has passed, the next cheapest still ahead is the
+  target, if its spread still clears the cost. A hourly plan did this at every
+  refresh already (it started at the current hour); a 15-minute plan did it
+  only from the next hour on, because it kept the elapsed quarters of this one.
+
+Measured with `scratch/PRICE-02/dev/tiesim.py` (refresh every 30 min from the
+floored hour, verdict at 7 min into each period, threshold 0.05, old = the
+verdict over the whole plan, new = this card):
+
+| data | days | acting periods old -> new | action changes old -> new |
+|---|---|---|---|
+| real 15-minute day, energy-charts 2026-09-09 | 1 | 4 -> 5 | 6 -> 6 |
+| real 15-minute days 2026-09-09 and -10 | 2 | 14 -> 26 | 24 -> 24 |
+| EPEX 2025-26 hourly prices as four equal quarters | 12 | 18 -> 72 | 36 -> 20 |
+| the same with random +-0.002 noise per quarter (no ties) | 12 | 18 -> 33 | 36 -> 48 |
+
+So a real 15-minute day does not switch more often (24 -> 24), and a day of
+equal quarters switches less. A synthetic day of noisy, tie-free quarters does
+(3.0 -> 4.0 changes a day): each period that passes hands the target to the
+next cheapest one ahead. Every change is still at a period edge, never within
+one. The replay in `test_arbitrage.py` (synthetic year, hourly) gives the same
+ledger on the old and the new code once its ties are broken (280 round trips,
+85 held, both): it printed one maximum twice per day, and the old fixture
+tested the first of them only because its plan began at midnight.
+
+## Battery throughput (round 3)
+
+On real 15-minute days the trade runs longer: about 1.5 to 2.5 times the
+minutes spent charging or discharging, with fewer on/off switches (for example
+78 -> 68, 92 -> 72), over 16 days (2026-09-02 to 09-17, a decision every
+minute, refresh at :00 or :10, tomorrow's prices known always or from 13:00;
+reviewer's sim). Through a modelled 10 kWh battery that is 27.5 -> 42.6 kWh
+(refresh at :00, tomorrow always known); 19.6-31.9 -> 43.4-48.7 kWh in the
+other three variants. Charge to
+discharge reversals are unchanged (10 -> 10, 13 -> 13). More cycling is the
+price of not pausing.
@@ -0,0 +1,18 @@
+# SAFETY-118 - the peak forecast is read in its own unit
+
+**Status: for review.** Tests: `test_safety118.py`.
+
+`peak_forecast_entity` was read as a bare number, and anything under 50 was
+multiplied by 1000 ("accept kW or W"). A W sensor reading 17 to 45 W, which a
+real site did 430 times in one morning, would be taken as 17 to 45 kW. The
+validator also called a kW sensor wrong, which was false for this entity.
+
+Decision: the size rule is gone. The entity is read through `pv.watts()`, the
+same unit table and reader as the solar entities, so W, kW, MW and the rest
+convert by the sensor's own `unit_of_measurement`. No unit, or a unit that is
+not power (kWh), means the forecast is not used, exactly as if the option were
+empty: the loop cap and every non-forecast peak step still apply. One WARNING
+per cause, and a status row and a settings note say the same.
+
+No size rule can be right in both units: 30 W and 30 kW are both ordinary.
+The read is still one `GET /api/states/<id>` per cycle, as `hass.number()` made.
@@ -0,0 +1,99 @@
+# SAFETY-119 - no "not keeping up" when the loop takes the wire back
+
+**Status: merged (bee7431); the settle and the budget changed in SAFETY-121**
+(DECISIONS/SAFETY-121-bound-every-quarter.md: 4 cycles and 22 s, one budget
+of 11). The rolling-budget sections below describe bee7431. Tests:
+`test_safety119.py`.
+
+**Cause.** When another owner (the peak guard, a maintenance charge) has set
+the wire and the loop wins again, `cycle()` re-seeds the integrator from that
+owner's command, and `compute()` adds `gain * error` from a meter that does
+not show that command yet. On the TEST-23 rig (SAFETY-118 I-2) the guard
+stepped from -2000 W to +429 W with 5 s left. A cycle later the loop's ask
+crossed the +2500 W rail and beat the guard's floor, so SAFETY-85 rule 1
+counted it as the loop's own bound and raised `goodwe_integrator_bound`. The
+battery gave what it was told, and the cap held.
+
+**Decision.** After a hand-back, the loop's integrator bound is not counted
+until the plant's settle has passed (`SHORT_CYCLES` cycles and
+`SHORT_SPAN_S`, the window SAFETY-85 grades a battery on). After that it
+counts as before. An over-rating (`clamped`, a bug) on a cycle the loop
+decided always counts. No command changes, and no text was added or changed.
+
+**A rolling budget (round 3).** The settle above is per hand-back, and
+losing the wire restarts it. Across all hand-backs the bound is hidden on at
+most a budget of cycles in any 15 minutes (`ROLLING_BUDGET`, `ROLLING_S`); a
+cycle over the budget counts. Round 1 restarted the settle at every
+hand-back, so a guard and a charge taking turns hid the bound for good (0
+warnings in 2 h where 28 were raised before). Round 2 gave each run of
+hand-backs its own budget; at 10 s and 15 s meters each quarter then started
+a fresh one and the loop's bound was never counted. A quarter-edge kick is a
+few bound cycles in one quarter, a real bound that stays is many: a budget
+per 15 minutes tells them apart.
+
+**The budget follows the cycle length.** 10 cycles up to a 3.5 s cycle, 8 up
+to 11 s, 6 up to 16 s, 4 beyond. The cycle length is the time between two
+decided cycles (a stop, or a gap over two minutes, is not one); until it is
+known, and without a monotonic clock, the budget is 8. Without a monotonic
+clock the budget never refills.
+
+**Why not one number.** Measured over 2 h (`goodwe-addon-checks:1`), the
+quarter-edge case (house 800 W, cap 2500 W, no forecast, 30 seeds) and the
+case below. No single budget held both at 1 to 15 s: 3 to 6 let the false
+alarm back at 2 s; 7 on 10 of 30 seeds at 2 s; 8 on 1 of 30 (seed 25) at
+2 s, and warned in only 1 to 3 of 7 quarters at 15 s; 9 and 10 miss quarters
+at 10 s. A slow cycle needs a small budget to warn, a fast one a large budget
+to stay quiet. Per band, the largest budget that still warns: up to 3.5 s,
+10 (9 and 10 had no false alarm at 1 and 2 s; above 10 was not swept); up to
+11 s, 8 (9 misses quarters at 10 s); up to 16 s, 6 (7 leaves two quiet
+quarters in a row at 15 s, 4 false-alarms at 12 s on 7 of 30 seeds); beyond,
+4 (3 false-alarms at 20 and 30 s on 14 of 30, 5 leaves five quiet quarters at
+20 s).
+
+**What holds.** Quarter-edge case, 30 seeds each: 0 notifications at 1, 2,
+3, 4, 5, 10, 12, 15, 20 and 30 s. Repeated hand-backs (2 x 2500 W,
+cheap-window charge, no usable forecast, cap 5000 W, house 5050 and 5100 W,
+constant and with noise, 8 runs per meter):
+
+| meter | warnings in 2 h | quarters warned (of 7 after the first) | without the fix |
+|---|---|---|---|
+| 1 s | 56 to 63 | 7 | 56 to 63 |
+| 2 s | 49 to 56 | 7 | 54 to 56 |
+| 5 s | 19 to 23 | 7 | 28 |
+| 10 s | 7 to 10 | 7 | 14 |
+| 15 s | 4 to 10 | 4 to 7, never two quiet in a row | 14 |
+| 30 s | 3 to 7 | 3 to 5, up to two quiet in a row | 7 to 11 |
+
+At 30 s no budget does better: 4 leaves two quiet quarters, 3 brings back
+the false alarm. Single hand-back, the loop at its rail, first warning after
+the hand-back compared with no fix: 10 s at 1 s, 20 s at 2 s, 40 s at 5 s
+(default), 80 s at 10 s, 90 s at 15 s, 80 s at 20 s, 120 s at 30 s, 240 s at
+60 s. At 60 s the rig is a different regime (the house is not over the cap
+in the case above), so nothing more is claimed there. The cap held at 1 to
+10 s in the quarter-edge case and at 1 to 5 s in the case above; at slower
+meters the meter's lag puts quarters over it, the same with and without the
+fix (commands are identical).
+
+**Limits.** These runs have one cycle per meter reading, at a steady
+interval. A 20 or 30 s cycle needs `cycle_floor_s` raised; at the default
+15 s, a slower meter adds cycles on an old reading. Measured that way (11
+seeds): a 15 s meter that varies by up to 30 % false-alarmed on 5 seeds, a
+30 s meter on 10 (0 to 4 in 2 h, 8 to 15 without the fix); a 20 s meter on
+none. The case above still warned every quarter there.
+
+**Kept.** The loop in charge at its rail warns on the same cycle as before.
+The start and a restart after a stop are not hand-backs. The quarter-edge
+kick of `test_safety119.py` part 1 stays hidden (see above).
+
+**Re-pinned.** test_safety84 (all six) and test_safety87 (`n1_crossing`,
+`n1_above`, `n1_charge_low`): only OUTPUT_CLAMP log rows differ; commands and
+claims are the same (`test_safety119.py` part 6).
+
+**Not hidden.** A battery that gives less than another owner told it still
+alarms through SAFETY-85 rule 2. "Always counts" for an over-rating holds on
+cycles the loop decided; on others SAFETY-85 rule 1 already dropped it.
+
+**Not changed.** The kick itself is control behaviour: for a few seconds at
+a quarter's edge the loop asks up to its rail. In `test_safety119.py` part 1
+that is more discharge than the guard asked at a quarter's end, and a few
+seconds of up to 500 W more charge at the next quarter's start.
@@ -0,0 +1,95 @@
+# SAFETY-121 - a recurring overload warns every quarter
+
+**Status: for review.** Tests: `test_safety119.py` (parts 2, 4, 5, 6).
+Follows DECISIONS/SAFETY-119-bound-after-hand-back.md.
+
+**The defect (TEST-23, SAFETY-119 rig test F-1).** 5 s meter, 2 x 2500 W,
+cap 5000 W, maintenance charge, no forecast, house 5100 W. bee7431 warned
+once in 70 min (04:31:01), then not at 04:45, 05:00 or 05:15. Base 75f0804
+warned at every quarter start. The loop held the wire once a quarter, at its
+start, and was at its bound on 4 or 5 cycles. SAFETY-119's settle (12
+cycles, 60 s at 5 s) covered all of them, and 5 cycles a quarter fit in its
+budget of 8 per 900 s.
+
+**Why the simulation said "every quarter".** `test_safety119.py` fed the
+meter one cycle behind the battery reading (`delay` counts cycles: 5 s at a
+5 s meter). Just after the loop leaves its rail, the guard's charge
+headroom (house = meter + battery) is then off by up to 5000 W, the charge
+pulls 2000 W, the guard steps in again, and the two chase each other: 8 to
+10 hand-backs and about 20 bound cycles a quarter at 5 s (rig: 1 and 4-5).
+With the meter read in the same cycle (`delay` 0, the rig's shape) the sim
+gives the rig's numbers: 3 to 5 bound cycles a quarter at 5 s, all inside
+SAFETY-119's settle, and bee7431 warns in 0 to 2 of 7 quarters. The test
+now runs both shapes.
+
+**Decision.** After a hand-back the loop's bound is hidden until 4 cycles
+(`HANDBACK_CYCLES`) and 22 s (`SHORT_SPAN_S`) have passed; across all
+hand-backs on at most 11 cycles (`ROLLING_BOUND_CYCLES`) in any 900 s. The
+budget no longer follows the cycle length, and the cycle length is not
+tracked. A stop ends the settle and keeps the budget. An over-rating always
+counts. Commands are unchanged.
+
+**Why it holds for any number of bound cycles a quarter.** The settle is
+fixed: at most 3 cycles or 22 s after a hand-back, whichever is longer. A
+bound that lasts past it counts on its first cycle after it. So one
+hand-back a quarter, with the loop at its rail past the settle, warns in
+that quarter, whether it is 1 bound cycle or 100. A bound that never lasts
+past a settle counts once more than 11 are hidden within 900 s. Hidden
+are only shapes with at most 11 bound cycles in 900 s, each within 3 cycles
+or 22 s of a hand-back. That is the quarter-edge kick: in every steady-meter
+run below it is on the 1st to 3rd cycle after its hand-back (up to 30 s at
+a 30 s meter). In the rig's shape at 5 s the bound comes 30 to 55 s after
+the hand-back.
+
+**Sweep** (`goodwe-addon-checks:1`, 2 h runs, scratch/SAFETY-121/dev/).
+Quarter edge = test_safety119 part 1 (house 800 W, cap 2500 W, no
+forecast). Overload = part 4 (2 x 2500 W, cap 5000 W, house 5050 or
+5100 W, seeds 0-3). "Delay 1" is the old sim, "delay 0" the rig's shape.
+
+| meter | quarter edge, runs with a warning (new / bee7431 / no fix) | overload delay 1, quarters warned of 7 (new / bee7431 / no fix) | overload delay 0, 5100 W (new / bee7431 / no fix) |
+|---|---|---|---|
+| 1 s | 0/70 / 0/70 / 68/70 | 7 / 7 / 7 | 7 / 7 / 7 |
+| 2 s | 0/70 / 0/70 / 39/70 | 7 / 7 / 7 | 7 / 7 / 7 |
+| 3 s | 0/70 / 0/70 / 40/70 | 7 / 7 / 7 | 7 / 7 / 7 (5050 W: 7 / 1-7 / 7) |
+| 5 s | 0/70 / 0/70 / 40/70 | 7 / 7 / 7 | 7 / 0-2 / 7 |
+| 10 s | 0/70 / 0/70 / 40/70 | 7 / 7 / 7 | 7 / 0 / 7 |
+| 15 s | 0/70 / 0/70 / 40/70 | 7 / 4-7 / 7 | no fix warns 0-1 (5300 W: 7 / 0 / 7) |
+| 20 s | 0/60 / 0/60 / 30/60 | 7 / 5-7 / 7 | no fix warns 0 (5300 W: 7 / 0 / 7) |
+| 30 s | 0/60 / 0/60 / 30/60 | 7 / 3-5 / 7 | no fix warns 0 (5300 W: 6-7 / 0 / 6-7) |
+
+Quarter-edge seeds: 1-30 with the meter in the same cycle, and 1-40 (1-30
+at 20 and 30 s) with the test's 1-2 cycle delay. 5300 W: seeds 1-5.
+Commands identical to no fix and to bee7431 in all 1013 runs (these and
+the limits below). Choosing the numbers: the runs above were recorded
+without the fix and replayed through candidate rules; with 3, 4 or 5
+cycles, budgets 9 to 13 met both cases at 1-30 s. 8 warns at the quarter
+edge (2 s, seed 25) and 14 misses quarters in the rig's shape (1 s,
+5050 W), both checked in part 4. 11 is the middle, and 4 the middle of 3
+to 5; with a jittery meter (below) 3 gave more false alarms, 5 more quiet
+quarters (replay).
+
+**First warning after one hand-back** (the loop at its rail; later than
+no fix by): 11 s at 1 s, 22 s at 2 s, 24 s at 3 s, 25 s at 5 s (default),
+30 s at 10 s, 45 s at 15 s, 60 s at 20 s, 90 s at 30 s, 180 s at 60 s.
+bee7431: 10, 20, 30, 40, 80, 90, 80, 120, 240 s. In the overload runs at
+1 to 30 s, the first warning was at most 90 s later than without the fix.
+
+**Limits (measured, not fixed).**
+- A meter that jitters by 30 % with `cycle_floor_s` 15 (11 seeds): with
+  the test's 1-2 cycle meter delay the quarter edge warns on 2 of 11 seeds
+  at 15 s, 2 at 20 s and 5 at 30 s (bee7431: 4, 0, 10; no fix: 11 each);
+  with the meter in the same cycle on none (no fix: 10, 9, 11). The overload at 5100 W leaves up
+  to 4 quiet quarters in a row at 15 and 20 s (bee7431: no warning at all
+  on some seeds); at 5200 W at most 1. Its first warning came up to 61 min
+  later than without the fix. The numbers depend on the jitter draw: the
+  review's draw gave 4, 4 and 5 of 11 at the quarter edge (bee7431: 4, 1,
+  9) and up to 2 and 4 quiet quarters at 15 and 20 s.
+- With cycles over about 40 s, a bound that is never past a settle uses up
+  11 in 900 s only if the wire changes hands every few cycles; otherwise
+  it is never counted (part 5 prints it at 60 s).
+- Hidden as designed: a real bound with the kick's shape (at most 11 cycles
+  in 900 s, each within 3 cycles or 22 s of a hand-back).
+
+**Re-pinned.** test_safety84 (all six) and test_safety87 (`n1_crossing`,
+`n1_above`, `n1_charge_low`): only OUTPUT_CLAMP log rows differ from
+bee7431 and from no fix; commands, claims, guard and phases are the same.
@@ -1,8 +1,9 @@
 # GoodWe RS485 Controller

-Drives a GoodWe ES/BP battery inverter over its RS485 meter bus: holds net grid
-exchange at zero, and runs a monthly battery maintenance cycle so the BMS can
-balance cells and recalibrate its coulomb counter.
+Drives a GoodWe ES/BP battery inverter over its RS485 EMS port: sends it a grid
+reading to hold net grid exchange at zero, and runs a monthly battery
+maintenance cycle so the BMS can balance cells and recalibrate its coulomb
+counter.

 Installers: the printed field guide (`docs/GoodWe-RS485-Field-Guide.pdf`) is
 v0.1.0 and outdated; where it disagrees with this page, this page wins.
@@ -33,8 +34,8 @@ v0.1.0 and outdated; where it disagrees with this page, this page wins.

 You need:

- A GoodWe **ES / BP family** inverter (AA55 / RS485 meter-bus generation)
- The vendor's meter-emulating controller **disconnected** from the bus
+- A GoodWe **ES / BP family** inverter (AA55 generation)
+- The vendor's controller **disconnected** from the inverter's EMS port
 - A control board: a T-CAN485 (ESP32) flashed with
  `firmware/goodwe-master.yaml`
 - A grid-power sensor already working in Home Assistant, updating every ~5–10 s
@@ -210,7 +211,7 @@ The label and description each setting shows on the Configuration tab, in tab or
 | Limits | Battery cut-out level (%) | `bms_soc_floor` | The level where the battery's own management system stops giving power. Read it off your battery rather than copying a figure. |
 | Limits | Peak limit (W) | `peak_cap_w` | Your own number: the 15-minute average power the add-on keeps the grid under. Take it from your grid contract. |
 | Limits | Margin below the peak limit (W) | `peak_margin_w` | The add-on aims this much below the peak limit, so a 15-minute period that ends a little high still stays under it. |
-| Limits | 15-minute demand forecast entity (W) | `peak_forecast_entity` | Optional. A forecast of this 15-minute period's average power. Leave it empty and there is no peak limit. |
+| Limits | 15-minute demand forecast entity | `peak_forecast_entity` | Optional. A forecast of this 15-minute period's average power, in W or kW. With no power unit it is not used. Leave it empty and there is no peak limit. |
 | Limits | Peak reserve (%) | `peak_soc_floor` | Peak limiting will not draw the battery below this level, but ordinary use can. Derived value, leave it unchanged. |
 | Tariff | Dynamic price source | `price_provider` | Where prices come from. Choosing a source starts the price fetch, even with trading off. |
 | Tariff | Supplier markup (EUR/kWh) | `price_markup_eur_kwh` | Your supplier's margin. It is added only when the price source does not already include it. |
@@ -1697,7 +1698,7 @@ DECISIONS/MAINT-13-full-pack-is-complete.md.

 | option | meaning |
 |---|---|
-| `peak_forecast_entity` | Quarter-hour demand forecast, for capacity-tariff markets. Empty = no cap |
+| `peak_forecast_entity` | Quarter-hour demand forecast, for capacity-tariff markets. Read in its own unit (W, kW or any power unit). No unit, or a unit that is not power, means it is not used, as if empty (SAFETY-118). Empty = no cap |
 | `peak_cap_w` | The site's capacity-tariff target |
 | `peak_margin_w` (50) | Watts the peak guard aims under `peak_cap_w` (SAFETY-79). Reports and the bill use `peak_cap_w` itself |
 | `peak_soc_floor` (20) | **The percent below which the capacity-peak guard will not discharge the battery.** ⚠️ It bounds **the peak guard only** — it is **not a pack-wide reserve**, and ordinary self-consumption discharges straight past it (SAFETY-25, see below). Not optional and not the same thing as `maintenance_soc_floor` |
@@ -172,7 +172,7 @@ IDLE_NOT_COVERED = (
 IDLE_NO_SOC = (
    "state of charge is not being read, and a battery whose fill nobody knows "
    "cannot be told to empty or to fill")
-IDLE_OFF_PEAK_HOUR = "this hour is neither the buy hour nor the sell hour"
+IDLE_OFF_PEAK_HOUR = "now is not the cheapest or the dearest price period"
 # OPT-09. A TRADE NOTHING CAN TAKE IS NOT A TRADE, AND THE ALTERNATIVE IS WORSE
 # THAN A MISSED HOUR. `charge_w`/`discharge_w` used to be the site's whole rating
 # and are now SIZED to the packs whose state of charge permits that direction, so
@@ -196,7 +196,7 @@ IDLE_HEADROOM_UNMEASURED = (
    "creates the billed quantity (§9.1) and nothing is measuring the quarter "
    "this one would land in")
 NEGATIVE_PRICE = (
-    "§17: the sell hour is priced BELOW ZERO, so discharging into it would give "
+    "§17: the sell period is priced BELOW ZERO, so discharging into it would give "
    "energy away and pay for the privilege. Arbitrage must not export at a "
    "negative price")

@@ -347,7 +347,7 @@ def decide(plan, now: datetime, *, peak_guard_active, charge_headroom_w, soc,

    verdict = plan.arbitrage(peak_guard_active=peak_guard_active,
                             min_spread_eur_kwh=min_spread_eur_kwh,
-                             uncertainty=uncertainty)
+                             uncertainty=uncertainty, now=now)
    return verdict.match(
        refused=lambda v: _idle(v.reason),
        allowed=lambda v: _act(plan, now, v, soc, charge_w, discharge_w,
@@ -362,7 +362,7 @@ def _act(plan, now, v, soc, charge_w, discharge_w, floor_pct, ceiling_pct,
    if here is None:
        return _idle(
            f"the series carries a tradeable spread but no price for this "
-            f"instant ({now.isoformat()}), which is §11.4 for this hour rather "
+            f"instant ({now.isoformat()}), which is §11.4 for this period rather "
            f"than a reason to reach for a neighbouring one",
            spread=v.spread_eur_kwh, required=v.required_spread_eur_kwh)

@@ -381,7 +381,7 @@ def _act(plan, now, v, soc, charge_w, discharge_w, floor_pct, ceiling_pct,
    # irreversible action may rest on it.
    if here.provisional:
        return _idle(
-            f"§8.3: the price for this hour ({here.start.isoformat()}) is "
+            f"§8.3: the price for this period ({here.start.isoformat()}) is "
            f"CARRIED FORWARD, not published, and no irreversible action may be "
            f"taken on a provisional price",
            spread=v.spread_eur_kwh, required=v.required_spread_eur_kwh,
@@ -399,18 +399,18 @@ def _act(plan, now, v, soc, charge_w, discharge_w, floor_pct, ceiling_pct,
        # negative price reports the reason that actually forbids the trade
        # rather than one that happens to fire first on some other site.
        if price < 0:
-            return _idle(f"{NEGATIVE_PRICE} - this hour is "
+            return _idle(f"{NEGATIVE_PRICE} - this period is "
                         f"{price:+.4f} EUR/kWh", **common)
        if soc <= floor_pct:
            return _idle(
-                f"the sell hour is here at {price:.4f} EUR/kWh but the pack is "
+                f"the sell period is here at {price:.4f} EUR/kWh but the pack is "
                f"at {soc:g} %, at or under the {floor_pct:g} % reserve floor "
                f"arbitrage may not spend (§10.1 priority 4)", **common)
        if not abs(float(discharge_w)) > 0.0:
            return _idle(IDLE_NO_SIZE, **common)
        return ArbitrageDecision(
            action=DISCHARGE, power_w=abs(float(discharge_w)),
-            reason=(f"{DISCHARGE}: this is the dearest firm hour at "
+            reason=(f"{DISCHARGE}: this is the dearest firm price period at "
                    f"{price:.4f} EUR/kWh, {v.spread_eur_kwh:.4f} above the "
                    f"cheapest and clear of the {v.required_spread_eur_kwh:.4f} "
                    f"this cycle had to cover; discharging "
@@ -421,7 +421,7 @@ def _act(plan, now, v, soc, charge_w, discharge_w, floor_pct, ceiling_pct,

    if soc >= ceiling_pct:
        return _idle(
-            f"the buy hour is here at {price:.4f} EUR/kWh but the pack is at "
+            f"the buy period is here at {price:.4f} EUR/kWh but the pack is at "
            f"{soc:g} %, at or over the {ceiling_pct:g} % ceiling - there is "
            f"nowhere to put the cheap energy", **common)
    if not abs(float(charge_w)) > 0.0:
@@ -456,7 +456,7 @@ def _act(plan, now, v, soc, charge_w, discharge_w, floor_pct, ceiling_pct,
    capped = size_w < asked_w
    return ArbitrageDecision(
        action=CHARGE, power_w=-size_w,
-        reason=(f"{CHARGE}: this is the cheapest firm hour at "
+        reason=(f"{CHARGE}: this is the cheapest firm price period at "
                f"{price:.4f} EUR/kWh, {v.spread_eur_kwh:.4f} below the dearest "
                f"and clear of the {v.required_spread_eur_kwh:.4f} this cycle "
                f"had to cover; charging {size_w:.0f} W from {soc:g} %"
@@ -22,16 +22,13 @@ 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, Uncertainty, brussels
+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

 # A battery at or under this many watts is resting, not charging or giving.
 IDLE_W = 50.0
-# Display only: the lowest third of today's price range is "cheap", the top
-# third "expensive". A price range under this is flat, and nothing is marked.
-FLAT_EUR_KWH = 0.01

 # Severity words the page shows; the same four as STYLE.md section 3.
 ALARM, WARNING, INFO = messages.ALARM, messages.WARNING, messages.INFO
@@ -142,55 +139,103 @@ class DayPrices:
    def __init__(self):
        self.day = None
        self.points = {}
+        self.kinds = {}

    def see(self, points, day0, day1):
        if self.day != day0:
-            self.day, self.points = day0, {}
+            self.day, self.points, self.kinds = day0, {}, {}
        for p in points:
            if day0 <= p.start < day1:
                self.points[p.start] = p
        return sorted(self.points.values(), key=lambda p: p.start)


-def hour_bars(points, day0, day1):
-    """One bar per local hour: the mean of its prices, or None when unknown.
-    `kind` is cheap / dear / mid by thirds of today's range (display only).
-    The page calls these "low price" and "high price", not cheap hours: the
-    add-on trades in the one cheapest and one dearest hour, not in a third."""
-    n = int(round(_hours(day1, day0)))
+def _bar_step(pts):
+    """The series' own spacing: its smallest gap, never over an hour."""
+    gaps = [y.start - x.start for x, y in zip(pts, pts[1:])
+            if y.start > x.start]
+    return min(gaps + [timedelta(hours=1)])
+
+
+def _bar_cover(pts):
+    """`[(start, end, point)]`: what each point is the price of on the chart.
+    The add-on's own rule, not a copy: `price._cover_table()` (TARIFF-14), so
+    a point covers until the next one starts and never over an hour, and the
+    last one for the span of the one before it."""
+    return _cover_table(pts)
+
+
+def price_bars(points, day0, day1, windows=(), now=None, kept=None):
+    """One bar per price step of the day: a quarter for a 15-minute series
+    (96; 92 and 100 on the clock-change days), an hour for an hourly one or a
+    static tariff. A bar is the price of the point that covers it, never an
+    average, and a step with no price is a bar with `eur_kwh` None.
+    `kind` is "cheap" or "dear" where `windows` (`[(kind, start, end)]`, the
+    runs the add-on itself uses) cover the bar's start, else "mid". A bar that
+    is over keeps the kind it had while it was still ahead (`kept`, a dict
+    that lives a day). Display only."""
+    pts = sorted(points, key=lambda p: p.start)
+    step = _bar_step(pts)
+    cover = _bar_cover(pts)
+    n = int((day1 - day0) / step)
    bars = []
    for k in range(n):
-        a, b = day0 + timedelta(hours=k), day0 + timedelta(hours=k + 1)
-        inside = [p for p in points if a <= p.start < b]
-        price = (sum(p.eur_per_kwh for p in inside) / len(inside)
-                 if inside else None)
+        a = day0 + k * step
+        z = a + step
+        hit = next((p for s, e, p in cover if s <= a < e), None)
+        kind = None
+        if hit is not None:
+            if kept is not None and now is not None and z <= now:
+                kind = kept.get(a, "mid")
+            else:
+                kind = next((w[0] for w in windows if w[1] <= a < w[2]),
+                            "mid")
+                if kept is not None:
+                    kept[a] = kind
        bars.append({"h": k, "start": a.isoformat(), "label": hhmm(a),
-                     "end_label": hhmm(b), "points": len(inside),
-                     "eur_kwh": None if price is None else round(price, 4),
-                     "estimate": bool(inside) and any(p.provisional
-                                                      for p in inside),
-                     "kind": None})
-    known = [b["eur_kwh"] for b in bars if b["eur_kwh"] is not None]
-    if known and max(known) - min(known) >= FLAT_EUR_KWH:
-        lo, hi = min(known), max(known)
-        third = (hi - lo) / 3.0
-        for b in bars:
-            p = b["eur_kwh"]
-            if p is None:
-                continue
-            b["kind"] = ("cheap" if p <= lo + third else
-                         "dear" if p >= hi - third else "mid")
-    elif known:
-        for b in bars:
-            if b["eur_kwh"] is not None:
-                b["kind"] = "mid"
+                     "end_label": hhmm(z),
+                     "eur_kwh": None if hit is None
+                     else round(hit.eur_per_kwh, 4),
+                     "estimate": hit is not None and bool(hit.provisional),
+                     "kind": kind})
    return bars


+def _price_mode_in_use(c):
+    """True when at least one battery is on and uses a price mode. The runs
+    belong to those batteries; with all on Solar first or off, nothing acts
+    on a price."""
+    for inv in c.inverters:
+        pm = c.pack_mode(inv)
+        if pm.use and pm.mode in PRICE_MODES:
+            return True
+    return False
+
+
+def price_windows(c, plan, verdict):
+    """`[(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."""
+    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 []
+        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))]
+
+
 def day_range(points):
    """(lowest, highest) of today's published points, as {eur_kwh, label},
-    or (None, None). The feed's own points, like the trade legs, not the
-    chart's hour averages."""
+    or (None, None). The feed's own points, like the trade legs."""
    firm = [p for p in points if not p.provisional]
    if not firm:
        return None, None
@@ -217,11 +262,12 @@ def _run(i, kind, start, end, day0, day1, what, why, amount, *, kwh=None,
            "eur_kwh": None if price is None else round(price, 4)}


-def trade_verdict(c, plan):
+def trade_verdict(c, plan, now):
    """The arbitrage verdict the control cycle would reach on this plan, or a
    reason there is none. The SAME call and inputs as `Controller.cycle()`:
    `plan.arbitrage()` with the peak guard's state, the cycle cost and the
-    no-weather uncertainty. Returns `(verdict_or_None, why_key)`."""
+    no-weather uncertainty, and (PRICE-02) the same `now`. Returns
+    `(verdict_or_None, why_key)`."""
    if not arbitrage.enabled(c.o):
        return None, "off"
    guard = arbitrage.guard_state(c.peak_guard)
@@ -231,20 +277,24 @@ def trade_verdict(c, plan):
        return None, "no_prices"
    verdict = plan.arbitrage(peak_guard_active=guard,
                             min_spread_eur_kwh=arbitrage.threshold_eur_kwh(c.o),
-                             uncertainty=frozenset({Uncertainty.NO_WEATHER}))
+                             uncertainty=frozenset({Uncertainty.NO_WEATHER}),
+                             now=now)
    return verdict.match(
        allowed=lambda v: (v, "allowed"),
-        refused=lambda _v: (None, refusal_key(plan, guard)))
+        refused=lambda _v: (None, refusal_key(plan, guard, now)))


-def refusal_key(plan, guard):
+def refusal_key(plan, guard, now):
    """Which of `TariffPlan.arbitrage()`'s refusals fired, in its own order:
    the peak guard, no prices, under two published points, then the gap."""
    if guard:
        return "peak"
    if not plan.has_prices:
        return "no_prices"
-    if sum(1 for p in _points(plan) if not p.provisional) < 2:
+    pts = _points(plan)
+    ahead = {id(p) for _s, end, p in _cover_table(pts) if end > now}
+    pts = [p for p in pts if id(p) in ahead]
+    if sum(1 for p in pts if not p.provisional) < 2:
        return "not_firm"
    return "not_worth"

@@ -551,13 +601,15 @@ def build_plan(c, now, shadow, running, held=False, settled=True):
                plan = static
        except Exception:                               # noqa: BLE001
            pass
-    seen = _day_prices(c).see(_points(plan), day0, day1)
-    bars = hour_bars(seen, day0, day1)
+    days = _day_prices(c)
+    seen = days.see(_points(plan), day0, day1)

    limit_w = c.peak.cap_w  # the limit the controller parsed at start
    runs, lines = [], []
    # The control cycle trades on the fresh plan only, so this does too.
-    verdict, trade_why = trade_verdict(c, fresh)
+    verdict, trade_why = trade_verdict(c, fresh, now)
+    bars = price_bars(seen, day0, day1, price_windows(c, fresh, verdict),
+                      now, days.kinds)
    modes_on = bool(getattr(c, "modes_on", False))
    if running:
        off = {i for i, inv in enumerate(c.inverters) if _off(c, inv)}
@@ -1028,9 +1080,9 @@ def _kwh(v) -> str:
    return _dec(f"{float(v):.1f}") + " kWh"


-# Row id -> the title on Home. The row's own sentence is the body, and it stays
-# in English (app/messages.py). Five titles are the notification's own title,
-# which test_ui_text.py checks.
+# Row id -> the title on Home. The row's own sentence is the body, in the
+# page's language (UX-46, `messages.pick`). Five titles are the notification's
+# own title, which test_ui_text.py checks.
 _EN = uitext.words("en")["home_words"]
 ATTN_TITLES = {(None if k == "none" else k): v for k, v in _EN["attn"].items()}
 ATTN_FROM_MESSAGES = {
@@ -1431,3 +1483,10 @@ def _samples() -> list:
            ("not_covered", "no_prices", "peak", "not_firm", "not_worth",
             "no_level")]
    return out
+
+
+def priced_hours(bars):
+    """How many clock hours of the day have a price: distinct hours among the
+    bars that have one, so 96 quarters count 24, not 96. The setup wizard's
+    "N of 24 hours". A 23-hour day gives 23, a 25-hour day 24."""
+    return len({b["label"][:2] for b in bars if b.get("eur_kwh") is not None})
@@ -3,7 +3,7 @@
 WHAT THIS THING DOES, in one paragraph: it reads the house's net grid power from
 Home Assistant, decides how hard the battery should charge or discharge to hold
 that at zero, and writes that figure to an ESP32 which puts it on the inverter's
-RS485 meter bus. Once a month it runs a full low->full battery cycle so the BMS
+RS485 EMS port. Once a month it runs a full low->full battery cycle so the BMS
 can balance cells and recalibrate its coulomb counter.

 ⚠️ THE ONE THING TO UNDERSTAND BEFORE CHANGING ANY OF THIS: the inverter holds
@@ -299,6 +299,14 @@ REFUSED_PROGRESS_W = _ctl.PROBE_ANSWER_W / 2
 # was told over the same span as above (the plant's measured settle time), so
 # a healthy battery still settling on a new command is not short.
 SHORT_CYCLES, SHORT_SPAN_S = _ctl.SETTLE_CYCLES, REFUSED_SPAN_S
+# SAFETY-119/121: after a hand-back the loop's bound is hidden until
+# HANDBACK_CYCLES cycles and SHORT_SPAN_S have passed; across all hand-backs
+# on at most ROLLING_BOUND_CYCLES cycles in any ROLLING_S seconds. Measured in
+# DECISIONS/SAFETY-121-bound-every-quarter.md. Without a monotonic clock the
+# budget never refills.
+HANDBACK_CYCLES = 4
+ROLLING_S = 900.0
+ROLLING_BOUND_CYCLES = 11


 def _refused_interval(sign: int) -> tuple:
@@ -1202,6 +1210,9 @@ class Controller:
        # `grid` is P1, one meter, one connection, and belongs here.
        self.grid = None
        self.peak_fc = None
+        # SAFETY-118: the unit fault last logged for the peak forecast (None =
+        # no fault), so the warning comes once and again only if it changes.
+        self._peak_fc_fault = None
        self.cheap = False
        self._price_gated = False     # MAINT-13: is a price gate set up
        # PRICE-01. Which step of the price chain the prices come from (logged
@@ -1269,6 +1280,13 @@ class Controller:
        self._loop_decision = None
        self._asked_hist: dict = {}
        self._short_run = 0
+        # SAFETY-119: did another owner set the wire last cycle; the window
+        # after a hand-back (monotonic s, the loop's cycles in a row); the
+        # monotonic s of the bound cycles hidden in the last ROLLING_S (a
+        # stop does not clear them).
+        self._wire_lost = False
+        self._handback = None
+        self._hidden = ()
        self.stopping = False
        # SAFETY-61. time.monotonic() at the end of the last run_control() pass.
        self.loop_pass_mono = None
@@ -2351,7 +2369,8 @@ class Controller:
            return plan.arbitrage(
                peak_guard_active=active,
                min_spread_eur_kwh=arbitrage.threshold_eur_kwh(self.o),
-                uncertainty=frozenset({Uncertainty.NO_WEATHER})).match(
+                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:
            # A charge asks the guard (section 9.1 interlock); a sell only
@@ -3358,6 +3377,22 @@ class Controller:
        self.pv_w, self.pv_why, self.pv_parts = pv_read.total(
            list(zip(roster, states)), pv_read.inverted(self.o))

+    def _peak_fc_unit_log(self, fault) -> None:
+        """SAFETY-118. One WARNING when the peak forecast's unit cannot be read
+        in watts, and again only if the unit changes; the unit is on DEBUG."""
+        if fault == self._peak_fc_fault:
+            return
+        self._peak_fc_fault = fault
+        if fault is None:
+            _LOG.info("The 15-minute demand forecast is used again.")
+        elif fault == "":
+            _LOG.warning("The 15-minute demand forecast has no unit, so it "
+                         "is not used.")
+        else:
+            _LOG.warning("The 15-minute demand forecast is not in a power "
+                         "unit, so it is not used.")
+            _LOG.debug("The 15-minute demand forecast reads in %r.", fault)
+
    async def _read_forecast(self) -> None:
        """OPT-11 P4: the solar forecast sensors (`solarfc.read()`). A
        failed or stale read is no forecast, never a zero."""
@@ -3448,11 +3483,17 @@ class Controller:
            _reads.append(self._read_forecast())
        await asyncio.gather(*_reads)
        if o.get("peak_forecast_entity"):
-            raw = await self.hass.number(o["peak_forecast_entity"])
-            # Accept kW or W - nobody's quarter-hour forecast is 50 W.
-            self.peak_fc = None if raw is None else (raw * 1000 if abs(raw) < 50 else raw)
+            # SAFETY-118: read in its own unit, like the PV path. One state
+            # read, as `hass.number()` made. No unit or a unit that is not
+            # power: not used, as if the option were empty.
+            st = await self.hass.state(o["peak_forecast_entity"])
+            self.peak_fc, _why = pv_read.watts(st)
+            # A missing reading leaves the unit-fault state as it was.
+            if pv_read.has_reading(st):
+                self._peak_fc_unit_log(pv_read.unit_fault(st))
        else:
            self.peak_fc = None
+            self._peak_fc_fault = None

        now_e, avg_e = o.get("price_now_entity"), o.get("price_avg_entity")
        if now_e and avg_e:
@@ -5788,6 +5829,7 @@ class Controller:
        if d is None:
            self._short_run = 0
            self._asked_hist = {}
+            self._wire_lost, self._handback = False, None
            return
        unmet = self.allocation.unmet_w if self.allocation is not None else 0
        cut = (resolution.bound_by or "").split("(")[0]
@@ -5813,7 +5855,9 @@ class Controller:
                 and delivery_short(asked[inv.name], inv.batt,
                                    self.tuning.saturation_w)]
        self._short_run = self._short_run + 1 if short else 0
-        if owns and self.loop_clamped[0]:
+        settling = self._settling(owns, now)
+        if owns and self.loop_clamped[0] and not (
+                settling and not self.loop_clamped[2]):
            return
        engaged = self._short_run >= self.tuning.saturation_cycles
        named = len(self.inverters) > 1
@@ -5822,6 +5866,41 @@ class Controller:
            if engaged else "", False)
        self.loop_clamp_facts = ()

+    def _settling(self, owns, now) -> bool:
+        """SAFETY-119: does the loop's bound on this cycle count? Not within
+        a settle after another owner handed the wire back: its integrator is
+        re-seeded from that owner's command and kicked by a meter that does
+        not show it yet. SAFETY-121: the settle is HANDBACK_CYCLES cycles and
+        SHORT_SPAN_S after the hand-back, so a bound that outlasts it counts
+        at any cycle length; losing the wire restarts it. Across all
+        hand-backs the bound is hidden on at most ROLLING_BOUND_CYCLES cycles
+        in any ROLLING_S, so a bound that never outlasts a settle is counted
+        too. DECISIONS/SAFETY-121-bound-every-quarter.md."""
+        def aged(t0, span):
+            return now is None or t0 is None or now - t0 >= span
+
+        if not owns:
+            self._wire_lost, self._handback = True, None
+            return False
+        if self._wire_lost:
+            self._wire_lost, self._handback = False, (now, 0)
+        if self._handback is None:
+            return False
+        tc, n = self._handback
+        n += 1
+        self._handback = (tc, n)
+        if aged(tc, SHORT_SPAN_S) and n >= HANDBACK_CYCLES:
+            self._handback = None
+            return False
+        if self.loop_clamped[0] and not self.loop_clamped[2]:
+            kept = tuple(t for t in self._hidden if now is None or (
+                t is not None and now - t < ROLLING_S))
+            if len(kept) >= ROLLING_BOUND_CYCLES:
+                self._hidden = kept
+                return False
+            self._hidden = kept + (now,)
+        return True
+
    async def check_output_clamp(self) -> None:
        """SAFETY-03. Alarm whenever a clamp actually engaged this cycle.

@@ -7240,6 +7319,10 @@ class Controller:
            # is both is a check nobody reads.
            out.append({"ok": False, "warn": True, "id": "peak_forecast",
                        "text": messages.row_no_peak_forecast()})
+        elif getattr(self, "_peak_fc_fault", None) is not None:
+            out.append({"ok": False, "warn": True, "id": "peak_forecast",
+                        "text": messages.row_peak_forecast_unit(
+                            self._peak_fc_fault)})
        # OPT-17: a forecast summed from several entities names, by position,
        # each member with no usable reading. A caution: control goes on.
        gaps = getattr(self, "solar_fc_gaps", ())
@@ -7382,7 +7465,8 @@ class Controller:
            level, banner = "warn", messages.banner_stopped()
        elif runs:
            level, running_alarm = "bad", True
-            banner = runs[0].get("banner") or messages.headline(runs[0]["text"])
+            banner = runs[0].get("banner") or messages.headline_bi(
+                runs[0]["text"])
        elif any(i.delivery_wd.tripped for i in self.inverters):
            # ⚠️ SAFETY-42, AND IT IS A `warn` BANNER RATHER THAN A `bad` ONE,
            # WHICH IS THE WHOLE "reports, does not act" DECISION IN ONE LINE.
@@ -7405,11 +7489,11 @@ class Controller:
            # character; at two, "Maintenance: drain" without a name is a
            # banner an operator cannot act on, because the remedy is at one
            # device and the site has two.
-            level, banner = "warn", f"Maintenance: {self.maint.phase}"
-            if len(self.inverters) > 1:
-                banner += f" ({self.maint_unit.name})"
+            level, banner = "warn", messages.banner_maintenance(
+                self.maint.phase,
+                self.maint_unit.name if len(self.inverters) > 1 else "")
        else:
-            level, banner = "ok", "Running — holding grid at zero"
+            level, banner = "ok", messages.banner_running()

        def w(v):
            return "—" if v is None else f"{v:,.0f} W".replace(",", " ")
@@ -7513,6 +7597,13 @@ class Controller:
                now=datetime.now(timezone.utc), why=self.why_words)),
        ]
        held = level == "bad" and not running_alarm
+        # UX-46. The rows were built in English with their Dutch beside them
+        # (`messages.Bi`); the page's language is chosen once, here, for the
+        # Home sentences, the checks list, the rows that carry one and the
+        # banner. A plain str (no Dutch twin) stays as it is.
+        checks = [dict(c, text=messages.pick(c["text"], lang)) for c in checks]
+        rows = [(k, messages.pick(v, lang)) for k, v in rows]
+        banner = messages.pick(banner, lang)
        out = {
            "banner": banner, "level": level, "rows": rows, "checks": checks,
            "hint": self.hint,
@@ -29,7 +29,7 @@ _LOG = logging.getLogger("goodwe.mqtt")
 DEVICE = {
    "identifiers": ["goodwe_rs485_controller"],
    "name": "GoodWe",
-    "manufacturer": "GoodWe (via RS485 meter emulation)",
+    "manufacturer": "GoodWe (via RS485 EMS port)",
    "model": "ES/BP series",
 }

@@ -93,12 +93,12 @@ def watts(state: dict | None) -> tuple:
    unknown" are different claims and the page has to be able to make the first.

    ⚠️ THE UNIT IS READ OFF THE ENTITY AND NOT ASSUMED, AND THERE IS NO
-    MAGNITUDE HEURISTIC. `read_inputs()` guesses kW-or-W for
-    `peak_forecast_entity` with `abs(raw) < 50`, which is safe there because
-    nobody's quarter-hour demand forecast is 50 W. It is NOT safe here: 30 W of
-    real production at dusk is an ordinary reading, and that heuristic would
-    publish it as 30 kW - a fabricated number, in the channel whose entire
-    purpose is to be believed a week later. A sensor whose unit this cannot read
+    MAGNITUDE HEURISTIC. 30 W of real production at dusk is an ordinary reading,
+    and a "small number means kW" rule would publish it as 30 kW - a fabricated
+    number, in the channel whose entire purpose is to be believed a week later.
+    SAFETY-118 removed the last such rule, on `peak_forecast_entity`, for the
+    same reason (DECISIONS/SAFETY-118-peak-forecast-unit.md): the peak forecast
+    now reads through this function too. A sensor whose unit this cannot read
    is REFUSED rather than guessed at.
    """
    if state is None:
@@ -126,6 +126,31 @@ def watts(state: dict | None) -> tuple:
    return value * WATTS_PER[unit], unit


+def has_reading(state: dict | None) -> bool:
+    """SAFETY-118. True when `state` holds a number, so its unit can be judged.
+    A missing, unavailable, unknown or non-numeric state is a missing reading."""
+    if state is None:
+        return False
+    raw = str(state.get("state", "")).strip()
+    if raw.lower() in BAD_STATES:
+        return False
+    try:
+        float(raw)
+    except ValueError:
+        return False
+    return True
+
+
+def unit_fault(state: dict | None):
+    """SAFETY-118. `None` unless `state` holds a number whose unit cannot be
+    read in watts, then that unit (`""` for none). `None` also means a missing
+    reading: use `has_reading()` to tell it from a good unit."""
+    if not has_reading(state):
+        return None
+    unit = str((state.get("attributes") or {}).get(UNIT_KEY) or "").strip()
+    return None if unit in WATTS_PER else unit
+
+
 # --- TEL-12: the ROSTER, and the SITE figure over it --------------------------

 def entities(opts: dict) -> tuple:
@@ -54,10 +54,12 @@ class SetupOnly:

    def status_payload(self, lang: str = "en") -> dict:
        return {"setup_only": True, "mode": "setup_only",
-                "banner": messages.banner_setup_only(), "level": "warn",
+                "banner": messages.pick(messages.banner_setup_only(),
+                                       lang), "level": "warn",
                "rows": [["Control", "not started, in setup"]],
                "checks": [{"ok": False, "warn": True,
-                            "text": messages.row_setup_only()}],
+                            "text": messages.pick(messages.row_setup_only(),
+                                                  lang)}],
                "hint": self.hint, "events": list(self.events)}

    async def handle_action(self, what):
@@ -78,6 +78,8 @@ h2{font-size:15px;margin:0 0 10px;font-weight:650}
 .bars i.cheap{background:var(--cheap)}
 /* not by colour alone: expensive hours are striped, estimates are faded */
 .bars i.dear{background:repeating-linear-gradient(135deg,var(--dear) 0 4px,color-mix(in srgb,var(--dear) 60%,var(--card)) 4px 7px)}
+.bars.fine{gap:1px}
+.bars.fine i{border-radius:1px 1px 0 0}
 .bars i.est{opacity:.55}
 .bars i.none{background:none;border-bottom:2px dotted var(--faint);height:2px!important}
 .lane{position:relative;height:18px;margin-top:4px;background:var(--bg);border-radius:4px}
@@ -177,11 +177,12 @@
    const known = p.prices.filter((b) => b.eur_kwh != null);
    const mx = Math.max(0.01, ...known.map((b) => Math.abs(b.eur_kwh)));
    bars.setAttribute("aria-label", t("plan.name"));
+    bars.classList.toggle("fine", p.prices.length > 48);
    bars.replaceChildren(...p.prices.map((b) => {
      const title = b.label + " " + t("plan.time_to") + " " + b.end_label;
      if (b.eur_kwh == null) return chartItem("i", "none", "", title, [t("plan.none_tip") + "."]);
      const kind = b.kind === "cheap" ? ", " + t("plan.cheap_tip") : b.kind === "dear" ? ", " + t("plan.dear_tip") : "";
-      const est = (b.points > 1 ? ", " + t("plan.average_tip") : "") + (b.estimate ? ", " + t("plan.estimate_tip") : "");
+      const est = (b.estimate ? ", " + t("plan.estimate_tip") : "");
      return chartItem("i", (b.kind || "mid") + (b.estimate ? " est" : ""),
                       "height:" + Math.max(4, Math.round(Math.abs(b.eur_kwh) / mx * 100)) + "%",
                       title, [eur(b.eur_kwh) + " " + t("plan.per_kwh") + kind + est + "."]);
@@ -207,7 +207,7 @@ from datetime import datetime, timedelta, timezone
 from . import messages, price_chain
 from .price import (
    MAX_PLAUSIBLE_EUR_KWH, Absence, PricePoint, PriceProduct, PriceRead,
-    Uncertainty, _Outcome, brussels, load_prices, price_option,
+    Uncertainty, _Outcome, _cover_table, brussels, load_prices, price_option,
    provider_configured, required_spread, uncertainty_of, widen_factor,
 )
 from .price_chain import uses_chain
@@ -986,12 +986,25 @@ class TariffPlan:
        return here.eur_per_kwh < (sum(p.eur_per_kwh for p in firm) / len(firm))

    def arbitrage(self, *, peak_guard_active: bool, min_spread_eur_kwh,
-                  uncertainty) -> Arbitrage:
+                  uncertainty, now: datetime) -> Arbitrage:
        """May OPT-04 trade, and on what numbers. See the module docstring.

-        ⚠️ ALL THREE ARGUMENTS ARE REQUIRED AND KEYWORD-ONLY, for one reason
+        PRICE-02. `now` (tz-aware) drops the points whose price period has
+        ended (`end <= now`, the span `price._cover_table()` gives it), so the
+        cheapest and dearest point are always ones that can still be traded.
+        It is taken here, per call, and not when the plan is built: a plan
+        built at 03:00 is still used at 03:20. An hourly point that is still
+        current stays in.
+
+        ⚠️ ALL FOUR ARGUMENTS ARE REQUIRED AND KEYWORD-ONLY, for one reason
        each, and none of them has a default:

+          `now`                 PRICE-02. A caller that could leave it out
+                                would get the whole series back, elapsed
+                                periods included, and the verdict could aim
+                                at a period that is over. A test that wants
+                                the whole series passes an instant before it.
+
          `peak_guard_active`   §9.1/§10.1 put peak shaving above arbitrage,
                                and this is how that ordering survives a
                                strategy that has not been written yet: the
@@ -1029,6 +1042,12 @@ class TariffPlan:
                f"{sorted(map(repr, caller_sources))} - a string widens by "
                f"nothing while reporting that it widened.")

+        if not isinstance(now, datetime) or now.tzinfo is None \
+                or now.utcoffset() is None:
+            raise TypeError(f"now must be a tz-aware datetime, not {now!r}; "
+                            f"a naive instant is ambiguous for one hour "
+                            f"every October")
+
        if peak_guard_active:
            return Arbitrage.refuse(
                "the capacity-tariff peak guard is holding, and §10.1 puts peak "
@@ -1056,6 +1075,8 @@ class TariffPlan:
        # day with no fetch at all) has no firm pair left and is refused, which
        # is the previous behaviour arrived at by a truer route.
        pts = self.read.points
+        ahead = {id(p) for _s, end, p in _cover_table(pts) if end > now}
+        pts = tuple(p for p in pts if id(p) in ahead)
        firm = tuple(p for p in pts if not p.provisional)
        if len(firm) < 2:
            # ⚠️ POINTS, AND THE HOUR FIGURE BESIDE IT RATHER THAN INSTEAD OF
@@ -1334,6 +1355,11 @@ async def resolve_tariff(opts: dict, since: datetime, until: datetime,
    that, so the spread is over hours that are still ahead. Both directions of
    the difference are real: the window gains the unpublished hours it was
    missing and loses the elapsed ones it should never have had.
+
+    ⚠️ PRICE-02: THAT HOLDS FOR AN HOURLY FEED ONLY. The window is floored to
+    the hour, so a 15-minute feed keeps the elapsed periods of the current
+    hour, and the plan ages between refreshes. `TariffPlan.arbitrage(now=...)`
+    drops the periods that have ended, at every call.
    """
    stamp = now or datetime.now(timezone.utc)
    if not provider_configured(opts):
@@ -66,8 +66,7 @@
      "estimate_tip": "estimate from yesterday",
      "none_tip": "No price known",
      "no_prices": {"description": "No prices for today, so the chart shows only the plan."},
-      "list": "The plan in words",
-      "average_tip": "hour average"
+      "list": "The plan in words"
    },
    "peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"},
    "attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"},
@@ -63,8 +63,7 @@
      "estimate_tip": "schatting op basis van gisteren",
      "none_tip": "Geen prijs bekend",
      "no_prices": {"description": "Geen prijzen voor vandaag, dus de grafiek toont alleen het plan."},
-      "list": "Het plan in woorden",
-      "average_tip": "gemiddelde van het uur"
+      "list": "Het plan in woorden"
    },
    "peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"},
    "attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"},
@@ -194,7 +194,7 @@ GROUPS = (
            Field("peak_cap_w", SLIDER, "kW", scale=1000, step=100,
                  simple=True, wizard=5, note="month_peak"),
            Field("peak_margin_w", SLIDER, "W", step=10),   # SAFETY-79
-            Field("peak_forecast_entity", ENTITY, kind="power_w", wizard=5),
+            Field("peak_forecast_entity", ENTITY, kind="power", wizard=5),
            Field("peak_soc_floor", LOCKED, "%"),
        )),
        Part("start", (
@@ -17,7 +17,7 @@ from . import uilayout as L
 from . import uitext
 from . import uimodel as U
 from .configui import help_of, label_of, problems_by_field, split_group
-from .validate import power_request_entities
+from .validate import note_text, power_request_entities

 # A choice the page cannot make, only keep. `price_service` needs a token, and
 # the token is a secret this page never draws (uilayout.HIDDEN), so it is set on
@@ -314,7 +314,7 @@ def anchors(problems, notes, model, keys, lang="en") -> list:
        add(None, None, "bad", text)
    for note in notes:
        tier = note.tier if note.tier in _TIERS else "info"
-        text = messages.NOTE_NL.get(note.text, note.text) if lang == "nl" else note.text
+        text = note_text(note, lang)
        for key in note.keys or (None,):
            for field, card in (targets(key, note.text, model) if key
                                else [(None, None)]):
@@ -386,12 +386,23 @@ class Note(NamedTuple):
                                # also "ok" and "bad" (setup_checks)
    keys: tuple
    text: str
+    nl: str = ""                # UX-46: the same sentence in Dutch


-def _advise(notes, tier: str, keys, text: str) -> None:
-    """Add a Note when the caller collects them (the settings page)."""
+def _advise(notes, tier: str, keys, text: str, nl: str = "") -> None:
+    """Add a Note when the caller collects them (the settings page). `nl` is
+    the Dutch twin of `text`; the page picks one (`note_text()`)."""
    if notes is not None:
-        notes.append(Note(tier, tuple(keys), text))
+        notes.append(Note(tier, tuple(keys), text, nl))
+
+
+def note_text(note, lang: str = "en") -> str:
+    """The note's sentence in the page's language, English when it has no
+    Dutch twin."""
+    if lang == "nl":
+        return getattr(note, "nl", "") or messages.NOTE_NL.get(
+            note.text, note.text)
+    return note.text


 # ⚠️ A MIRROR OF A FIRMWARE CONSTANT, AND IT CANNOT BE IMPORTED. The firmware
@@ -628,6 +639,11 @@ def S(key: str, where: str = "") -> str:
    return messages.setting(key, where.strip().strip("()"))


+def SN(key: str, where: str = "") -> str:
+    """`S()` with the Dutch label, for the Dutch twin of a note."""
+    return messages.setting(key, where.strip().strip("()"), "nl")
+
+
 def _labels(keys, joiner: str = "and") -> str:
    """Several settings, each with its key: the config panel files a refusal
    under every key it names (`configui.problems_by_field()`)."""
@@ -1216,7 +1232,9 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
            integ_w, max_w)
        _advise(notes, "warn", ("integrator_max_w",),
                f"{S('integrator_max_w')} is above {S('max_w')}, which only "
-                "adds overshoot, so set it to 0.")
+                "adds overshoot, so set it to 0.",
+                nl=f"{SN('integrator_max_w')} is hoger dan {SN('max_w')}, wat "
+                "alleen doorschieten geeft, dus zet het op 0.")

    # ⚠️ THE SIBLING OF RULE 6, AND NOT THE SAME CASE - see the docstring. The
    # drain phase OWNS the actuator (`Claim.set` at P_MAINTENANCE), and a SET is
@@ -1244,7 +1262,10 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
        _advise(notes, "warn", ("maintenance_discharge_w",),
                f"{S('maintenance_discharge_w')} is above "
                f"{S('max_w', maint_where)}, so the battery empties at "
-                f"{messages.watts(maint_cap)} and the cycle takes longer.")
+                f"{messages.watts(maint_cap)} and the cycle takes longer.",
+                nl=f"{SN('maintenance_discharge_w')} is hoger dan "
+                f"{SN('max_w', maint_where)}, dus de batterij loopt leeg met "
+                f"{messages.watts(maint_cap)} en de cyclus duurt langer.")
        _LOG.debug(
            "Not refused: the drain phase sets the setpoint, the arbiter "
            "clamps it to %.0f W and names the clamp, and the drain phase has "
@@ -1473,7 +1494,9 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                TAXES_PROFILE_OPTION, negative)
            _advise(notes, "warn", (TAXES_PROFILE_OPTION,),
                    f"{S(TAXES_PROFILE_OPTION)} has negative figures, which "
-                    "lower the price, and that is usually a sign error.")
+                    "lower the price, and that is usually a sign error.",
+                    nl=f"{SN(TAXES_PROFILE_OPTION)} heeft negatieve bedragen, "
+                    "die de prijs verlagen, en dat is meestal een tekenfout.")

    # ⚠️ TARIFF-15: THE FORMULA, GRADED AGAINST THE OPERATOR'S OWN CARD, AT
    # STARTUP RATHER THAN AT 03:00.
@@ -1532,7 +1555,10 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
            _advise(notes, "warn", ("price_formula", "price_provider"),
                    f"{S('price_formula')} is not used, because "
                    f"{S('price_provider')} is not 'custom_formula', so clear "
-                    "it or choose that source.")
+                    "it or choose that source.",
+                    nl=f"{SN('price_formula')} wordt niet gebruikt, omdat "
+                    f"{SN('price_provider')} niet 'custom_formula' is, dus wis "
+                    "ze of kies die bron.")
        if spec is not None and pid == "custom_formula":
            taxes = _number(opts, "price_taxes_eur_kwh",
                            PRICE_OPTION_DEFAULTS["price_taxes_eur_kwh"])
@@ -1547,7 +1573,8 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                # cannot start.
                _LOG.warning("%s", aged)
                _advise(notes, "warn", ("price_formula",),
-                        _card_note("price_formula", spec))
+                        _card_note("price_formula", spec),
+                        nl=_card_note("price_formula", spec, "nl"))

    # ⚠️ TARIFF-16: THE INJECTION LEG, REFUSED AT STARTUP ON THE SAME RULE.
    #
@@ -1630,7 +1657,10 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                    xspec.offset_eur_kwh)
                _advise(notes, "info", (EXPORT_FORMULA_OPTION,),
                        f"{S(EXPORT_FORMULA_OPTION)} has no card block, so "
-                        "only the shape of its numbers is checked.")
+                        "only the shape of its numbers is checked.",
+                        nl=f"{SN(EXPORT_FORMULA_OPTION)} heeft geen kaartblok, "
+                        "dus alleen de vorm van de getallen wordt "
+                        "gecontroleerd.")
                _LOG.debug(
                    "Accepted because some suppliers (Eneco) print the "
                    "injection formula with no price beside it. If your card "
@@ -1643,7 +1673,8 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                if xaged:
                    _LOG.warning("%s", xaged)
                    _advise(notes, "warn", (EXPORT_FORMULA_OPTION,),
-                            _card_note(EXPORT_FORMULA_OPTION, xspec))
+                            _card_note(EXPORT_FORMULA_OPTION, xspec),
+                            nl=_card_note(EXPORT_FORMULA_OPTION, xspec, "nl"))

    # ⚠️ A WARNING, NOT A REFUSAL, AND THE ASYMMETRY IS DELIBERATE. §11.4 says a
    # site with no price data falls back to the static profile; a dynamic site
@@ -1657,13 +1688,16 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
            "fallback.", pid)
        _advise(notes, "warn", ("static_profile",),
                f"{S('static_profile')} is empty, so the site has no tariff "
-                "at all while the price feed is down.")
+                "at all while the price feed is down.",
+                nl=f"{SN('static_profile')} is leeg, dus de installatie heeft "
+                "helemaal geen tarief zolang de prijsfeed uitvalt.")

    # PRICE-01: not a fault, so an info note and no log line here (the add-on
    # logs it once at start). With `price_service` the fixed tariff is only the
    # plan's last fallback; the cheap window and the gate do not read it.
    if pid == "price_service" and str(opts.get("static_profile", "") or "").strip():
-        _advise(notes, "info", ("static_profile",), messages.FIXED_TARIFF_NOTE)
+        _advise(notes, "info", ("static_profile",), messages.FIXED_TARIFF_NOTE,
+                nl=messages.FIXED_TARIFF_NOTE_NL)

    # ⚠️ OPT-04. THE THREE WAYS `arbitrage_enabled: true` CAN BE A LIE, refused
    # rather than logged, because a strategy that is armed in the UI and cannot
@@ -1735,17 +1769,22 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
    return problems


-def _card_note(option: str, spec) -> str:
+def _card_note(option: str, spec, lang: str = "en") -> str:
+    if lang == "nl":
+        return (f"{SN(option)} gebruikt een tariefkaart van "
+                f"{spec.card_month}, dus neem de nieuwe cijfers over als uw "
+                "contract veranderde.")
    return (f"{S(option)} uses a tariff card dated {spec.card_month}, so copy "
            "the new figures if your contract changed.")


 # UX-13: entity options whose number the add-on takes as watts, with no unit
-# conversion. pv.py converts each solar entity's own unit, so those are not here.
+# conversion. pv.py converts each solar entity's own unit, so those are not here,
+# and SAFETY-118 moved the peak forecast there too.
 WATT_ENTITY_KEYS = (
    "meter_entity", "p1_net_entity", "p1_import_entity", "p1_export_entity",
    "p1_phase_net_entities", "p1_phase_import_entities",
-    "p1_phase_export_entities", "batt_entity", "peak_forecast_entity")
+    "p1_phase_export_entities", "batt_entity")


 # The meter entities each `meter_source` reads through Home Assistant.
@@ -1809,7 +1848,10 @@ def config_notes(opts: dict, *, entities: dict | None = None,
    if month_peak_w is not None and cap is not None and cap < month_peak_w:
        _advise(notes, "warn", ("peak_cap_w",),
                f"This month's peak is already {messages.watts(month_peak_w)}, "
-                f"so a lower {S('peak_cap_w')} saves nothing until next month.")
+                f"so a lower {S('peak_cap_w')} saves nothing until next month.",
+                nl=f"De piek van deze maand is al "
+                f"{messages.watts(month_peak_w)}, dus een lagere "
+                f"{SN('peak_cap_w')} bespaart niets tot volgende maand.")
    return notes


@@ -1822,27 +1864,43 @@ def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
        if row is None:
            _advise(notes, "bad" if key in bad else "warn", (key,),
                    f"Home Assistant has no entity {entity}, which "
-                    f"{S(key, where)} names.")
+                    f"{S(key, where)} names.",
+                    nl=f"Home Assistant kent {entity} niet, maar "
+                    f"{SN(key, where)} verwijst ernaar.")
            continue
        unit = str(row.get("unit") or "")
        if key in WATT_ENTITY_KEYS and unit in pv.WATTS_PER and unit != "W":
            _advise(notes, "warn", (key,),
                    f"{entity} reads in {unit}, but {S(key, where)} is "
-                    "taken as watts, so pick a sensor in W.")
+                    "taken as watts, so pick a sensor in W.",
+                    nl=f"{entity} meldt in {unit}, maar {SN(key, where)} wordt "
+                    "als watt gelezen, dus kies een sensor in W.")
+        if key == "peak_forecast_entity" and unit not in pv.WATTS_PER:
+            _advise(notes, "warn", (key,),
+                    messages.peak_forecast_unit(unit) + " Pick a sensor in "
+                    "W or kW.",
+                    nl=messages.peak_forecast_unit(unit, "nl")
+                    + " Kies een sensor in W of kW.")
        if key in FORECAST_KEYS and unit not in solarfc.KWH_PER:
            _advise(notes, "warn", (key,),
                    f"{entity} does not read in kWh, so pick a solar "
-                    "forecast sensor in kWh.")
+                    "forecast sensor in kWh.",
+                    nl=f"{entity} meet niet in kWh, dus kies een sensor voor "
+                    "de zonneprognose in kWh.")
    today = solarfc.entities(opts)
    tomorrow = solarfc.entities(opts, tomorrow=True)
    if (today or tomorrow) and \
            opts.get("battery_modes_enabled") is not True:
        _advise(notes, "info", ("pv_forecast_entity",),
-                "The solar forecast is used only with battery modes on.")
+                "The solar forecast is used only with battery modes on.",
+                nl="De zonneprognose wordt alleen gebruikt met batterijmodi "
+                "aan.")
    if tomorrow and not today:
        _advise(notes, "warn", ("pv_forecast_tomorrow_entity",),
                "Tomorrow's forecast is used only with today's, so set "
-                f"{S('pv_forecast_entity')} too.")
+                f"{S('pv_forecast_entity')} too.",
+                nl="De prognose voor morgen wordt alleen met die van vandaag "
+                f"gebruikt, dus stel ook {SN('pv_forecast_entity')} in.")


 # --------------------------------------------------------------------------- #
@@ -1921,7 +1979,9 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
    if entities is None:
        # Red: only the list can tell a missing power request entity (SAFETY-77).
        _advise(notes, "bad", ("setpoint_entity",), "Home Assistant is not "
-                "answering, so press Check again once it is back.")
+                "answering, so press Check again once it is back.",
+                nl="Home Assistant antwoordt niet, dus druk op Opnieuw "
+                "nakijken zodra het terug is.")
    else:
        # A missing meter entity is red too (UX-15): with the kettle test
        # skipped, nothing else on the way to the save would catch it.
@@ -1943,13 +2003,16 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
                solar.append(None)
                _advise(notes, "warn", ("pv_invert_entities",),
                        f"{entity} reads below zero now, so turn on its "
-                        "“Reads negative” switch in the Solar step.")
+                        "“Reads negative” switch in the Solar step.",
+                        nl=f"{entity} meet nu onder nul, dus zet de schakelaar "
+                        "“Meet negatief” aan bij de stap Zonnepanelen.")
            else:
                w = -w if entity in flipped else w
                solar.append(w)
                _advise(notes, "ok", ("pv_entity",),
                        f"{entity} reads {_signed(w)} of solar production "
-                        "now.")
+                        "now.",
+                        nl=f"{entity} meet nu {_signed(w)} zonneproductie.")
    # A battery sensor that reads the wrong way while giving power makes the
    # house use less than nothing. Only with every term known: a missing
    # solar reading could be the difference.
@@ -1959,7 +2022,10 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
        _advise(notes, "warn", ("batt_invert",),
                f"The readings add up to {_signed(sum(known))} of house "
                "use, so check each "
-                "battery's “Battery power sign is reversed” switch in step 2.")
+                "battery's “Battery power sign is reversed” switch in step 2.",
+                nl=f"De metingen tellen op tot {_signed(sum(known))} "
+                "huisverbruik, dus controleer bij elke batterij de schakelaar "
+                "“Teken batterijvermogen omkeren” in stap 2.")
    _price_check(notes, opts, running, prices_known)
    return notes

@@ -1983,7 +2049,9 @@ def _meter_check(notes, opts, entities, running, meter_now_w):
            return float(meter_now_w)
        _advise(notes, "info", ("meter_source",), "The add-on reads "
                "this meter itself, so Home shows its reading after "
-                "the restart.")
+                "the restart.",
+                nl="De add-on leest deze meter zelf, dus Start toont de "
+                "meting na de herstart.")
        return None
    if entities is None:
        return None
@@ -1996,7 +2064,9 @@ def _meter_check(notes, opts, entities, running, meter_now_w):
        if w is None:
            _advise(notes, "warn", ("meter_source",),
                    f"{entity} reads {text} now, so check it in Home "
-                    "Assistant before you start.")
+                    "Assistant before you start.",
+                    nl=f"{entity} meldt nu {text}, dus controleer ze in Home "
+                    "Assistant voor u start.")
            return None
        total += sign * w
    if source == "off" and opts.get("meter_invert"):
@@ -2007,12 +2077,14 @@ def _meter_check(notes, opts, entities, running, meter_now_w):

 def _meter_line(notes, w) -> None:
    if abs(w) < 1.0:
-        text = "The meter reads 0 W now."
+        text, nl = "The meter reads 0 W now.", "De meter meldt nu 0 W."
    elif w > 0:
        text = f"The meter reads {messages.watts(w)} taken from the grid now."
+        nl = f"De meter meldt nu {messages.watts(w)} afname van het net."
    else:
        text = f"The meter reads {messages.watts(w)} fed into the grid now."
-    _advise(notes, "ok", ("meter_source",), text)
+        nl = f"De meter meldt nu {messages.watts(w)} injectie op het net."
+    _advise(notes, "ok", ("meter_source",), text, nl=nl)


 def _card_checks(notes, who, entry, entities):
@@ -2020,40 +2092,55 @@ def _card_checks(notes, who, entry, entities):
    positive while giving power, or None when it is not known."""
    if entities is None:
        return None
+    wie = who.replace(" for ", " voor ", 1)
    setpoint = str(entry.get("setpoint_entity") or "").strip()
    if setpoint and setpoint in entities:
        _advise(notes, "ok", ("setpoint_entity",),
                f"Home Assistant has {setpoint}, the power request "
-                f"entity{who}.")
+                f"entity{who}.",
+                nl=f"Home Assistant heeft {setpoint}, de entiteit voor de "
+                f"vermogensvraag{wie}.")
    soc = str(entry.get("soc_entity") or "").strip()
    if not soc:
        _advise(notes, "warn", ("soc_entity",), f"There is no battery "
                f"level entity{who}, so pick one in step 2 or the add-on "
-                "holds 0 W.")
+                "holds 0 W.",
+                nl=f"Er is geen entiteit voor het laadniveau{wie}, dus kies er "
+                "een in stap 2 of de add-on houdt 0 W aan.")
    elif soc in entities:
        level, _unit = _reading(entities, soc)
        if level is None or not 0.0 <= level <= 100.0:
            _advise(notes, "warn", ("soc_entity",), f"The battery "
-                    f"level{who} reads nothing now, so check {soc}.")
+                    f"level{who} reads nothing now, so check {soc}.",
+                    nl=f"Het laadniveau{wie} meldt niets, dus controleer "
+                    f"{soc}.")
        else:
            _advise(notes, "ok", ("soc_entity",),
-                    f"The battery level{who} reads {level:.0f} %.")
+                    f"The battery level{who} reads {level:.0f} %.",
+                    nl=f"Het laadniveau{wie} meldt {level:.0f} %.")
    batt = str(entry.get("batt_entity") or "").strip()
    if batt and batt in entities:
        w, _unit = _reading(entities, batt)
        if w is None:
            _advise(notes, "warn", ("batt_entity",), f"The battery "
-                    f"power{who} reads nothing now, so check {batt}.")
+                    f"power{who} reads nothing now, so check {batt}.",
+                    nl=f"Het batterijvermogen{wie} meldt niets, dus controleer "
+                    f"{batt}.")
            return None
        w = -w if entry.get("batt_invert") else w
        if abs(w) < IDLE_W:
            _advise(notes, "info", ("batt_entity",), f"The battery{who} is "
-                    "idle now, so check its direction on Home later.")
+                    "idle now, so check its direction on Home later.",
+                    nl=f"De batterij{wie} staat nu stil, dus controleer later "
+                    "op Start de richting.")
        else:
            doing = "giving power" if w > 0 else "charging"
+            doet = "levert" if w > 0 else "laadt"
            _advise(notes, "info", ("batt_invert",),
                    f"The battery{who} reads {messages.watts(w)} {doing} "
-                    "now, so check the inverter shows the same.")
+                    "now, so check the inverter shows the same.",
+                    nl=f"De batterij{wie} {doet} nu {messages.watts(w)}, dus "
+                    "controleer of de omvormer hetzelfde toont.")
        return w
    return None

@@ -2065,20 +2152,28 @@ def _price_check(notes, opts, running, prices_known) -> None:
        if profile:
            _advise(notes, "ok", ("static_profile",),
                    "Your prices come from your contract, so they are "
-                    "always known.")
+                    "always known.",
+                    nl="Uw prijzen komen uit uw contract, dus ze zijn altijd "
+                    "bekend.")
        else:
            _advise(notes, "info", ("price_provider",),
                    "No prices are set, so the batteries do not charge "
-                    "on price.")
+                    "on price.",
+                    nl="Er zijn geen prijzen ingesteld, dus de batterijen "
+                    "laden niet op prijs.")
        return
    same = (isinstance(running, dict)
            and str(running.get("price_provider") or "") == provider)
    if same and prices_known:
        _advise(notes, "ok", ("price_provider",),
-                f"Prices for today are in, for {prices_known} of 24 hours.")
+                f"Prices for today are in, for {prices_known} of 24 hours.",
+                nl=f"De prijzen van vandaag zijn binnen, voor {prices_known} "
+                "van 24 uur.")
    else:
        _advise(notes, "info", ("price_provider",),
-                "Prices are fetched after the restart, and Home shows them.")
+                "Prices are fetched after the restart, and Home shows them.",
+                nl="De prijzen worden na de herstart opgehaald, en Start toont "
+                "ze.")


 def _margin_problems(opts: dict) -> list[str]:
@@ -50,8 +50,8 @@ from aiohttp import web

 from . import messages, price, selfconfig, uipage, uitext
 from .haentities import EntityCache
-from .homeview import region_of
-from .validate import config_notes, setup_checks
+from .homeview import priced_hours, region_of
+from .validate import config_notes, note_text, setup_checks
 from .config_page import CONFIG_PAGE
 from .configui import (changed_keys, field_model, hide_secrets, keep_secrets,
                       problems_by_field, secret_keys)
@@ -105,6 +105,9 @@ def page() -> str:
 DEVICE_NOTE = (
    "%s did not report its power range, so two checks were skipped, here and "
    "at start. If they fail later, the add-on will not start then.")
+DEVICE_NOTE_NL = (
+    "%s meldde geen vermogensbereik, dus twee controles zijn overgeslagen, "
+    "hier en bij het starten. Falen ze later, dan start de add-on niet.")


 def build_app(controller, selfcfg=None) -> web.Application:
@@ -301,22 +304,27 @@ def build_app(controller, selfcfg=None) -> web.Application:
        # UX-13: warnings and info beside the refusals. Never block a save.
        # The entity checks use the picker's cached list and never wait on HA.
        notes += config_notes(options, entities=entities.peek())
+        # UX-46: one language choice for everything below that has words.
+        lang = uitext.lang_of(_body.get("lang"))
        payload = {"problems": problems, "by_key": by_key,
                   "unanchored": unanchored,
                   "notes": [n._asdict() for n in notes]}
        if unread:
-            payload["device_note"] = DEVICE_NOTE % ", ".join(sorted(set(unread)))
+            payload["device_note"] = (DEVICE_NOTE_NL if lang == "nl"
+                                      else DEVICE_NOTE) % ", ".join(
+                                          sorted(set(unread)))
        if model is not None:
            payload["messages"] = (
                uipage.derive_messages(errors, problems, notes, model,
-                                       _keys_of(options),
-                                       uitext.lang_of(_body.get("lang")))
+                                       _keys_of(options), lang)
                if errors
                else uipage.anchors(problems, notes, model, _keys_of(options),
-                                    uitext.lang_of(_body.get("lang"))))
+                                    lang))
            payload["steps"] = uipage.step_problems(payload["messages"], model)
        if _body.get("setup"):
-            payload["setup"] = [n._asdict() for n in await _setup_checks(options)]
+            payload["setup"] = [
+                dict(n._asdict(), text=note_text(n, lang))
+                for n in await _setup_checks(options)]
        return web.json_response(payload)

    async def _setup_checks(options):
@@ -328,7 +336,7 @@ def build_app(controller, selfcfg=None) -> web.Application:
        try:
            prices = (controller.status_payload().get("plan") or {}).get(
                "prices") or []
-            known = sum(1 for p in prices if p.get("eur_kwh") is not None)
+            known = priced_hours(prices)
        except Exception:  # noqa: BLE001 - a display figure, never a failure
            known = None
        return setup_checks(options, entities=rows, running=controller.o,
@@ -1,9 +1,9 @@
 name: GoodWe RS485 Controller
-version: "0.18.1"
+version: "0.18.2"
 slug: goodwe_controller
 description: >-
-  Drives a GoodWe ES/BP battery inverter over RS485 by emulating its smart
-  meter, holding net grid exchange at zero and running a monthly battery
+  Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a
+  grid reading, holding net grid exchange at zero and running a monthly battery
  maintenance cycle.
 url: https://gittea.kammenstraatha.duckdns.org/admin/goodwe-addon
 arch:
@@ -109,6 +109,11 @@ from app.validate import validate_startup_config

 UTC = timezone.utc
 HERE = os.path.dirname(os.path.abspath(__file__))
+
+# PRICE-02: `TariffPlan.arbitrage(now=...)` is required. This instant is before every
+# point these fixtures build, so no period has ended and the whole series counts.
+from datetime import datetime as _DT, timezone as _TZ  # noqa: E402
+LONG_AGO = _DT(2000, 1, 1, tzinfo=_TZ.utc)
 fails = []


@@ -194,13 +199,22 @@ NO_WEATHER = frozenset({Uncertainty.NO_WEATHER})


 def plan_of(prices, *, product=PriceProduct.DAY_AHEAD, start=D0,
-            provisional=False, provider="generic_dayahead"):
+            provisional=False, provider="generic_dayahead", days=2):
    """A TariffPlan over consecutive hourly prices starting at `start`.

    `provisional` may be a single bool or a per-hour sequence.
+
+    PRICE-02: the verdict skips price periods that have ended, so a plan
+    probed at 18:30 no longer sees the cheap hour at 03:00 of the same day. A
+    running site holds 24-48 h, so `days=2` repeats the day (tomorrow's
+    prices are today's): probes in day one keep their extremes, and the
+    first cheapest/dearest hour still ahead is today's. Pass `days=1` for a
+    plan that must be exactly the given hours.
    """
+    prices = list(prices) * days
    flags = ([bool(provisional)] * len(prices)
-             if isinstance(provisional, bool) else list(provisional))
+             if isinstance(provisional, bool)
+             else list(provisional) * days)
    pts = [PricePoint(start=brussels(start + timedelta(hours=i)),
                      eur_per_kwh=round(float(p), 6), provisional=f)
           for i, (p, f) in enumerate(zip(prices, flags))]
@@ -344,7 +358,7 @@ check(f"a realistic Belgian day/night profile has a spread of "
      f"{_st_spread!r} EUR/kWh - the number the product decision is about",
      near(_st_spread, 0.08))
 _shipped = PRICE_OPTION_DEFAULTS["cycle_cost_threshold_eur"]
-_st_verdict = derived(lambda: _st_plan.arbitrage(
+_st_verdict = derived(lambda: _st_plan.arbitrage(now=LONG_AGO,
    peak_guard_active=False, min_spread_eur_kwh=_shipped,
    uncertainty=NO_WEATHER))
 check(f"...and at the SHIPPED threshold of {_shipped} EUR/kWh that site does "
@@ -361,7 +375,7 @@ check(f"...and it is the SPREAD rung that refuses it, not a flat-tariff or a "
 check("...while the SAME site trades once the threshold is set below its "
      "spread, so the refusal above is about the number and not about static "
      "tariffs being unsupported",
-      derived(lambda: _st_plan.arbitrage(
+      derived(lambda: _st_plan.arbitrage(now=LONG_AGO,
          peak_guard_active=False,
          min_spread_eur_kwh=_st_spread / widen_factor(NO_WEATHER) - 1e-4,
          uncertainty=NO_WEATHER).kind) == "allowed")
@@ -1644,7 +1658,7 @@ check("a FULLY carried series trades nothing at all, whatever its spread - "
 # standing if a future caller ever hands `_act` a plan the verdict did not come
 # from.
 _probe = _arb._point_at(PLAN, hour(CHEAP_H))
-_verdict = PLAN.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0,
+_verdict = PLAN.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0,
                          uncertainty=frozenset())
 check("the point matched for the buy hour IS the verdict's own cheapest point, "
      "by identity - which is why `_act`'s provisional guard is unreachable "
@@ -1665,6 +1679,14 @@ print("4b. §10.2 hysteresis - a price on the boundary cannot flap at 30 s")
 # threshold repeatedly, hour to hour, which is the shape that makes a
 # per-tick price-vs-threshold comparison flap.
 FLAP = [0.20 + (0.101 if i % 2 else 0.0) for i in range(24)]
+# PRICE-02: the verdict skips periods that have ended, and this day had ties
+# (0.20 at every even hour, 0.301 at every odd one). With ties the first hour
+# still ahead is the extreme, so the verdict moves on every hour - once per
+# hour, never per tick, which test_price02.py part 6 grades. This check is
+# about a verdict that stays put while the prices keep crossing the threshold,
+# so the day gets one cheapest and one dearest hour at its end (22: 0.60,
+# 23: 0.05), unique and ahead of every probe until they come.
+FLAP[22], FLAP[23] = 0.60, 0.05
 _flap_plan = plan_of(FLAP)
 check("the flapping fixture really does straddle the threshold hour by hour - "
      "every neighbouring pair differs by more than it",
@@ -1846,7 +1868,15 @@ def replay(threshold, unc, *, soc0=50.0, floor=20.0, ceiling=95.0):
    neg_sells = 0
    for n in range(365):
        day0 = REPLAY_START + timedelta(days=n)
-        prices = synth_day(n)
+        # PRICE-02: no two hours share a price. The synthetic day is
+        # symmetric, so it prints the same maximum twice; the verdict now takes
+        # the first one still AHEAD, where it used to take the first of the
+        # day (a tie, graded on its own in test_price02.py part 6). So the
+        # ties are broken by a jitter of at most 5e-5 EUR/kWh that has no
+        # direction: not later-is-dearer, which would send every day to a
+        # buy-then-sell and hide the selectivity this replay checks.
+        prices = [round(p + 1e-6 * ((37 * h + 101 * n) % 50), 6)
+                  for h, p in enumerate(synth_day(n))]
        plan = plan_of(prices, start=day0)
        open_buy = None
        for h in range(24):
@@ -2056,18 +2086,26 @@ check(f"BUT NOT ONE OF THE 365 DAYS HAS A NEGATIVE DEAREST HOUR "
 def replay_real(days, threshold, unc, *, soc0=50.0, floor=20.0, ceiling=95.0):
    """The shipped `decide()` over the real year. Returns the ledger, nothing else.

-    One `TariffPlan` per Brussels day, so "the cheapest hour" means the cheapest
-    hour of that day - the same shape as section 7's replay, and the same shape
-    a site with a day-ahead feed actually sees.
+    The plan is built the way production builds it: one per hour, from that
+    hour (the refresh floors to the hour) to the end of the Brussels day,
+    plus the next day from 13:00 Brussels, when the day-ahead prices are
+    published. So a site sees 11 to 35 hours ahead, never a whole day behind
+    it and never a day on its own. (An earlier version built one plan per
+    calendar day with no tomorrow: after the cheap hour no cheap hour was left
+    ahead, and the ledger shrank to a few trades that no real site would see.)
+    An open buy is kept over midnight: with tomorrow in view most buys are
+    sold the next day or later (46 of 51 at the shipped threshold).
    """
    soc = soc0
    trades, holdings, bad, neg_sells = [], [], [], 0
-    for day in days:
-        plan = TariffPlan(
-            PriceRead.series(day, PriceProduct.DAY_AHEAD, "generic_dayahead",
-                             day[0].start), None, "provider")
-        open_buy = None
-        for p in day:
+    open_buy = None
+    for di, day in enumerate(days):
+        nxt = days[di + 1] if di + 1 < len(days) else []
+        for i, p in enumerate(day):
+            ahead = day[i:] + (nxt if brussels(p.start).hour >= 13 else [])
+            plan = TariffPlan(
+                PriceRead.series(ahead, PriceProduct.DAY_AHEAD,
+                                 "generic_dayahead", p.start), None, "provider")
            d = decide(plan, p.start + timedelta(minutes=30),
                       peak_guard_active=False, soc=soc,
                       min_spread_eur_kwh=threshold, uncertainty=unc,
@@ -2444,7 +2482,7 @@ check("...and every one of its points is provisional, so firm_points() is "
      "a fresh observation",
      isinstance(_t12_fb, TariffPlan) and _t12_fb.provisional is True
      and _t12_fb.firm_points() == ()
-      and _t12_fb.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0,
+      and _t12_fb.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0,
                            uncertainty=NO_WEATHER).kind == "refused")
 _t12_f.tariff_plan, _t12_f.tariff_at = _t12_good, datetime.now(UTC) - \
    timedelta(seconds=1800)
@@ -2789,7 +2827,7 @@ check(f"the shipped rule and this one give DIFFERENT points at both probes - "

 print()
 print("10b. the buy/sell identity test matches the actual extremum interval")
-_qv = QPLAN.arbitrage(peak_guard_active=False, min_spread_eur_kwh=_shipped,
+_qv = QPLAN.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=_shipped,
                      uncertainty=NO_WEATHER)
 check("the verdict's cheapest and dearest are the two QUARTERS, not the hours "
      "containing them - `static_tariff` reduces over every firm point and "
@@ -2921,7 +2959,7 @@ check(f"...and its firm half's extremes are quarters {_mix_cheap_i} and "
      f"{_mix_dear_i}, neither on a whole hour, so the identity test below is "
      f"about the quarter and not about the hour",
      (_mix_cheap_i - MIX_N_H) % 4 != 0 and (_mix_dear_i - MIX_N_H) % 4 != 0)
-_mv = MIX_PLAN.arbitrage(peak_guard_active=False, min_spread_eur_kwh=_shipped,
+_mv = MIX_PLAN.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=_shipped,
                         uncertainty=NO_WEATHER)
 _mix_buy_t = qprobe(_mix_cheap_i, gaps=MIX_GAPS)
 _mix_sell_t = qprobe(_mix_dear_i, gaps=MIX_GAPS)
@@ -2933,14 +2971,19 @@ check("the verdict over a MIXED series still names firm quarters, and "
      is MIX_PTS[_mix_cheap_i]
      and derived(lambda: _arb._point_at(MIX_PLAN, _mix_sell_t))
      is MIX_PTS[_mix_dear_i])
+# PRICE-02: the same day twice, as a running site holds 24-48 h (see plan_of).
+# The probes stay in day one and keep their extremes: once the cheap quarter is
+# over, the verdict at the dear quarter needs a cheap one still ahead.
+MIX2_PLAN = qplan_of(MIX_PRICES * 2, provisional=MIX_FLAGS * 2,
+                     gaps=MIX_GAPS + [900] + MIX_GAPS)
 check("...so the mixed day CHARGES and DISCHARGES in its firm quarters, at "
      "their own prices",
-      decide(MIX_PLAN, _mix_buy_t, peak_guard_active=False, soc=50.0,
+      decide(MIX2_PLAN, _mix_buy_t, peak_guard_active=False, soc=50.0,
             min_spread_eur_kwh=_shipped, uncertainty=NO_WEATHER,
             charge_headroom_w=HEADROOM_CLEAR,
                charge_w=MAX_W, discharge_w=MAX_W, soc_floor_pct=20.0,
             soc_ceiling_pct=95.0).action == CHARGE
-      and decide(MIX_PLAN, _mix_sell_t, peak_guard_active=False, soc=50.0,
+      and decide(MIX2_PLAN, _mix_sell_t, peak_guard_active=False, soc=50.0,
                 min_spread_eur_kwh=_shipped, uncertainty=NO_WEATHER,
                 charge_headroom_w=HEADROOM_CLEAR,
                charge_w=MAX_W, discharge_w=MAX_W, soc_floor_pct=20.0,
@@ -33,7 +33,9 @@ from app import homeview, web
 from app.main import Controller
 from app.peakguard import PeakDecision
 from app.price import PricePoint, PriceProduct, PriceRead
-from app.static_tariff import TariffPlan
+from app.static_tariff import TariffPlan, static_plan
+from app import packmode
+from app.store import unit_key
 from app.uimodel import REGION_PRESETS
 from named_absence import field, nth, present

@@ -152,6 +154,14 @@ def quiet_guard(projected_w=1240.0):
                        ceiling_from="cap", projected_w=projected_w)


+def set_modes(c, *modes):
+    """File each battery's mode in the store (None leaves the default, which
+    follows the house)."""
+    for inv, m in zip(c.inverters, modes):
+        if m is not None:
+            c.store.data[unit_key(inv.name, packmode.MODE_KEY)] = m
+
+
 def status(c, now=NOW):
    s = c.status_payload()
    # The status route builds at wall-clock time; rebuild the structured half
@@ -254,7 +264,7 @@ check("trading on price: a charge block at the cheapest hour (13:00) and a "
 check("...placed where the control cycle's own verdict puts them: the same "
      "plan.arbitrage() call on the same plan",
      c_arb.fresh_tariff_plan(NOW).arbitrage(
-          peak_guard_active=False, min_spread_eur_kwh=0.05,
+          now=NOW, peak_guard_active=False, min_spread_eur_kwh=0.05,
          uncertainty=frozenset({__import__("app.price", fromlist=["x"])
                                 .Uncertainty.NO_WEATHER}))
      .match(allowed=lambda v: (v.cheapest.start, v.dearest.start),
@@ -317,7 +327,7 @@ check("a plan with no published prices yet says so, not 'the price gap is "
      _t == [] and homeview.line_no_trade("not_firm") in _l
      and homeview.line_no_trade("not_worth") not in _l)
 check("the price bars are today's 24 hours, from the real series, with the "
-      "cheap and expensive thirds marked",
+      "cheap and dear hour marked",
      [b["eur_kwh"] for b in s_arb["plan"]["prices"]] == MOCK
      and s_arb["plan"]["prices"][13]["kind"] == "cheap"
      and s_arb["plan"]["prices"][19]["kind"] == "dear"
@@ -518,10 +528,269 @@ check("quarter-hour prices: the charge block, its price and the price line's "
      and f"Today: lowest €{_lo.eur_per_kwh:.2f} at "
          f"{homeview.hhmm(_lo.start)}," in s_q["plan"]["price_line"]
      and "the list" not in json.dumps(s_q["plan"]))
-check("...and the hour bar says it is an hour average",
-      s_q["plan"]["prices"][13]["points"] == 4
-      and '"plan.average_tip"' in io.open(os.path.join(
-          HERE, "app", "static", "app.js"), encoding="utf-8").read())
+
+# UX-45: the chart draws the steps the add-on decides on.
+_pq = s_q["plan"]["prices"]
+check("UX-45: 96 quarter prices -> 96 bars, each one quarter, labelled "
+      "from its own start, with its own price and no average",
+      len(_pq) == 96 and _pq[0]["label"] == "00:00"
+      and _pq[0]["end_label"] == "00:15" and _pq[57]["label"] == "14:15"
+      and _pq[57]["end_label"] == "14:30"
+      and [b["eur_kwh"] for b in _pq] == [round(p.eur_per_kwh, 4)
+                                          for p in _q[:96]]
+      and all("points" not in b for b in _pq)
+      and s_q["plan"]["hours"] == 24)
+check("...the quarters of one hour differ (the chart shows the steps)",
+      len({b["eur_kwh"] for b in _pq[52:56]}) > 1)
+check("...and the page has no 'hour average' tip any more",
+      "average_tip" not in io.open(os.path.join(
+          HERE, "app", "static", "app.js"), encoding="utf-8").read()
+      and "average_tip" not in io.open(os.path.join(
+          HERE, "app", "ui_text", "en.json"), encoding="utf-8").read()
+      and "average_tip" not in io.open(os.path.join(
+          HERE, "app", "ui_text", "nl.json"), encoding="utf-8").read())
+_cheap_q = [b["start"] for b in _pq if b["kind"] == "cheap"]
+_dear_q = [b["start"] for b in _pq if b["kind"] == "dear"]
+_hi = max(_q[:96], key=lambda p: p.eur_per_kwh)
+check("...without battery modes the marks are the two quarters the "
+      "arbitrage verdict trades in, and no others",
+      _cheap_q == [_lo.start.isoformat()] and _dear_q == [_hi.start.isoformat()]
+      and sum(1 for b in _pq if b["kind"] == "mid") == 94)
+
+# Battery modes on: the marks ARE the kept priceruns result.
+from app import priceruns
+_rp = priceruns.plan(tuple(_q), NOW, required_eur_kwh=0.05, charge_kwh=2.0,
+                     charge_kw=4.0, sell_kwh=0.0, sell_kw=0.0)
+c_m = make(ARB)
+c_m.tariff_plan, c_m.tariff_at = c_q.tariff_plan, NOW
+c_m.peak_guard = quiet_guard()
+c_m.modes_on, c_m.mode_runs = True, _rp
+set_modes(c_m, packmode.SOLAR_FIRST, packmode.CHEAP_HOURS)
+_pm = status(c_m)["plan"]["prices"]
+_today = [(a, z) for a, z, _p in priceruns.firm_slots(_q, NOW)
+          if a < DAY0 + timedelta(hours=24)]
+_want_c = {a.isoformat() for a, z in _today
+           if _rp.cheap.start <= a < _rp.cheap.end}
+_want_d = {a.isoformat() for g in _rp.give for a, z in _today
+           if g.start <= a < g.end}
+check("UX-45: with battery modes on, the cheap and dear quarters are the "
+      "priceruns cheap run and give runs for the same input",
+      _rp.on and _rp.charge_useful() and _want_c and _want_d
+      and {b["start"] for b in _pm if b["kind"] == "cheap"} == _want_c
+      and {b["start"] for b in _pm if b["kind"] == "dear"} == _want_d
+      and len(_pm) == 96)
+c_m2 = make(ARB)
+c_m2.tariff_plan, c_m2.tariff_at = c_q.tariff_plan, NOW
+c_m2.peak_guard = quiet_guard()
+c_m2.modes_on = True
+set_modes(c_m2, packmode.CHEAP_HOURS, None)
+c_m2.mode_runs = priceruns.plan(tuple(_q), NOW, required_eur_kwh=5.0,
+                                charge_kwh=2.0, charge_kw=4.0, sell_kwh=0.0,
+                                sell_kw=0.0)
+check("...a run plan that says no trade marks nothing",
+      not c_m2.mode_runs.on
+      and {b["kind"] for b in status(c_m2)["plan"]["prices"]} == {"mid"})
+
+# A quarter that is over keeps the mark it had while it was ahead.
+# (`status()` also builds at wall-clock time, which starts the day's memory
+# over, so the two builds below go straight to `homeview.build`.)
+_later = NOW + timedelta(hours=4)
+_s0 = c_q.status_payload()
+homeview.build(c_q, level=_s0["level"], checks=_s0["checks"], now=NOW)
+c_q.tariff_at = _later
+_pl = homeview.build(c_q, level=_s0["level"], checks=_s0["checks"],
+                     now=_later)["plan"]["prices"]
+check("...and a quarter already over keeps the mark it had while ahead",
+      [b["kind"] for b in _pl if b["start"] == _lo.start.isoformat()]
+      == ["cheap"]
+      and [b["kind"] for b in _pl if b["label"] == "19:00"] == ["dear"])
+c_q.tariff_at = NOW
+
+# UX-45 round 2 (F2): a hole is covered by the add-on's own rule,
+# `price._cover_table()`: the point before it runs on, never over an hour.
+def _hole_bars(missing):
+    pts = [PricePoint(DAY0 + timedelta(minutes=15 * i), .10 + .001 * i, False)
+           for i in range(96)]
+    gone = {DAY0 + timedelta(hours=10, minutes=15 * (1 + j))
+            for j in range(missing)}
+    pts = [p for p in pts if p.start not in gone]
+    return homeview.price_bars(pts, DAY0, DAY0 + timedelta(hours=24))
+
+
+_gap = {}
+for _n in (1, 2, 3, 4, 5):
+    _bb = _hole_bars(_n)
+    _gap[_n] = ([b["eur_kwh"] is None for b in _bb[41:41 + _n]],
+                len(_bb))
+_b1 = _hole_bars(1)
+check("UX-45: 1, 2 or 3 missing quarters show the price before them (the "
+      "add-on's own cover rule), and nothing shifts",
+      all(len(_hole_bars(n)) == 96 for n in (1, 2, 3))
+      and _gap[1][0] == [False] and _gap[2][0] == [False, False]
+      and _gap[3][0] == [False, False, False]
+      and [b["eur_kwh"] for b in _hole_bars(3)[40:44]]
+      == [_hole_bars(3)[40]["eur_kwh"]] * 4
+      and _b1[42]["label"] == "10:30" and _b1[43]["label"] == "10:45"
+      and _b1[43]["eur_kwh"] == round(.10 + .001 * 43, 4))
+check("...4 missing quarters leave 1 bar empty, 5 leave 2: a hole over an "
+      "hour is not filled past the hour",
+      _gap[4][0] == [False, False, False, True]
+      and _gap[5][0] == [False, False, False, True, True]
+      and sum(b["eur_kwh"] is None for b in _hole_bars(4)) == 1
+      and sum(b["eur_kwh"] is None for b in _hole_bars(5)) == 2)
+
+# A cheap run that is not worth charging in is not marked; an estimate is.
+import types
+_pts = [PricePoint(DAY0 + timedelta(minutes=15 * i),
+                   .30 if i < 4 else .10, False) for i in range(8)]
+_rp2 = priceruns.plan(tuple(_pts), DAY0, required_eur_kwh=0.05,
+                      charge_kwh=0.5, charge_kw=4.0, sell_kwh=0.0, sell_kw=0.0)
+c_w2 = make(ARB)
+c_w2.modes_on, c_w2.mode_runs = True, _rp2
+set_modes(c_w2, packmode.LEFTOVER_SOLAR, None)
+_w2 = homeview.price_windows(c_w2, None, None)
+check("UX-45: a cheap run that comes after every dear slot is not worth a "
+      "charge, so it is not marked (the dear run is)",
+      _rp2.on and _rp2.cheap is not None and not _rp2.charge_useful()
+      and [w[0] for w in _w2] == ["dear"])
+_est = [PricePoint(DAY0 + timedelta(minutes=15 * i), .2, False)
+        for i in range(80)] + [PricePoint(DAY0 + timedelta(hours=20), .25,
+                                          True)]
+_be = homeview.price_bars(_est, DAY0, DAY0 + timedelta(hours=24))
+check("UX-45: a carried (estimate) price after quarter prices is the last "
+      "point, so it covers one quarter (the add-on's tail rule), as an "
+      "estimate bar; the rest stays empty",
+      [b["estimate"] for b in _be[78:83]] == [False, False, True, False, False]
+      and _be[80]["eur_kwh"] == .25 and _be[81]["eur_kwh"] is None)
+_est2 = _est[:80] + [PricePoint(DAY0 + timedelta(hours=20 + k), .25, True)
+                     for k in range(3)]
+_be2 = homeview.price_bars(_est2, DAY0, DAY0 + timedelta(hours=24))
+check("...carried hourly points one after another cover an hour each",
+      [b["eur_kwh"] for b in _be2[80:92]] == [.25] * 12
+      and _be2[92]["eur_kwh"] is None)
+
+# Hourly prices -> 24 bars (above); a day/night tariff -> 24 bars.
+_ph1 = s_arb["plan"]["prices"]
+check("UX-45: hourly prices -> 24 hour bars with the hour's own price",
+      len(_ph1) == 24 and _ph1[13]["end_label"] == "14:00"
+      and "points" not in _ph1[13])
+c_dn = make(dict(ARB, static_profile=(
+    '{"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}]}')))
+c_dn.peak_guard = quiet_guard()
+_pd = status(c_dn)["plan"]["prices"]
+check("UX-45: a day/night tariff -> 24 bars, 0.26 at night and 0.34 by day",
+      len(_pd) == 24
+      and [b["eur_kwh"] for b in _pd]
+      == [.26] * 7 + [.34] * 15 + [.26] * 2
+      and all(b["kind"] == "mid" for b in _pd))
+
+# Clock-change days: 92 and 100 quarters.
+_d0 = datetime(2026, 3, 28, 23, 0, tzinfo=timezone.utc)
+_d1 = datetime(2026, 3, 29, 22, 0, tzinfo=timezone.utc)
+_sp = [PricePoint(_d0 + timedelta(minutes=15 * i), .1, False)
+       for i in range(92)]
+check("UX-45: a 23-hour day has 92 quarter bars, a 25-hour day 100",
+      len(homeview.price_bars(_sp, _d0, _d1)) == 92
+      and len(homeview.price_bars(
+          _sp, _d0, _d0 + timedelta(hours=25))) == 100)
+
+_f0 = datetime(2026, 10, 24, 22, 0, tzinfo=timezone.utc)   # 25-hour day
+_fb = [PricePoint(_f0 + timedelta(minutes=15 * i), .1, False)
+       for i in range(100)]
+
+# F5: the day/night chart with the stored static plan, as in production
+# (the cycle stores `static_plan()` when the provider is off).
+_PROF = ('{"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}]}')
+
+
+def _dn(arb):
+    c = make(dict(ARB if arb else TWO, static_profile=_PROF))
+    c.peak_guard = quiet_guard()
+    c.tariff_plan = static_plan(c.o, NOW, NOW + timedelta(hours=36), now=NOW)
+    c.tariff_at = NOW
+    return c, status(c)["plan"]["prices"]
+
+
+_c_off, _p_off = _dn(False)
+_c_on, _p_on = _dn(True)
+_v_on, _why_on = homeview.trade_verdict(_c_on, _c_on.fresh_tariff_plan(NOW), NOW)
+check("UX-45: day/night tariff with the stored plan and price trading off: "
+      "24 bars, no cheap or dear mark",
+      len(_p_off) == 24 and {b["kind"] for b in _p_off} == {"mid"})
+check("...and with price trading on, the marks are the verdict's cheapest "
+      "and dearest hour (one each)",
+      _v_on is not None and len(_p_on) == 24
+      and [datetime.fromisoformat(b["start"]) for b in _p_on
+           if b["kind"] == "cheap"] == [_v_on.cheapest.start]
+      and [datetime.fromisoformat(b["start"]) for b in _p_on
+           if b["kind"] == "dear"] == [_v_on.dearest.start]
+      and sum(b["kind"] == "mid" for b in _p_on) == 22)
+
+# F3 / owner decision 2a: with battery modes on, marks only when a battery
+# uses a price mode.
+def _modes(*modes, use=(True, True)):
+    c = make(ARB)
+    c.tariff_plan, c.tariff_at = c_q.tariff_plan, NOW
+    c.peak_guard = quiet_guard()
+    c.modes_on, c.mode_runs = True, _rp
+    set_modes(c, *modes)
+    for inv, u in zip(c.inverters, use):
+        c.store.data[unit_key(inv.name, packmode.USE_KEY)] = u
+    return {b["kind"] for b in status(c)["plan"]["prices"]}
+
+
+_F, _L, _C = (packmode.SOLAR_FIRST, packmode.LEFTOVER_SOLAR,
+              packmode.CHEAP_HOURS)
+check("UX-45: battery modes on, every battery follows the house: no marks",
+      _modes(_F, _F) == {"mid"} and _modes(None, None) == {"mid"})
+check("...one battery on Cheap hours or Leftover solar: the marks show",
+      {"cheap", "dear"} <= _modes(_F, _C) and {"cheap", "dear"} <= _modes(_L, _F))
+check("...a price mode on a battery that is switched off does not count",
+      _modes(_F, _C, use=(True, False)) == {"mid"}
+      and {"cheap", "dear"} <= _modes(_F, _C, use=(False, True)))
+
+# F4: the day's memory of past marks starts over on a new day.
+_s4 = c_q.status_payload()
+homeview.build(c_q, level=_s4["level"], checks=_s4["checks"], now=NOW)
+_k0 = dict(c_q.home_prices.kinds)
+_tom = NOW + timedelta(days=1)
+c_q.tariff_at = _tom
+homeview.build(c_q, level=_s4["level"], checks=_s4["checks"], now=_tom)
+c_q.tariff_at = NOW
+check("UX-45: past marks start over on a new day (nothing of yesterday is "
+      "kept)",
+      len(_k0) > 0 and c_q.home_prices.day != DAY0
+      and c_q.home_prices.kinds
+      and all(k >= DAY0 + timedelta(days=1) for k in c_q.home_prices.kinds)
+      and len(c_q.home_prices.kinds) <= 96)
+
+# F1: the setup wizard counts hours, not bars.
+from app.validate import setup_checks
+_o = dict(ARB, price_provider="entsoe_be")
+_say = lambda n: [x for x in map(repr, setup_checks(
+    _o, entities={}, running=_o, prices_known=n)) if "Prices for today" in x]
+check("UX-45: 96 quarter prices count as 24 hours in the setup wizard, "
+      "not 96",
+      homeview.priced_hours(_pq) == 24
+      and homeview.priced_hours(s_arb["plan"]["prices"]) == 24
+      and "for 24 of 24 hours" in "".join(_say(homeview.priced_hours(_pq)))
+      and "96 of 24" not in "".join(_say(homeview.priced_hours(_pq))))
+check("...a half-priced day counts its hours; a hole of one quarter loses "
+      "no hour",
+      homeview.priced_hours(_pq[:48]) == 12
+      and homeview.priced_hours(_hole_bars(5)) == 24
+      and homeview.priced_hours([dict(b, eur_kwh=None) for b in _pq]) == 0)
+check("...a 23-hour day gives 23 and a 25-hour day 24 (clock hours)",
+      homeview.priced_hours(homeview.price_bars(_sp, _d0, _d1)) == 23
+      and homeview.priced_hours(homeview.price_bars(
+          _fb, _f0, _f0 + timedelta(hours=25))) == 24)
+check("...and the wizard takes that count",
+      "known = priced_hours(prices)" in io.open(os.path.join(
+          HERE, "app", "web.py"), encoding="utf-8").read())

 # --------------------------------------------------------------------------- #
 print("\n4. a fault in the Home view never costs the page its rows")
@@ -66,22 +66,54 @@ A, B = "inverter-a", "inverter-b"

 # ============================================================================ #
 print("1. modes off: byte-identical to 7a00f12 on the trade path")
-# Printed by tools/opt11p3_identity.py on release/1.0 7a00f12 (2026-09-29),
-# goodwe-addon-checks:1. 1080 cycles each; the trade CHARGEs and DISCHARGEs.
-AT_7A00F12 = {
+# Printed on release/1.0 7a00f12 (2026-09-29), goodwe-addon-checks:1, 1080
+# cycles each; the trade CHARGEs and DISCHARGEs.
+#
+# PRICE-02 (2026-10-22) changed two things in the trade sentence and nothing
+# else: the plan now drops price periods that have ended, so a sale's "N above
+# the cheapest" is another number once the first cheap period is over, and the
+# sentences say "price period" for "hour". So there are three pins:
+#   AT_7A00F12_OLD  the digests printed on 7a00f12, sentence included. They no
+#                   longer match, and the check below says so: that is what
+#                   makes the mask necessary.
+#   AT_7A00F12      the same rows through `ident.trade_digest()`, which hides
+#                   exactly those two things (and only for this comparison with
+#                   an older tree). It equals what 7a00f12 gives through it.
+#   AT_NOW          this tree's own digests, sentence included, with nothing
+#                   hidden: any later change to a command, a sentence or a
+#                   figure moves it. The mask cannot hide a future drift.
+AT_7A00F12_OLD = {
    "n1": "71245b227ca40bada4f71f57ea6154475f4b0bd60239c9ad4f80bffb0094514c",
    "n2": "56cf28010b06765c29e5479abb815d7503d570b39240d82dfc818efa90c93722",
-    "n1_off": "71245b227ca40bada4f71f57ea6154475f4b0bd60239c9ad4f80bffb0094514c",
-    "n2_off": "56cf28010b06765c29e5479abb815d7503d570b39240d82dfc818efa90c93722",
 }
+AT_7A00F12 = {
+    "n1": "33886ef03f364852883f0370230e6e04823fbb46a4704f88ca75bf9082d98c01",
+    "n2": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
+    "n1_off": "33886ef03f364852883f0370230e6e04823fbb46a4704f88ca75bf9082d98c01",
+    "n2_off": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
+}
+AT_NOW = {
+    "n1": "939b3d47bbd64fa50e3d70538f092fb98e5c4bd5ead85a7fc696a1dbb514039e",
+    "n2": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
+    "n1_off": "939b3d47bbd64fa50e3d70538f092fb98e5c4bd5ead85a7fc696a1dbb514039e",
+    "n2_off": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
+}
+_cmd_digest = ident.trade_digest
 _rows = {k: ident.run(**ident.SCENARIOS[k])[0] for k in AT_7A00F12}
-_got = {k: ident.digest(v) for k, v in _rows.items()}
+_got = {k: _cmd_digest(v) for k, v in _rows.items()}
 for k in AT_7A00F12:
    print(f"    {k} {'same' if _got[k] == AT_7A00F12[k] else 'DIFFERS'} "
          f"{_got[k][:16]}")
+_full = {k: ident.digest(v) for k, v in _rows.items()}
 check("with battery modes off (option absent or false), every command, "
-      "integrator, allocation and trade sentence equals 7a00f12's, at one "
-      "inverter and at two", _got == AT_7A00F12)
+      "integrator, allocation and trade action equals 7a00f12's, at one "
+      "inverter and at two (the sentence masked as above)",
+      _got == AT_7A00F12)
+check("...the mask is needed and nothing more: unmasked, n1 and n2 differ "
+      "from 7a00f12's printed digests, and unmasked they equal this tree's "
+      "own pins, so a later change to any sentence or figure fails here",
+      all(_full[k] != AT_7A00F12_OLD[k] for k in AT_7A00F12_OLD)
+      and _full == AT_NOW)
 _acts = {r[-1][0] for r in _rows["n2"] if r[-1]}
 check("...and the runs reach the trade P3 now skips with modes on: a charge "
      "and a sale", {arbitrage.CHARGE, arbitrage.DISCHARGE} <= _acts)
@@ -96,7 +128,7 @@ def _moved(scn, patch):
        real(c, t)
    ident._feed = feed
    try:
-        return ident.digest(ident.run(**ident.SCENARIOS[scn])[0]) \
+        return _cmd_digest(ident.run(**ident.SCENARIOS[scn])[0]) \
            != AT_7A00F12[scn]
    finally:
        ident._feed = real
@@ -112,7 +144,7 @@ def _moved_headroom(scn):
    real = peakguard.charge_headroom_w
    peakguard.charge_headroom_w = lambda g: None
    try:
-        return ident.digest(ident.run(**ident.SCENARIOS[scn])[0]) \
+        return _cmd_digest(ident.run(**ident.SCENARIOS[scn])[0]) \
            != AT_7A00F12[scn]
    finally:
        peakguard.charge_headroom_w = real
@@ -104,7 +104,7 @@ def check(name, cond):
 # release/1.0 rather than against release/1.0.
 # ---------------------------------------------------------------------------
 _DEV = ('{"identifiers": ["goodwe_rs485_controller"], "name": "GoodWe", '
-        '"manufacturer": "GoodWe (via RS485 meter emulation)", '
+        '"manufacturer": "GoodWe (via RS485 EMS port)", '
        '"model": "ES/BP series"}')

 BASELINE = [
@@ -442,7 +442,7 @@ for c_ in unit_cfgs:
 print(f"    regression pin (sha256 of the eight payloads): {_pin}")
 check("the per-unit payloads are the ones this PR was reviewed with "
      "(REGRESSION PIN, not a correctness claim - see the comment)",
-      _pin == "eb5022b0455158d7")
+      _pin == "b4274714d8557c37")

 # ---------------------------------------------------------------------------
 print("\n4. zero overlap between A's entities and B's")
@@ -976,7 +976,7 @@ def announce_p2(units=(), omit=(), include=(), modes=(), retract=(),
 # `git show ed739d4:goodwe_controller/app/mqtt.py` and this loop.
 ROSTERS = [[], ["inverter-a"], ["inverter-a", "inverter-b"], ["a", "b", "c"],
           ["inverter-b", "Inverter B", "x", "y"], ["café"]]
-ED739D4_OFF = "501a7d93782a260b"
+ED739D4_OFF = "057be1d8ad7bb582"  # DOC-8: ed739d4 digest with only the manufacturer string changed
 _h, _n, _subs_off = hashlib.sha256(), 0, []
 for _r in ROSTERS:
    for _om in [(), ("p1_age",), ("p1_age", "grid")]:
@@ -99,6 +99,11 @@ from app.static_tariff import (
    TariffPlan, parse_taxes_profile, static_status)
 from app.validate import validate_startup_config

+
+# PRICE-02: `TariffPlan.arbitrage(now=...)` is required. This instant is before every
+# point these fixtures build, so no period has ended and the whole series counts.
+from datetime import datetime as _DT, timezone as _TZ  # noqa: E402
+LONG_AGO = _DT(2000, 1, 1, tzinfo=_TZ.utc)
 fails = []


@@ -4518,8 +4523,8 @@ _T11_FLAT = TariffPlan(
        [PricePoint(_T11_NOW + timedelta(minutes=15 * i), 0.10, False)
         for i in range(96)],
        PriceProduct.DAY_AHEAD, "generic_dayahead", _T11_NOW), None, "provider")
-_r83 = derived(lambda: _T11_ONEFIRM.arbitrage(**_T11_A9).reason)
-_rflat = derived(lambda: _T11_FLAT.arbitrage(**_T11_A9).reason)
+_r83 = derived(lambda: _T11_ONEFIRM.arbitrage(now=LONG_AGO, **_T11_A9).reason)
+_rflat = derived(lambda: _T11_FLAT.arbitrage(now=LONG_AGO, **_T11_A9).reason)
 print(f"    §8.3 refusal : {_r83[:118]}")
 print(f"    flat refusal : {_rflat[:118]}")
 # 96 quarter-hourly points span 24 hours; ONE firm point spans one of them.
@@ -4828,7 +4833,7 @@ def _t17_verdict(points):
    read = PriceRead.series(points, PriceProduct.DAY_AHEAD, "t17",
                            datetime.now(UTC))
    plan = TariffPlan(read, None, "provider")
-    return plan.arbitrage(peak_guard_active=False,
+    return plan.arbitrage(now=LONG_AGO, peak_guard_active=False,
                          min_spread_eur_kwh=PRICE_OPTION_DEFAULTS[
                              "cycle_cost_threshold_eur"],
                          uncertainty=frozenset())
@@ -0,0 +1,538 @@
+"""Runnable check for PRICE-02.  `python3 test_price02.py`
+
+The trading verdict is taken over the price periods that have not ended.
+`TariffPlan.arbitrage(now=...)` drops the points with `end <= now` (the span
+`price._cover_table()` gives each one) and every caller passes its `now`:
+`arbitrage.decide()` (modes off), the `allowed()` gate in
+`Controller._mode_roles()` (modes on) and the Home page's `trade_verdict()`.
+
+1. A 15-minute day, probed at :05, :20, :35 and :50 of the cheap hour: the
+   buy leg and the sell leg move to the current period and never name one that
+   has ended, and `decide()` trades in it. Cheapest in the past, the current
+   and a future period are all covered.
+2. A plan built at 03:00 and used at 03:20 (the 30-minute refresh lag), and the
+   shipped refresh (`fill_from_yesterday`, which keeps the whole current hour).
+3. An hourly feed and the static day/night tariff: an hourly point that is
+   still current stays in. A plan built off the hour (the refresh runs every
+   30 min from add-on start, so :20 and :50 are normal) no longer aims at the
+   hour that has just ended, so a trade runs through (owner, 2026-10-22), and
+   a period that ends exactly at `now` is over.
+4. Modes on: a spread that exists only because of an ended period no longer
+   opens the gate (`Controller._mode_roles`), nor the Home page verdict.
+5. The reason text says "price period"; `now` is required (no default).
+6. Ties. The verdict takes the first extreme still ahead, where it used to
+   take the first of the whole plan. On hour-constant 15-minute data (four
+   equal quarters) that is four acting periods in the cheap hour, not one;
+   the number of times the action changes does not grow. The same on a real
+   15-minute day, and hourly alternating prices change at most once an hour.
+
+Mutations: MUTATION.md says how to run them (purged copies); the ones of
+PRICE-02 are listed in the pull request.
+"""
+
+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                             # noqa: E402
+from app.arbitrage import CHARGE, DISCHARGE, decide             # noqa: E402
+from app.price import (PricePoint, PriceProduct, PriceRead,     # noqa: E402
+                       Uncertainty, brussels)
+from app.price_forecast import fill_from_yesterday              # noqa: E402
+from app.static_tariff import TariffPlan, static_plan           # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+UTC = timezone.utc
+LONG_AGO = datetime(2000, 1, 1, tzinfo=UTC)     # before every point: nothing has ended, the old reach
+NO_WEATHER = frozenset({Uncertainty.NO_WEATHER})
+D0 = datetime(2026, 10, 20, 0, 0, tzinfo=UTC)      # 02:00 Brussels
+H3 = D0 + timedelta(hours=1)                       # 03:00 Brussels
+ARGS = dict(peak_guard_active=False, min_spread_eur_kwh=0.10,
+            uncertainty=NO_WEATHER)
+
+
+def qplan(prices, start=D0, minutes=15, product=PriceProduct.DAY_AHEAD):
+    pts = [PricePoint(brussels(start + timedelta(minutes=minutes * i)), p,
+                      False) for i, p in enumerate(prices)]
+    return TariffPlan(PriceRead.series(pts, product, "generic_dayahead",
+                                       start), None, "provider")
+
+
+ARGS_NO_NOW = dict(ARGS)
+ARGS5 = dict(ARGS, min_spread_eur_kwh=0.05, uncertainty=frozenset())
+
+
+def dec(plan, now, **kw):
+    base = dict(peak_guard_active=False, charge_headroom_w=5000.0, soc=50.0,
+                min_spread_eur_kwh=0.10, uncertainty=frozenset(),
+                charge_w=2500.0, discharge_w=2500.0, soc_floor_pct=10.0,
+                soc_ceiling_pct=90.0)
+    base.update(kw)
+    return decide(plan, now, **base)
+
+
+def hhmm(t):
+    return f"{brussels(t):%H:%M}"
+
+
+def ahead_extreme(prices, now, pick, start=D0, minutes=15):
+    """The expected leg, by plain arithmetic: the extreme price over the
+    periods whose end is after `now`, as the start instant (first on a tie)."""
+    best = None
+    for i, p in enumerate(prices):
+        s = start + timedelta(minutes=minutes * i)
+        if s + timedelta(minutes=minutes) <= now:
+            continue
+        if best is None or pick(p, best[1]):
+            best = (s, p)
+    return best[0]
+
+
+# --------------------------------------------------------------------------- #
+print("1. a 15-minute day: the verdict is taken from the current period on")
+BUY = [0.30] * 192                      # 48 h of quarters from 02:00
+for q, p in ((4, 0.05), (5, 0.06), (6, 0.07), (7, 0.08), (68, 0.50)):
+    BUY[q] = p                          # 03:00 .05  03:15 .06  03:30 .07  03:45 .08  19:00 .50
+BUY_PLAN = qplan(BUY)
+check("the fixture: the day's cheapest period is 03:00, then three dearer "
+      "ones, and the dearest is 19:00 - so every probe has a past, a current "
+      "and a future period to choose between",
+      BUY.index(min(BUY)) == 4 and BUY.index(max(BUY)) == 68
+      and BUY[4] < BUY[5] < BUY[6] < BUY[7] < min(BUY[8:68]))
+want_q = {5: 4, 20: 5, 35: 6, 50: 7}
+for mins, q in want_q.items():
+    now = H3 + timedelta(minutes=mins)
+    v = BUY_PLAN.arbitrage(now=now, **ARGS)
+    d = dec(BUY_PLAN, now)
+    got = v.cheapest.start
+    exp = ahead_extreme(BUY, now, lambda a, b: a < b)
+    check(f"03:{mins:02d}: the buy leg is {hhmm(exp)} (the first period not "
+          f"over), the verdict says {hhmm(got)}, and decide() is {d.action}",
+          got == exp == D0 + timedelta(minutes=15 * q)
+          and d.action == CHARGE
+          and abs(d.price_now_eur_kwh - BUY[q]) < 1e-9)
+check("before the change the same plan at 03:20 aimed at 03:00 (the "
+      "verdict without `now`) and decide() did nothing - the defect, shown",
+      BUY_PLAN.arbitrage(now=LONG_AGO, **ARGS).cheapest.start == H3
+      and arbitrage._act(BUY_PLAN, H3 + timedelta(minutes=20),
+                         BUY_PLAN.arbitrage(now=LONG_AGO, **ARGS), 50.0, 2500.0, 2500.0,
+                         10.0, 90.0, 5000.0).action is None)
+
+# A cheapest period still AHEAD stays the target from every probe.
+FUT = [0.30] * 192
+FUT[8], FUT[68] = 0.04, 0.50            # cheapest 04:00, dearest 19:00
+FUT_PLAN = qplan(FUT)
+check("the cheapest in the FUTURE (04:00) is the buy leg at :05, :20, :35 and "
+      ":50 of the hour before it - nothing ahead is dropped",
+      all(FUT_PLAN.arbitrage(now=H3 + timedelta(minutes=m), **ARGS)
+          .cheapest.start == H3 + timedelta(hours=1) for m in (5, 20, 35, 50)))
+check("...and at 04:20 (that period is now the current one) it is still the "
+      "current period at :00-:15 only: 04:20 aims elsewhere",
+      FUT_PLAN.arbitrage(now=H3 + timedelta(hours=1, minutes=20), **ARGS)
+      .cheapest.start != H3 + timedelta(hours=1))
+
+print("\n1b. the sell leg")
+SELL = [0.30] * 192
+for q, p in ((4, 0.70), (5, 0.65), (6, 0.60), (7, 0.55), (68, 0.10)):
+    SELL[q] = p                         # dearest 03:00 .70 .. 03:45 .55 ; cheapest 19:00
+SELL_PLAN = qplan(SELL)
+for mins, q in want_q.items():
+    now = H3 + timedelta(minutes=mins)
+    v = SELL_PLAN.arbitrage(now=now, **ARGS)
+    d = dec(SELL_PLAN, now)
+    exp = ahead_extreme(SELL, now, lambda a, b: a > b)
+    check(f"03:{mins:02d}: the sell leg is {hhmm(exp)}, the verdict says "
+          f"{hhmm(v.dearest.start)}, and decide() is {d.action}",
+          v.dearest.start == exp == D0 + timedelta(minutes=15 * q)
+          and d.action == DISCHARGE
+          and abs(d.price_now_eur_kwh - SELL[q]) < 1e-9)
+
+# --------------------------------------------------------------------------- #
+print("\n2. the plan is older than the verdict")
+# Built at 03:00 and used at 03:20, 03:35 (the refresh runs every 30 min).
+built = H3
+feed = qplan(BUY).read
+plan_0300 = TariffPlan(fill_from_yesterday(
+    feed, yesterday=PriceRead.no_data("none"), since=built,
+    until=built + timedelta(hours=48), stamp=built), None, "provider")
+check("the plan built at 03:00 starts at 03:00 (the refresh floors to the hour)",
+      min(p.start for p in plan_0300.read.points) == H3)
+for mins, q in ((20, 5), (35, 6)):
+    now = H3 + timedelta(minutes=mins)
+    d = dec(plan_0300, now)
+    check(f"used at 03:{mins:02d} the verdict is "
+          f"{hhmm(D0 + timedelta(minutes=15 * q))} and decide() charges there",
+          plan_0300.arbitrage(now=now, **ARGS).cheapest.start
+          == D0 + timedelta(minutes=15 * q) and d.action == CHARGE)
+# The shipped refresh at 03:20 keeps the whole hour: the verdict still skips it.
+now = H3 + timedelta(minutes=20)
+plan_refresh = TariffPlan(fill_from_yesterday(
+    feed, yesterday=PriceRead.no_data("none"), since=now,
+    until=now + timedelta(hours=48), stamp=now), None, "provider")
+check("the shipped refresh at 03:20 still holds the 03:00 period, as before, "
+      "and the verdict does not aim at it",
+      min(p.start for p in plan_refresh.read.points) == H3
+      and plan_refresh.arbitrage(now=now, **ARGS).cheapest.start
+      == H3 + timedelta(minutes=15))
+
+# --------------------------------------------------------------------------- #
+print("\n3. hourly feeds and the static tariff: a current hour stays in")
+HR = [0.30] * 48                        # 48 hourly points from 02:00
+HR[1], HR[17] = 0.05, 0.50              # cheapest 03:00, dearest 19:00
+HR_PLAN = qplan(HR, minutes=60)
+same = True
+for m in (0, 5, 20, 35, 59):
+    now = H3 + timedelta(minutes=m)
+    a = HR_PLAN.arbitrage(now=now, **ARGS)
+    b = HR_PLAN.arbitrage(now=LONG_AGO, **ARGS)
+    same = same and a.cheapest is b.cheapest and a.dearest is b.dearest \
+        and a.spread_eur_kwh == b.spread_eur_kwh
+check("an hourly point that is still current stays in: at 03:00, :05, :20, "
+      ":35 and :59 the verdict is the one without `now`", same)
+check("...and decide() still charges in the current hour at 03:40",
+      dec(HR_PLAN, H3 + timedelta(minutes=40)).action == CHARGE)
+check("...and once the hour has ended its point is gone: at 04:05 the buy leg "
+      "is no longer 03:00",
+      HR_PLAN.arbitrage(now=H3 + timedelta(hours=1, minutes=5), **ARGS)
+      .cheapest.start != H3)
+
+TWO = {"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "mon-sun",
+     "eur_per_kwh": 0.40},
+    {"name": "night", "from": "22:00", "to": "07:00", "days": "mon-sun",
+     "eur_per_kwh": 0.18}]}
+OPTS = {"price_provider": "off", "static_profile": json.dumps(TWO)}
+ok, n_checked = True, 0
+for h in range(0, 24):
+    for m in (0, 20, 50):
+        now = D0 + timedelta(hours=h - 2, minutes=m)   # from 22:00 UTC the day before
+        plan = static_plan(OPTS, now, now + timedelta(hours=48), now=now)
+        a = plan.arbitrage(now=now, **ARGS)
+        b = plan.arbitrage(now=LONG_AGO, **ARGS)
+        n_checked += 1
+        ok = ok and a.kind == b.kind == "allowed" and a.cheapest is b.cheapest \
+            and a.dearest is b.dearest and a.spread_eur_kwh == b.spread_eur_kwh
+check(f"the static day/night plan, built at the instant it is used (so it "
+      f"holds no ended hour), gives the same verdict with and without `now` "
+      f"at {n_checked} instants", ok and n_checked == 72)
+
+# 3b. The refresh is NOT on the hour. main.py rebuilds the plan every 30 min
+# counted from add-on start (TARIFF_REFRESH_S = 1800), so a plan built at :20
+# or :50 starts at the floored hour and, until the next refresh, still holds
+# the hour that has just ended. Owner decision 2026-10-22: the verdict skips
+# that hour too, so a trade runs through instead of pausing until the refresh.
+print("\n3b. hourly and static plans built off the hour: the ended hour is not the target")
+HR2 = [0.30] * 48                       # hourly from 02:00 Brussels
+HR2[1], HR2[2], HR2[17] = 0.05, 0.05, 0.50   # cheap 03:00 and 04:00 (a tie), dear 19:00
+built = H3 + timedelta(minutes=50)      # the refresh at :50 floors to 03:00
+plan_h = TariffPlan(fill_from_yesterday(
+    qplan(HR2, minutes=60).read, yesterday=PriceRead.no_data("none"),
+    since=built, until=built + timedelta(hours=48), stamp=built),
+    None, "provider")
+now = H3 + timedelta(hours=1, minutes=5)     # 04:05, before the next refresh
+check("the hourly plan built at 03:50 starts at 03:00 and is used at 04:05, so "
+      "it still holds the 03:00 hour, which is over",
+      min(p.start for p in plan_h.read.points) == H3)
+old_v = plan_h.arbitrage(now=LONG_AGO, **ARGS)
+new_v = plan_h.arbitrage(now=now, **ARGS)
+check("without `now` (the old verdict) the buy leg is the ended 03:00 hour "
+      "(first of the tie) and decide() does nothing at 04:05 - the pause",
+      old_v.cheapest.start == H3
+      and arbitrage._act(plan_h, now, old_v, 50.0, 2500.0, 2500.0, 10.0,
+                         90.0, 5000.0).action is None)
+check("with `now` the buy leg is 04:00, the hour in progress, and decide() "
+      "charges at 04:05: the trade runs through",
+      new_v.cheapest.start == H3 + timedelta(hours=1)
+      and dec(plan_h, now).action == CHARGE)
+
+# The day/night tariff, refresh at :20 of the hour: all 15 day hours tie.
+b_local = D0 + timedelta(hours=10, minutes=20)    # 12:20 Brussels
+plan_s = static_plan(OPTS, b_local, b_local + timedelta(hours=48), now=b_local)
+now = D0 + timedelta(hours=11, minutes=5)         # 13:05 Brussels
+old_v = plan_s.arbitrage(now=LONG_AGO, **ARGS)
+new_v = plan_s.arbitrage(now=now, **ARGS)
+check("the day/night plan built at 12:20 starts at 12:00; used at 13:05 its "
+      "sell leg without `now` is the ended 12:00 hour (first of the tied day "
+      "hours) and decide() does nothing - the old hourly pause",
+      min(p.start for p in plan_s.read.points) == D0 + timedelta(hours=10)
+      and old_v.dearest.start == D0 + timedelta(hours=10)
+      and arbitrage._act(plan_s, now, old_v, 50.0, 2500.0, 2500.0, 10.0,
+                         90.0, 5000.0).action is None)
+check("with `now` the sell leg is 13:00, the hour in progress, and decide() "
+      "discharges at 13:05: the trade runs through",
+      new_v.dearest.start == D0 + timedelta(hours=11)
+      and dec(plan_s, now).action == DISCHARGE)
+ok = True
+for m in (0, 5, 20, 35, 50, 59):                  # every minute class of the hour
+    t = D0 + timedelta(hours=12, minutes=m)       # 14:mm Brussels
+    v = plan_s.arbitrage(now=t, **ARGS)
+    ok = ok and v.dearest.start == D0 + timedelta(hours=12) \
+        and dec(plan_s, t).action == DISCHARGE
+check("...and through the whole of 14:00-14:59 the target is the 14:00 hour "
+      "and the trade stays on (no pause at the top of the hour)", ok)
+
+# The exact boundary: a period ends AT its `end`, so at that instant it is over.
+# (`end >= now` would keep it for one more instant.)
+print("\n3c. the exact end of a period")
+at = H3 + timedelta(minutes=15)                   # 03:15:00 exactly
+v = BUY_PLAN.arbitrage(now=at, **ARGS)
+check("at 03:15:00 exactly the 03:00 quarter is over: the buy leg is 03:15 "
+      "and decide() charges", v.cheapest.start == at and dec(BUY_PLAN, at)
+      .action == CHARGE)
+check("one microsecond earlier the 03:00 quarter is still in view",
+      BUY_PLAN.arbitrage(now=at - timedelta(microseconds=1), **ARGS)
+      .cheapest.start == H3)
+at_h = H3 + timedelta(hours=1)                    # 04:00:00 exactly
+check("at 04:00:00 exactly the 03:00 hour is over (hourly feed), one "
+      "microsecond earlier it is not",
+      plan_h.arbitrage(now=at_h, **ARGS).cheapest.start == at_h
+      and plan_h.arbitrage(now=at_h - timedelta(microseconds=1), **ARGS)
+      .cheapest.start == H3)
+two = qplan([0.10, 0.20])                         # two firm quarters from 02:00
+check("the Home page's refusal key at the exact end of the first of two "
+      "quarters: one is left, so 'not_firm' (with `end >= now` it would say "
+      "'not_worth'); a microsecond earlier both count",
+      homeview.refusal_key(two, False, D0 + timedelta(minutes=15)) == "not_firm"
+      and homeview.refusal_key(two, False, D0 + timedelta(minutes=15)
+                               - timedelta(microseconds=1)) == "not_worth")
+
+# --------------------------------------------------------------------------- #
+print("\n4. modes on: an ended period no longer opens the gate")
+GATE = [0.30] * 192
+GATE[4] = 0.10                          # the ONLY spread is the 03:00 period
+GATE_PLAN = qplan(GATE)
+now = H3 + timedelta(minutes=20)
+check("the fixture: with the ended 03:00 period in view the verdict is "
+      "allowed; from 03:20 on the rest of the series is flat",
+      GATE_PLAN.arbitrage(now=LONG_AGO, **ARGS).kind == "allowed"
+      and GATE_PLAN.arbitrage(now=now, **ARGS).kind == "refused"
+      and "flat" in GATE_PLAN.arbitrage(now=now, **ARGS).reason)
+
+import opt11p3_replay as rp                                     # noqa: E402
+
+WPTS = [(D0 + timedelta(minutes=15 * i), 900, 0.10) for i in range(192)]
+
+
+def controller_at(at, plan):
+    """The real Controller after a few cycles of the modes-on replay at `at`
+    (two batteries, one on Cheap hours), holding `plan` as its fresh plan."""
+    _st, c = rp.run("p3_ch_sell", [(D0.timestamp() - 10, 800.0)], WPTS, at,
+                    20.0, soc0={"a": 60.0, "b": 30.0},
+                    extra={"cycle_cost_threshold_eur": 0.05})
+    c.tariff_plan, c.tariff_at = plan, at
+    return c
+
+
+from app import modetrade                                       # noqa: E402
+
+GATE_SEEN = {}
+_real_decide = modetrade.decide
+
+
+def _spy(runs, now_, packs, **kw):
+    GATE_SEEN.update(charge_ok=kw["charge_ok"], sell_ok=kw["sell_ok"],
+                     trade_why=kw["trade_why"])
+    return _real_decide(runs, now_, packs, **kw)
+
+
+modetrade.decide = _spy
+c = controller_at(now, GATE_PLAN)
+GATE_SEEN.clear()
+c._mode_roles(now, None)
+late = dict(GATE_SEEN)
+c2 = controller_at(H3 + timedelta(minutes=5), GATE_PLAN)
+GATE_SEEN.clear()
+c2._mode_roles(H3 + timedelta(minutes=5), None)
+early = dict(GATE_SEEN)
+modetrade.decide = _real_decide
+check(f"Controller._mode_roles() (modes on, the `allowed()` gate) at 03:05, "
+      f"03:00 still current: charge and sell are allowed ({early})",
+      early.get("charge_ok") is True and early.get("sell_ok") is True)
+check(f"...and at 03:20, with only flat periods ahead: neither is allowed, "
+      f"and the reason is the spread ({late})",
+      late.get("charge_ok") is False and late.get("sell_ok") is False
+      and late.get("trade_why") == "not_worth")
+
+c.o["arbitrage_enabled"] = True
+v, why = homeview.trade_verdict(c, GATE_PLAN, now)
+check(f"the Home page verdict takes the same `now`: no verdict at 03:20 "
+      f"({why!r}), and a verdict at 03:05",
+      v is None and why == "not_worth"
+      and homeview.trade_verdict(c, GATE_PLAN, H3 + timedelta(minutes=5))[0]
+      is not None)
+check("...and the refusal key counts only periods not over: two firm periods "
+      "left, so 'not_worth', and with one left 'not_firm'",
+      homeview.refusal_key(GATE_PLAN, False, now) == "not_worth"
+      and homeview.refusal_key(qplan([0.1, 0.2]), False,
+                               D0 + timedelta(minutes=20)) == "not_firm")
+
+# --------------------------------------------------------------------------- #
+print("\n5. the text")
+check("the reason for an off-peak period says 'price period', not 'hour'",
+      arbitrage.IDLE_OFF_PEAK_HOUR
+      == "now is not the cheapest or the dearest price period")
+_b = dec(BUY_PLAN, H3 + timedelta(minutes=20))
+_s = dec(SELL_PLAN, H3 + timedelta(minutes=20))
+check("...and the charge and the discharge sentences say 'price period' too "
+      "(the unit is 15 minutes), with no 'firm hour' left",
+      "cheapest firm price period" in _b.reason
+      and "dearest firm price period" in _s.reason
+      and "firm hour" not in _b.reason + _s.reason)
+_hi = dec(BUY_PLAN, H3 + timedelta(minutes=20), soc=95.0)
+_lo = dec(SELL_PLAN, H3 + timedelta(minutes=20), soc=10.0)
+check("...and so do the full-pack and empty-pack sentences ('buy period', "
+      "'sell period')",
+      "the buy period is here" in _hi.reason
+      and "the sell period is here" in _lo.reason)
+import inspect                                                  # noqa: E402
+
+_par = inspect.signature(TariffPlan.arbitrage).parameters
+check("`now` is required: keyword-only with no default, like the three "
+      "arguments beside it, so a caller that forgets it fails loudly instead "
+      "of getting the elapsed periods back",
+      _par["now"].default is inspect.Parameter.empty
+      and _par["now"].kind is inspect.Parameter.KEYWORD_ONLY
+      and all(p.default is inspect.Parameter.empty
+              for n, p in _par.items() if n != "self"))
+try:
+    BUY_PLAN.arbitrage(**ARGS_NO_NOW)
+    _forgot = False
+except TypeError:
+    _forgot = True
+check("...and calling without it raises TypeError", _forgot)
+try:
+    BUY_PLAN.arbitrage(now=datetime(2026, 10, 20, 3, 20), **ARGS)
+    _naive = False
+except TypeError as e:
+    _naive = "tz-aware" in str(e)
+check("a naive `now` is refused: it is ambiguous for one hour every October",
+      _naive)
+
+
+# --------------------------------------------------------------------------- #
+print("\n6. ties: the first extreme still ahead")
+def acts(plan, instants, ago=False, args=ARGS):
+    out = []
+    for t in instants:
+        v = plan.arbitrage(now=LONG_AGO if ago else t, **args)
+        d = arbitrage._act(plan, t, v, 50.0, 2500.0, 2500.0, 10.0, 90.0,
+                           5000.0) if v.kind == "allowed" else None
+        out.append(None if d is None else d.action)
+    return out
+
+
+# Hour-constant 15-minute data: the cheap hour is four equal quarters.
+HC = [round(0.40 - 0.0001 * i, 4) for i in range(192)]   # falling, no ties
+for q in range(4, 8):
+    HC[q] = 0.05                        # 03:00-04:00 four equal quarters
+HC[68:72] = [0.50] * 4                  # 19:00-20:00 four equal quarters
+HC_PLAN = qplan(HC)
+probe = [H3 + timedelta(minutes=m) for m in (5, 20, 35, 50, 65)]
+old = acts(HC_PLAN, probe, ago=True)
+new = acts(HC_PLAN, probe)
+check(f"before: four equal cheap quarters, the verdict is the first of them, "
+      f"so the trade acts in one quarter ({old})",
+      old == [CHARGE, None, None, None, None])
+check(f"after: the first one still ahead, so it acts in all four and stops "
+      f"with the hour ({new}) - four acting periods for the same hour, one "
+      f"block either way",
+      new == [CHARGE, CHARGE, CHARGE, CHARGE, None])
+changes = lambda a: sum(1 for x, y in zip(a, a[1:]) if x != y)    # noqa: E731
+check("...the action changes the same number of times (one start, one stop)",
+      changes(old) == changes(new) == 1)
+
+# A real 15-minute day, as production runs it: refresh every 30 min from the
+# floored hour, the verdict at 7 min into every period.
+REAL = os.path.join(HERE, "scenarios",
+                    "energy-charts-be-price-2026-09-09_2026-09-10-twoday.json")
+_d = json.load(open(REAL))
+_pts = [PricePoint(brussels(datetime.fromtimestamp(t, UTC)), p / 1000.0, False)
+        for t, p in zip(_d["unix_seconds"], _d["price"])]
+_feed = PriceRead.series(_pts, PriceProduct.DAY_AHEAD, "generic_dayahead",
+                         _pts[0].start)
+_day0 = _pts[0].start.astimezone(UTC)
+
+def real_day(ago):
+    out = []
+    for q in range(96):
+        t = _day0 + timedelta(minutes=15 * q + 7)
+        ref = t.replace(minute=0 if t.minute < 30 else 30, second=0,
+                        microsecond=0)
+        plan = TariffPlan(fill_from_yesterday(
+            _feed, yesterday=PriceRead.no_data("none"), since=ref,
+            until=ref + timedelta(hours=36), stamp=ref), None, "provider")
+        v = plan.arbitrage(now=LONG_AGO if ago else t, **ARGS5)
+        out.append(arbitrage._act(plan, t, v, 50.0, 2500.0, 2500.0, 10.0,
+                                  90.0, 5000.0).action
+                   if v.kind == "allowed" else None)
+    return out
+
+
+r_old, r_new = real_day(True), real_day(False)
+n_old = sum(1 for a in r_old if a)
+n_new = sum(1 for a in r_new if a)
+print(f"    real 15-minute day 2026-09-09: acting periods {n_old} -> {n_new}, "
+      f"action changes {changes(r_old)} -> {changes(r_new)}")
+check("a real 15-minute day (energy-charts, 2026-09-09) does not switch more "
+      "often: the action changes no more often than before",
+      changes(r_new) <= changes(r_old))
+check("...and every period the old verdict acted in is still acted in, with "
+      "the quarters it had lost to the elapsed-period tie added",
+      all(n is not None for o, n in zip(r_old, r_new) if o) and n_new >= n_old)
+
+# Alternating hourly prices (the flapping day): ties everywhere, so the verdict
+# moves on every hour. At most once an hour, never once a tick.
+FL = [0.20 + (0.101 if i % 2 else 0.0) for i in range(24)] * 2
+FL_PLAN = qplan(FL, minutes=60)
+ticks = [acts(FL_PLAN, [D0 + timedelta(seconds=30 * k)], args=ARGS5)[0]
+         for k in range(24 * 120)]
+check(f"alternating hourly prices: {changes(ticks)} action changes over "
+      f"2880 ticks - at most one an hour, not one a tick",
+      changes(ticks) <= 24 and CHARGE in ticks and DISCHARGE in ticks)
+
+# The Home page path: `homeview.build_plan()` hands its own `now` to
+# `trade_verdict`. With a `now` floored to the hour it would still aim at the
+# 03:00 period at 03:20 and draw a trade that the control cycle does not take.
+print("\n4b. the Home page plan (build_plan) uses the instant it is rendered at")
+c.o["arbitrage_enabled"] = True
+c.modes_on = False
+
+
+def home_at(t):
+    c.tariff_plan, c.tariff_at = GATE_PLAN, t
+    return homeview.build_plan(c, t, False, True)
+
+
+h_early = home_at(H3 + timedelta(minutes=5))
+h_late = home_at(H3 + timedelta(minutes=20))
+trade_kinds = ("grid", "give")
+check("build_plan at 03:05 (03:00 still current): the spread is real, so the "
+      "page draws a trade (verdict_key 'trade')",
+      h_early["verdict_key"] == "trade"
+      and any(r["kind"] in trade_kinds for r in h_early["runs"]))
+check("build_plan at 03:20 (only flat periods ahead): no trade on the page, "
+      "the same refusal as trade_verdict gives (verdict_key 'house')",
+      h_late["verdict_key"] == "house"
+      and not any(r["kind"] in trade_kinds for r in h_late["runs"])
+      and h_late["lines"] != h_early["lines"])
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED: " + "; ".join(fails))
+    sys.exit(1)
+print("all checks passed")
@@ -87,6 +87,11 @@ from app.static_tariff import Arbitrage, TariffPlan

 UTC = timezone.utc
 HERE = os.path.dirname(os.path.abspath(__file__))
+
+# PRICE-02: `TariffPlan.arbitrage(now=...)` is required. This instant is before every
+# point these fixtures build, so no period has ended and the whole series counts.
+from datetime import datetime as _DT, timezone as _TZ  # noqa: E402
+LONG_AGO = _DT(2000, 1, 1, tzinfo=_TZ.utc)
 fails = []


@@ -905,7 +910,7 @@ def min_accepted_spread(product, sources, base, provider="generic_dayahead"):
    lo, hi = 0.0, 4.0
    for _ in range(60):
        mid = (lo + hi) / 2
-        v = plan_with_spread(mid, product, provider).arbitrage(
+        v = plan_with_spread(mid, product, provider).arbitrage(now=LONG_AGO,
            peak_guard_active=False, min_spread_eur_kwh=base,
            uncertainty=sources)
        if v.kind == "allowed":
@@ -1013,7 +1018,7 @@ check(f"the fixture is non-degenerate: the whole-series spread "
      f"{_all_spread:.6f} and the firm-only spread {_firm_spread:.6f} are "
      f"different numbers, so a verdict can be traced to one of them",
      not near(_all_spread, _firm_spread, 1e-6))
-_v = derived(lambda: _mixed.arbitrage(peak_guard_active=False,
+_v = derived(lambda: _mixed.arbitrage(now=LONG_AGO, peak_guard_active=False,
                                      min_spread_eur_kwh=0.0,
                                      uncertainty=frozenset()))
 check("a PART-published series still allows arbitrage - §8.3 forbids acting on "
@@ -1032,7 +1037,7 @@ check("...and it reports the threshold it cleared and why, rather than leaving "
 _all_prov = TariffPlan(PriceRead.series(_cheap_stale, PriceProduct.DAY_AHEAD,
                                        "generic_dayahead", D0), None,
                       "fallback")
-_vp = derived(lambda: _all_prov.arbitrage(peak_guard_active=False,
+_vp = derived(lambda: _all_prov.arbitrage(now=LONG_AGO, peak_guard_active=False,
                                          min_spread_eur_kwh=0.0,
                                          uncertainty=frozenset()))
 check("a WHOLLY provisional series - the §11.4 fallback, or a day before any "
@@ -1046,23 +1051,23 @@ _one_firm = TariffPlan(
                     "generic_dayahead", D0), None, "provider")
 check("one firm hour is not enough either: a buy hour and a sell hour must "
      "BOTH be published before a cycle can be committed",
-      _one_firm.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0,
+      _one_firm.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0,
                          uncertainty=frozenset()).kind == "refused")
 check("§10.1 still holds above all of it: the peak guard refuses the same "
      "series that is otherwise allowed",
-      _mixed.arbitrage(peak_guard_active=True, min_spread_eur_kwh=0.0,
+      _mixed.arbitrage(now=LONG_AGO, peak_guard_active=True, min_spread_eur_kwh=0.0,
                       uncertainty=frozenset()).kind == "refused")
 check("the three questions cannot be skipped: all of peak_guard_active, "
      "min_spread_eur_kwh and uncertainty are required and keyword-only",
-      raises(lambda: _mixed.arbitrage(peak_guard_active=False), TypeError)
-      and raises(lambda: _mixed.arbitrage(peak_guard_active=False,
+      raises(lambda: _mixed.arbitrage(now=LONG_AGO, peak_guard_active=False), TypeError)
+      and raises(lambda: _mixed.arbitrage(now=LONG_AGO, peak_guard_active=False,
                                          min_spread_eur_kwh=0.0), TypeError)
      and raises(lambda: _mixed.arbitrage(False, 0.0, frozenset()), TypeError))
 check("...nor answered with a truthy 'unknown' or a negative threshold",
-      raises(lambda: _mixed.arbitrage(peak_guard_active=None,
+      raises(lambda: _mixed.arbitrage(now=LONG_AGO, peak_guard_active=None,
                                      min_spread_eur_kwh=0.0,
                                      uncertainty=frozenset()), TypeError)
-      and raises(lambda: _mixed.arbitrage(peak_guard_active=False,
+      and raises(lambda: _mixed.arbitrage(now=LONG_AGO, peak_guard_active=False,
                                          min_spread_eur_kwh=-0.1,
                                          uncertainty=frozenset()), TypeError))

@@ -118,6 +118,11 @@ from app.static_tariff import resolve_tariff

 UTC = timezone.utc
 HERE = os.path.dirname(os.path.abspath(__file__))
+
+# PRICE-02: `TariffPlan.arbitrage(now=...)` is required. This instant is before every
+# point these fixtures build, so no period has ended and the whole series counts.
+from datetime import datetime as _DT, timezone as _TZ  # noqa: E402
+LONG_AGO = _DT(2000, 1, 1, tzinfo=_TZ.utc)
 fails = []
 _tmpdirs = []

@@ -699,8 +704,8 @@ check(f"the short answer stays a SERIES of what exists - {_pre.read.kind}, "
 # --- the trade set, which is where the whole thing lands ------------------- #
 _A9 = dict(peak_guard_active=False, min_spread_eur_kwh=0.0,
           uncertainty=frozenset())
-_v2 = _pub.arbitrage(**_A9)
-_v1 = _pre.arbitrage(**_A9)
+_v2 = _pub.arbitrage(now=LONG_AGO, **_A9)
+_v1 = _pre.arbitrage(now=LONG_AGO, **_A9)
 check("both plans still ALLOW a trade, so the two verdicts below are compared "
      "against each other and not against a refusal",
      _v2.kind == "allowed" and _v1.kind == "allowed")
@@ -744,8 +749,8 @@ print("2. AC2 - the spread stopped being taken over hours that have gone")

 _A = dict(peak_guard_active=False, min_spread_eur_kwh=0.0,
          uncertainty=frozenset())
-_v_before = _before.arbitrage(**_A)
-_v_after = _after.arbitrage(**_A)
+_v_before = _before.arbitrage(now=LONG_AGO, **_A)
+_v_after = _after.arbitrage(now=LONG_AGO, **_A)
 check("both plans still ALLOW a trade, so this section compares two verdicts "
      "rather than a verdict and a refusal",
      _v_before.kind == "allowed" and _v_after.kind == "allowed")
@@ -843,7 +848,7 @@ check("...and no two of them share a whole hour by accident: the fixture puts "

 _q_spread_want = round(max(p.eur_per_kwh for p in _q_win)
                       - min(p.eur_per_kwh for p in _q_win), 6)
-_qv = _q_after.arbitrage(**_A)
+_qv = _q_after.arbitrage(now=LONG_AGO, **_A)
 _q_spread_got = _qv.match(allowed=lambda v: v.spread_eur_kwh,
                          refused=lambda _v: None)
 check(f"...and the spread is the fixture's own max - min over that window "
@@ -596,30 +596,59 @@ check("selling is off: no sale on any cycle",

 # ============================================================================ #
 print("\n5. modes off: byte-identical to release/1.0 e3e4ba6")
-# Printed by tools/opt11p3_identity.py on release/1.0 e3e4ba6 (2026-10-13),
-# goodwe-addon-checks:1, with this branch's harness (same API). n1 and n2 are
-# also 5a4cdc2's; the lag ones moved with SAFETY-90/91 (n2_lag now equals n2:
-# the next-quarter grading removed the edge tick's blindness at N=2).
-AT_BASE = {
+# Printed on release/1.0 e3e4ba6 (2026-10-13), goodwe-addon-checks:1, with this
+# branch's harness (same API). n1 and n2 are also 5a4cdc2's; the lag ones moved
+# with SAFETY-90/91 (n2_lag now equals n2: the next-quarter grading removed the
+# edge tick's blindness at N=2).
+#
+# PRICE-02 (2026-10-22) changed two things in the trade sentence and nothing
+# else (see test_modes_p3.py part 1): the "N above the cheapest" figure of a
+# sale and "hour" -> "price period". Three pins, as there:
+#   AT_BASE_OLD  the digests printed on e3e4ba6, sentence included (no longer
+#                matched: the mask is needed);
+#   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.
+AT_BASE_OLD = {
    "n1": "71245b227ca40bada4f71f57ea6154475f4b0bd60239c9ad4f80bffb0094514c",
    "n2": "56cf28010b06765c29e5479abb815d7503d570b39240d82dfc818efa90c93722",
    "n1_lag": "86ef0f5ad8da1498ff7dcf59262a177bef847a0b201ce804e947c8eab5f07190",
    "n2_lag": "56cf28010b06765c29e5479abb815d7503d570b39240d82dfc818efa90c93722",
 }
-_got = {k: ident.digest(ident.run(**ident.SCENARIOS[k])[0])
-        for k in AT_BASE}
+AT_BASE = {
+    "n1": "33886ef03f364852883f0370230e6e04823fbb46a4704f88ca75bf9082d98c01",
+    "n2": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
+    "n1_lag": "f6c67b351bd732fb69e62cafbfdb2bcff6032f5d8845836659d096b8c677d3c0",
+    "n2_lag": "666a31f41491c22750720524853d95944d5fba395d1d14040c460d71414b275f",
+}
+AT_NOW = {
+    "n1": "939b3d47bbd64fa50e3d70538f092fb98e5c4bd5ead85a7fc696a1dbb514039e",
+    "n2": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
+    "n1_lag": "78aac892975be81a7ceac0c000ed441a731bd4f42ff9f729996cbee53d6b7f02",
+    "n2_lag": "c51008213dd739e1e5142c236d9a950aa585992393e4af120086f1ba52ff3e0d",
+}
+_cmd_digest = ident.trade_digest
+_rows5 = {k: ident.run(**ident.SCENARIOS[k])[0] for k in AT_BASE}
+_got = {k: _cmd_digest(v) for k, v in _rows5.items()}
+_full5 = {k: ident.digest(v) for k, v in _rows5.items()}
 for _k in AT_BASE:
    print(f"    {_k} {'same' if _got[_k] == AT_BASE[_k] else 'DIFFERS'} "
          f"{_got[_k][:16]}")
 check("with battery modes off every command, integrator, allocation and "
-      "trade sentence equals e3e4ba6's, also when every quarter boundary's "
-      "cycle still sees the old P1 block", _got == AT_BASE)
+      "trade action equals e3e4ba6's (the sentence masked as above), also when "
+      "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 "
+      "later change to any sentence or figure fails here",
+      all(_full5[k] != AT_BASE_OLD[k] for k in AT_BASE_OLD)
+      and _full5 == AT_NOW)

 _real_project = tariff.PeakTracker.project
 tariff.PeakTracker.project = staticmethod(
    lambda a, now, roll=False: _real_project(a, now, roll=True))
 try:
-    _moved = ident.digest(ident.run(**ident.SCENARIOS["n1_lag"])[0]) \
+    _moved = _cmd_digest(ident.run(**ident.SCENARIOS["n1_lag"])[0]) \
        != AT_BASE["n1_lag"]
 finally:
    tariff.PeakTracker.project = _real_project
@@ -1178,7 +1178,7 @@ async def _modes_plan():
        c = W.ctl
        plan = c.fresh_tariff_plan(t)
        verdict = plan.arbitrage(
-            peak_guard_active=False, min_spread_eur_kwh=0.05,
+            now=t, peak_guard_active=False, min_spread_eur_kwh=0.05,
            uncertainty=frozenset())
        return verdict.match(allowed=lambda v: ("allowed", v.spread_eur_kwh),
                             refused=lambda v: ("refused", v.reason))
@@ -0,0 +1,375 @@
+"""SAFETY-118: the peak forecast is read in its own unit.  `python3 -B test_safety118.py`
+
+`peak_forecast_entity` used to be read as a bare number and anything under 50
+was multiplied by 1000, so a W sensor reading 17 W was taken as 17 kW. It is
+now read through `pv.watts()` by its own `unit_of_measurement`. No unit, or a
+unit that is not power: the forecast is not used, as if the option were empty.
+
+1. The reader through the real `read_inputs()`: W, kW, MW, no unit, kWh, bad state.
+2. The warning: once, again only when the cause changes, never every cycle.
+3. One state read per cycle, as before.
+4. The maintenance charge headroom and the charge-only clamp act on the
+   converted value (real `cycle()`).
+5. The validator, the status row and the strings.
+
+Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
+"""
+
+import asyncio
+import logging
+from pathlib import Path
+
+from app import main as _main
+from app import messages, pv, validate
+from app.main import Controller
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+def st(value, unit=None):
+    attrs = {} if unit is None else {"unit_of_measurement": unit}
+    return {"state": str(value), "attributes": attrs}
+
+
+class _Store:
+    def __init__(self, data=None):
+        self.data = dict(data or {})
+
+    def set(self, k, v):
+        self.data[k] = v
+
+    def get_time(self, *a):
+        return None
+
+    def set_time(self, *a):
+        pass
+
+
+class _Pub:
+    enabled = False
+
+    def publish(self, *a, **k):
+        pass
+
+    def close(self):
+        pass
+
+
+class _Hass:
+    def __init__(self, fc=None, prices=None):
+        self.fc = fc
+        self.prices = prices or {}
+        self.reads = []
+        self.writes = []
+
+    async def limits(self, entity):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def state(self, entity):
+        self.reads.append(entity)
+        if entity == "sensor.fc":
+            return self.fc
+        v = {"sensor.grid": 0.0, "sensor.soc": 50.0, "sensor.batt": 0.0,
+             **self.prices}.get(entity)
+        return None if v is None else st(v, "W")
+
+    async def number(self, entity, invert=False):
+        obj = await self.state(entity)
+        try:
+            return float(obj["state"]) if obj else None
+        except ValueError:
+            return None
+
+    async def set_number(self, entity, value):
+        self.writes.append(float(value))
+        return True
+
+    async def call(self, domain, service, data):
+        return True
+
+
+OPTS = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+        "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+        "meter_source": "off", "heartbeat_s": 10, "stale_input_s": 15,
+        "max_w": 5000.0, "gain": 0.6, "slew_w": 400.0, "deadband_w": 15,
+        "step_w": 10, "target_grid_w": -10.0, "stale_input_s": 15,
+        "peak_cap_w": 5000, "peak_margin_w": 0,
+        "peak_forecast_entity": "sensor.fc"}
+
+
+class _Rec(logging.Handler):
+    def __init__(self):
+        super().__init__(logging.DEBUG)
+        self.rows = []
+
+    def emit(self, r):
+        self.rows.append((r.levelno, r.getMessage()))
+
+
+def make(fc, store=None, prices=None, **over):
+    hass = _Hass(fc, prices)
+    c = Controller(dict(OPTS, **over), hass, _Store(store), _Pub(),
+                   stop=asyncio.Event())
+    c.auto, c.dev_min, c.dev_max = True, -5000.0, 5000.0
+    return c, hass
+
+
+def reads(c):
+    asyncio.run(c.read_inputs())
+    return c.peak_fc
+
+
+def peak_of(state):
+    c, _h = make(state)
+    return reads(c)
+
+
+print("1. the reader")
+CASES = [("W 17", st(17, "W"), 17.0), ("W 820", st(820, "W"), 820.0),
+         ("kW 0.82", st(0.82, "kW"), 820.0), ("kW 0.017", st(0.017, "kW"), 17.0),
+         ("MW 0.0008", st(0.0008, "MW"), 800.0), ("W 49", st(49, "W"), 49.0),
+         ("W 50", st(50, "W"), 50.0), ("kW 30", st(30, "kW"), 30000.0),
+         ("W 0", st(0, "W"), 0.0)]
+for label, s, want in CASES:
+    got = peak_of(s)
+    check(f"{label} -> {want} W (got {got})",
+          got is not None and abs(got - want) < 1e-6)
+for label, s in [("no unit", st(820)), ("empty unit", st(820, "")),
+                 ("kWh", st(820, "kWh")), ("percent", st(20, "%")),
+                 ("unavailable", st("unavailable", "W")),
+                 ("unknown", st("unknown", "W")), ("missing entity", None),
+                 ("not a number", st("sunny", "W"))]:
+    check(f"{label} -> None (got {peak_of(s)})", peak_of(s) is None)
+c, _h = make(st(820, "W"), peak_forecast_entity="")
+check("option empty -> None and the entity is never read",
+      reads(c) is None and "sensor.fc" not in _h.reads)
+
+print("2. the warning")
+rec = _Rec()
+lg = logging.getLogger("goodwe")
+lg.addHandler(rec)
+lg.setLevel(logging.DEBUG)
+
+
+def warns():
+    return [m for lv, m in rec.rows if lv >= logging.WARNING]
+
+
+c, h = make(st(820, "kWh"))
+for _ in range(5):
+    reads(c)
+check(f"kWh: five cycles, one WARNING ({warns()})", len(warns()) == 1)
+check("...short, plain, and says it is not used",
+      warns()[0] == "The 15-minute demand forecast is not in a power unit, so "
+      "it is not used." and len(warns()[0].split()) <= 25)
+h.fc = st(820, "MWh")
+reads(c)
+check("the same cause with another unit warns again (the cause changed)",
+      len(warns()) == 2)
+h.fc = st(820)
+reads(c)
+check("no unit is a different cause and warns", len(warns()) == 3
+      and "has no unit" in warns()[2])
+reads(c)
+check("...and only once", len(warns()) == 3)
+USED = (logging.INFO, "The 15-minute demand forecast is used again.")
+
+
+def used():
+    return [r for r in rec.rows if r == USED]
+
+
+h.fc = st("unavailable")
+reads(c)
+check("unavailable adds no warning and no 'used again'",
+      len(warns()) == 3 and not used())
+h.fc = st(820, "W")
+reads(c)
+check("a good unit is read again: one INFO, no new warning",
+      c.peak_fc == 820.0 and len(warns()) == 3 and len(used()) == 1
+      and rec.rows[-1] == USED)
+n = len(warns())
+for s in (st(820, "W"), st(0.8, "kW")):
+    h.fc = s
+    reads(c)
+check("W and kW never warn", len(warns()) == n)
+rows = [r for r in c.checks() if r.get("id") == "peak_forecast"]
+check("a good forecast has no peak_forecast row", not rows)
+h.fc = st(820, "kWh")
+reads(c)
+rows = [r for r in c.checks() if r.get("id") == "peak_forecast"]
+check("the status page carries a caution row for the unit fault",
+      len(rows) == 1 and rows[0]["warn"] and not rows[0]["ok"]
+      and rows[0]["text"] == messages.row_peak_forecast_unit("kWh"))
+lg.removeHandler(rec)
+
+print("3. one state read per cycle")
+c, h = make(st(0.82, "kW"))
+reads(c)
+check(f"one read of the forecast entity per read_inputs() ({h.reads})",
+      h.reads.count("sensor.fc") == 1)
+
+print("4. maintenance headroom and the charge-only clamp use watts")
+seen = []
+_real = _main.maintenance_charge_floor
+
+
+def spy(charge_w, fc, cap):
+    out = _real(charge_w, fc, cap)
+    seen.append((charge_w, fc, cap, out))
+    return out
+
+
+_main.maintenance_charge_floor = spy
+try:
+    def cycle(fc, **kw):
+        c, h = make(fc, store={"phase": "charge"},
+                    prices={"sensor.pnow": 1.0, "sensor.pavg": 2.0},
+                    price_now_entity="sensor.pnow",
+                    price_avg_entity="sensor.pavg", **kw)
+        seen.clear()
+        asyncio.run(c.read_inputs())
+        asyncio.run(c.cycle())
+        return c, h
+
+    # cap 2500 W, charge rate 2000 W: 820 W of forecast leaves 1680 W, 17 W
+    # leaves the whole 2000 W (the size rule read 17 as 17 kW and left 0).
+    c, h = cycle(st(0.82, "kW"), peak_cap_w=2500)
+    check(f"cheap-window headroom is cap - 820 W = 1680 W ({seen})",
+          len(seen) == 1 and seen[0][1] == 820.0 and seen[0][0] == 2000.0
+          and abs(seen[0][3] - 1680.0) < 1e-6)
+    c, h = cycle(st(17, "W"), peak_cap_w=2500)
+    check(f"a 17 W forecast leaves the full 2000 W charge rate ({seen})",
+          len(seen) == 1 and seen[0][1] == 17.0 and abs(seen[0][3] - 2000.0) < 1e-6)
+    # charge-only clamp: not cheap, shaping suspended only if the forecast is
+    # over the aim.  6 kW is over 5000 W; 17 W is not (the old rule read it
+    # as 17 kW and suspended).
+    def clamp(fc):
+        c, h = make(fc, store={"phase": "charge"})
+        asyncio.run(c.read_inputs())
+        asyncio.run(c.cycle())
+        return c._maint_shape_suspended
+    check("kW 6.0 (6000 W, over the 5000 W aim) suspends the charge-only clamp",
+          clamp(st(6.0, "kW")) is True)
+    check("W 17 leaves the charge-only clamp in place",
+          clamp(st(17, "W")) is False)
+    check("kW 0.017 leaves the charge-only clamp in place",
+          clamp(st(0.017, "kW")) is False)
+    check("no unit: forecast unused, clamp in place, as with the option empty",
+          clamp(st(6000)) is False)
+finally:
+    _main.maintenance_charge_floor = _real
+
+print("5. validator and strings")
+def notes(unit, key="peak_forecast_entity"):
+    ent = {"sensor.fc": {"entity_id": "sensor.fc", "unit": unit,
+                         "state": "1"}}
+    return [n for n in validate.config_notes(
+        {key: "sensor.fc", "meter_source": "off"}, entities=ent)
+        if key in n.keys]
+
+
+check("validator: W no note", not notes("W"))
+check("validator: kW no note", not notes("kW"))
+check("validator: MW no note", not notes("MW"))
+nu, kw = notes(""), notes("kWh")
+check(f"validator: no unit warns ({nu})", len(nu) == 1 and nu[0].tier == "warn"
+      and "has no unit" in nu[0].text)
+check(f"validator: kWh warns ({kw})", len(kw) == 1 and kw[0].tier == "warn"
+      and "not in a power unit" in kw[0].text)
+check("validator: the false 'taken as watts' claim is gone for this entity",
+      not any("taken as watts" in n.text for n in nu + kw + notes("kW")))
+check("validator: another watt key keeps its claim",
+      len(notes("kW", "batt_entity")) == 1
+      and "taken as watts" in notes("kW", "batt_entity")[0].text)
+check("WATT_ENTITY_KEYS no longer holds the peak forecast",
+      "peak_forecast_entity" not in validate.WATT_ENTITY_KEYS
+      and "batt_entity" in validate.WATT_ENTITY_KEYS)
+print("   EN no unit :", messages.peak_forecast_unit(""))
+print("   EN bad unit:", messages.peak_forecast_unit("kWh"))
+print("   NL no unit :", messages.peak_forecast_unit("", "nl"))
+print("   NL bad unit:", messages.peak_forecast_unit("kWh", "nl"))
+check("the strings differ by cause and by language",
+      len({messages.peak_forecast_unit(u, l) for u in ("", "kWh")
+           for l in ("en", "nl")}) == 4)
+print("6. a missing reading leaves the unit fault as it was (F1)")
+
+
+lg.addHandler(rec)
+
+
+def prow(c):
+    return [r for r in c.checks() if r.get("id") == "peak_forecast"]
+
+
+def flap(first, gap, last):
+    """first, gap, first again (or last): the log rows and the status row
+    after each cycle."""
+    rec.rows.clear()
+    c, h = make(first)
+    out = []
+    for s in (first, gap, last):
+        h.fc = s
+        reads(c)
+        out.append((len(warns()), len(used()), len(prow(c)), c.peak_fc))
+    return out
+
+
+for label, first, gap in [
+        ("kWh -> unavailable -> kWh", st(820, "kWh"), st("unavailable", "kWh")),
+        ("kWh -> unknown -> kWh", st(820, "kWh"), st("unknown", "kWh")),
+        ("kWh -> failed read -> kWh", st(820, "kWh"), None),
+        ("kWh -> non-numeric -> kWh", st(820, "kWh"), st("sunny", "kWh")),
+        ("no unit -> failed read -> no unit", st(820), None),
+        ("no unit -> unavailable -> no unit", st(820), st("unavailable"))]:
+    r = flap(first, gap, first)
+    check(f"{label}: one WARNING, no 'used again', row on all 3 ({r})",
+          [x[0] for x in r] == [1, 1, 1] and [x[1] for x in r] == [0, 0, 0]
+          and [x[2] for x in r] == [1, 1, 1]
+          and [x[3] for x in r] == [None, None, None])
+r = flap(st(820, "kWh"), st("unavailable", "kWh"), st(820, "W"))
+check(f"kWh -> unavailable -> W: the fault clears only on the W reading ({r})",
+      [x[1] for x in r] == [0, 0, 1] and [x[2] for x in r] == [1, 1, 0]
+      and [x[0] for x in r] == [1, 1, 1] and r[2][3] == 820.0)
+rec.rows.clear()
+c, h = make(st(820, "W"))
+for s in (st(820, "W"), st("unavailable", "W"), None, st("sunny", "W")):
+    h.fc = s
+    reads(c)
+    check(f"good unit, reading {s and s['state']!r}: no row, no log",
+          not prow(c) and not warns() and not used())
+rec.rows.clear()
+c, h = make(st(820, "kWh"))
+reads(c)
+for s in (st("unavailable", "kWh"), None):
+    h.fc = s
+    reads(c)
+    check("fault row stays while the reading is missing",
+          len(prow(c)) == 1 and prow(c)[0]["text"]
+          == messages.row_peak_forecast_unit("kWh"))
+c, h = make(st(820, "W"))
+h.fc = st("unavailable", "W")
+reads(c)
+check("good-unit sensor only unavailable: the fault row stays away",
+      not prow(c))
+lg.removeHandler(rec)
+check("has_reading: numbers only",
+      pv.has_reading(st(0, "kWh")) and pv.has_reading(st("1.5"))
+      and not pv.has_reading(None) and not pv.has_reading(st("unavailable"))
+      and not pv.has_reading(st("unknown")) and not pv.has_reading(st("x")))
+check("pv.unit_fault: None for a good unit and for a missing reading (has_reading tells them apart)",
+      pv.unit_fault(st(1, "kW")) is None and pv.unit_fault(None) is None
+      and pv.unit_fault(st("unavailable")) is None
+      and pv.unit_fault(st(1)) == "" and pv.unit_fault(st(1, "kWh")) == "kWh")
+src = (Path(__file__).parent / "app" / "main.py").read_text(encoding="utf-8")
+check("the size rule is gone from main.py", "abs(raw) < 50" not in src)
+
+print()
+print("FAILED: " + "; ".join(fails) if fails else "all checks passed")
+raise SystemExit(1 if fails else 0)
@@ -0,0 +1,737 @@
+"""Runnable check for SAFETY-119: no "Battery is not keeping up" when the
+loop takes the wire back from another owner. `python3 test_safety119.py`
+
+During a maintenance charge with no usable peak forecast, the measured peak
+guard steps in during a quarter's last seconds and hands back. On the cycle
+the loop gets the wire back, its integrator is re-seeded from the other
+owner's command and kicked by a meter reading taken before the battery moved.
+It crossed its rail for one or two cycles, the loop's ask beat the one-sided
+limit, so the cycle counted as the loop's own and raised
+`goodwe_integrator_bound`. The battery gave what it was told. Now the loop's
+bound does not count until the plant's settle (SHORT_CYCLES cycles and
+SHORT_SPAN_S) has passed since the hand-back. SAFETY-121: the settle is
+HANDBACK_CYCLES (4) cycles and SHORT_SPAN_S (22 s), and across all
+hand-backs the bound is hidden on at most ROLLING_BOUND_CYCLES (11) cycles in
+any ROLLING_S (900 s), at every cycle length.
+DECISIONS/SAFETY-119-bound-after-hand-back.md,
+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.
+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).
+3. With a usable forecast: the same commands and the same alarms as without
+   the fix.
+4. Repeated hand-backs (N=2, the guard and the charge take turns), 2, 5, 10
+   and 15 s meters: it warns in every quarter, both with the meter a cycle
+   behind the battery reading and in the rig's shape (SAFETY-121, F-1: the
+   meter read in the same cycle, 1 to 5 bound cycles a quarter), where
+   SAFETY-119's settle of 12 cycles hid every quarter but one; the
+   quarter-edge case stays silent at 2, 5, 10 and 15 s; the budget's margins
+   (8 warns at the quarter edge, 14 misses quarters); a start or a blind
+   cycle is not a hand-back; the delay after one hand-back.
+5. The rule at its boundaries (`Controller._settling`): the settle, the
+   rolling budget, and a stop that does not give the budget back.
+6. test_safety84's and test_safety87's re-pinned digests: the same commands
+   and claims; only OUTPUT_CLAMP log rows differ.
+
+Mutations (MUTATION.md, purged copies) are listed in the pull request.
+"""
+
+import logging
+import math
+import os
+import random
+import sys
+import time
+from datetime import timedelta
+
+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 safety79_identity as s79                                # noqa: E402
+import safety84_identity as s84                                # noqa: E402
+import app.main as app_main                                    # noqa: E402
+from app import messages                                       # noqa: E402
+from app.main import Controller                                # noqa: E402
+from app.p1 import make_sample, split_signed                   # noqa: E402
+from named_absence import first, nth, present                  # noqa: E402
+
+fails = []
+OPT0 = dict(s84.OPT)
+CAP = 2500.0
+QUARTER = 900.0
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+async def _call(self, *a):
+    """The rig's Home Assistant, recording each notification (time, id)."""
+    if len(a) >= 3 and a[1] == "create" and isinstance(a[2], dict):
+        self.__dict__.setdefault("notes", []).append(
+            (self.t, a[2].get("notification_id")))
+    return True
+
+
+def _power(self, u, lag=1.0):
+    """The TEST-23 plant's battery: 800 W/s ramp, 1 s first-order lag."""
+    st = self.__dict__.setdefault("_plant", {})
+    a, tgt, tl = st.get(u, (0.0, 0.0, self.t))
+    for _ in range(int(round((self.t - tl) / 0.1))):
+        d = self.cmd[u] - tgt
+        tgt += math.copysign(min(abs(d), 80.0), d)
+        a += (tgt - a) * (1 - math.exp(-0.1 / lag))
+    st[u] = (a, tgt, self.t)
+    if self.cut(u, self.t) and self.cmd[u] >= -4.0:
+        return -4.0
+    return float(round(a))
+
+
+_real_number, _real_power = rig._Hass.number, rig._Hass.power
+_real_feed = s79._feed
+
+
+async def _number(self, e, invert=False):
+    """sensor.fc: a usable demand forecast of 800 W (part 3)."""
+    if e == "sensor.fc":
+        return 800.0
+    return await _real_number(self, e, invert)
+
+
+rig._Hass.call, rig._Hass.power, rig._Hass.number = _call, _power, _number
+rig.TICK = 1.0
+DELAY = [1]
+
+
+def _feed(c, t):
+    """The P1 meter `DELAY` ticks behind the battery, as on the rig (the
+    meter reached HA after the battery reading). Records the true grid."""
+    h = c.hass.__dict__.setdefault("grid_true", [])
+    h.append((t, c.hass.grid()))
+    g = h[max(0, len(h) - 1 - DELAY[0])][1]
+    imp, exp = split_signed(g)
+    c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
+                            ingest_ts=rig.BASE + timedelta(seconds=t),
+                            ingest_mono=time.monotonic()))
+
+
+s79._feed = _feed
+
+
+def house(seed, base=800.0, step=None):
+    """800 W +- 30 W, a new value each second; `step` = (t, W) from then."""
+    rnd = random.Random(seed)
+    noise = [rnd.uniform(-30.0, 30.0) for _ in range(4000)]
+
+    def load(t):
+        if step is not None and t >= step[0]:
+            return step[1]
+        return base + noise[int(t) % 4000]
+    return load
+
+
+def run(load, *, n=1, dur=7200.0, delay=1, extra=None, cheap=True, cut=None,
+        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."""
+    extra = dict(extra or {})
+    s84.OPT = dict(OPT0, peak_cap_w=int(CAP * n), peak_margin_w=50,
+                   maintenance_charge_w=2000)
+    if not charging:
+        extra.update(maintenance_enabled=False, peak_cap_w=20000)
+    for k in [k for k in extra if k in s84.OPT]:
+        s84.OPT[k] = extra.pop(k)
+    DELAY[0] = delay
+    try:
+        feed = s84.feed(cheap)
+
+        def before(c, t):
+            if t >= blind:                  # before that: no meter reading
+                return feed(c, t)
+        return s84.run(n, load=load, cheap=cheap,
+                       store=(s79.store_charging(n) if charging
+                              else rig._Store()),
+                       soc=lambda u, t: 60.0, dur=dur, cut=cut,
+                       before=before if blind else None,
+                       extra=dict({"max_w": 2500, "slew_w": 0}, **extra))
+    finally:
+        s84.OPT = OPT0
+
+
+def patched(obj, name, value):
+    def wrap(fn):
+        real = getattr(obj, name)
+        setattr(obj, name, value)
+        try:
+            return fn()
+        finally:
+            setattr(obj, name, real)
+    return wrap
+
+
+no_fix = patched(Controller, "_settling", lambda self, owns, now: False)
+
+
+def notes(c):
+    return [t for t, i in getattr(c.hass, "notes", [])
+            if i == messages.ID_LOOP_BOUND]
+
+
+def quarters(c, tick=1.0):
+    """Each whole quarter's true average import (W)."""
+    q = {}
+    for t, g in c.hass.grid_true:
+        q.setdefault(int(t // QUARTER), []).append(g)
+    return [sum(v) / len(v) for v in q.values()
+            if len(v) == QUARTER / tick]
+
+
+def commands(rows):
+    return [(r[0], r[1], r[2]) for r in rows]
+
+
+def guard_steps(c):
+    return sum(1 for e in c.events if "PEAK_GUARD:" in e)
+
+
+# ============================================================================ #
+print("1. a maintenance charge with no forecast, the guard steps in at each "
+      "quarter's end, 2 h")
+NEW, OLD = {}, {}
+for seed, delay in ((1, 1), (2, 1), (3, 2)):
+    NEW[seed] = run(house(seed), delay=delay)
+    OLD[seed] = no_fix(lambda: run(house(seed), delay=delay))
+    print(f"    seed {seed} meter {delay} s behind: notifications "
+          f"{notes(NEW[seed][1])} (without the fix {notes(OLD[seed][1])}), "
+          f"highest quarter {max(quarters(NEW[seed][1])):.0f} W, guard "
+          f"step-ins in the last 40 log rows {guard_steps(NEW[seed][1])}")
+check("⭐ no 'Battery is not keeping up' notification, cycle or episode",
+      all(notes(c) == [] and c.clamp_wd.bound == 0
+          and c.clamp_wd.bound_episodes == 0 for _r, c in NEW.values()))
+check("⭐ the peak cap is held: every quarter's average is under 2500 W",
+      all(len(quarters(c)) == 8 and max(quarters(c)) < CAP
+          for _r, c in NEW.values()))
+check("⭐ control is unchanged: every command the same as without the fix",
+      all(commands(NEW[k][0]) == commands(OLD[k][0]) for k in NEW))
+check("...the charge ran and the guard stepped in near each quarter's end",
+      all(any(r[1] == -2000.0 for r in rows) and any(
+          r[-1][1] and r[-1][1][0] and r[0] % QUARTER >= QUARTER - 40
+          for r in rows) for rows, _c in NEW.values()))
+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)))
+
+# ============================================================================ #
+print("\n2. a genuine integrator bound still warns")
+_rail = run(house(1, base=4000.0), dur=600.0,
+            charging=False)
+_rail_old = no_fix(lambda: run(house(1, base=4000.0), dur=600.0,
+                                 charging=False))
+print(f"    loop in charge, house 4000 W over the 2500 W rating: "
+      f"{notes(_rail[1])}, without the fix {notes(_rail_old[1])}")
+check("⭐ the loop in charge at its rail warns (log and notification), at "
+      "the same cycle as before",
+      len(notes(_rail[1])) >= 1 and notes(_rail[1]) == notes(_rail_old[1])
+      and _rail[1].clamp_wd.bound == _rail_old[1].clamp_wd.bound
+      and any("OUTPUT_CLAMP episode" in e for e in _rail[1].events))
+
+# The charge sets the wire until 600 s, then a solar surplus of 6000 W: the
+# loop takes the wire back and stands at its -2500 W rail.
+_hb = run(house(1, step=(600.0, -6000.0)), dur=1200.0,
+          extra={"peak_cap_w": 20000})
+_hb_old = no_fix(lambda: run(house(1, step=(600.0, -6000.0)), dur=1200.0,
+                             extra={"peak_cap_w": 20000}))
+_first = notes(_hb[1])[:1]
+print(f"    hand-back to a loop at its rail at 600 s: first notification "
+      f"{_first}, without the fix {notes(_hb_old[1])[:1]}; command at the "
+      f"end {_hb[0][-1][1]}")
+MB = 11                       # the budget (at 1 s it ends the settle)
+check(f"⭐ the loop at its rail after a hand-back still warns, once "
+      f"{MB} of its bound cycles are hidden (1 s meter: {MB} s)",
+      _first and 600.0 + MB <= _first[0] <= 600.0 + MB + 4.0
+      and _hb[0][-1][1] == -2500.0
+      and _hb[1].clamp_wd.bound > 100)
+check("...without the fix it warned at once (non-vacuous)",
+      notes(_hb_old[1])[:1] and notes(_hb_old[1])[0] < 600.0 + MB)
+# The same charge with no forecast; at 1795 s, under the guard's step-in at
+# the quarter's end, the house goes to 4000 W, over the 2500 W rating.
+_up = run(house(1, step=(1795.0, 4000.0)), dur=1900.0)
+_up_old = no_fix(lambda: run(house(1, step=(1795.0, 4000.0)), dur=1900.0))
+print(f"    guard step-in, then the house over the rating from 1795 s: "
+      f"{notes(_up[1])}, without the fix {notes(_up_old[1])}")
+check("⭐ a genuine bound in the rig's own scenario still warns, within the "
+      "settle of the guard's hand-back",
+      notes(_up[1]) and 1795.0 <= notes(_up[1])[0] <= 1795.0 + 40.0
+      and any("OUTPUT_CLAMP episode" in e for e in _up[1].events))
+
+# ============================================================================ #
+print("\n3. with a usable forecast (800 W): unchanged")
+FC = {"peak_forecast_entity": "sensor.fc"}
+_fc = run(house(1), extra=FC)
+_fc_old = no_fix(lambda: run(house(1), extra=FC))
+print(f"    notifications {notes(_fc[1])} (without the fix "
+      f"{notes(_fc_old[1])}), highest quarter "
+      f"{max(quarters(_fc[1])):.0f} W, charge "
+      f"{min(r[1] for r in _fc[0][:300]):.0f} W")
+check("⭐ the same commands and the same alarms as without the fix, and "
+      "the cap held",
+      commands(_fc[0]) == commands(_fc_old[0])
+      and notes(_fc[1]) == notes(_fc_old[1])
+      and _fc[1].clamp_wd.engagements == _fc_old[1].clamp_wd.engagements
+      and max(quarters(_fc[1])) < CAP)
+check("...the forecast was used (the charge is shaped under -2000 W)",
+      -2000.0 < min(r[1] for r in _fc[0][:300]) < 0.0)
+
+# ============================================================================ #
+print("\n4. repeated hand-backs: the guard and the charge take turns")
+
+
+def round1(self, owns, now):
+    """Round 1's rule, kept here to show what it hid: every hand-back
+    restarts the window, so a loss within the settle never lets it end."""
+    d = self.__dict__
+    if not owns:
+        d["_r1"], d["_r1_n"] = True, None
+        return False
+    if d.get("_r1"):
+        d["_r1"], d["_r1_n"] = False, (now, 0)
+    if d.get("_r1_n") is None:
+        return False
+    t0, n = d["_r1_n"]
+    d["_r1_n"] = (t0, n + 1)
+    if n + 1 >= app_main.SHORT_CYCLES and (
+            now is None or t0 is None or now - t0 >= app_main.SHORT_SPAN_S):
+        d["_r1_n"] = None
+        return False
+    return True
+
+
+# N=2 (2 x 2500 W), a cheap-window charge, no usable forecast, the house 50 W
+# over the 5000 W rating from 300 s: the loop never held the wire for more
+# than 10 cycles. Round 1: no notification in 2 h; round 2: none at 10 s or
+# 15 s meters.
+def never(tick, hw=5050.0, fix=True, seed=0, delay=1):
+    """`seed` 0: a constant house; else 800 W +- 30 W, `hw` +- 30 W from
+    300 s. `delay` 0 is the rig's shape: the meter read in the same cycle
+    as the battery (SAFETY-121)."""
+    rig.TICK = tick
+    if seed:
+        load = (lambda t, h=house(seed):
+                h(t) + (hw - 800.0 if t >= 300.0 else 0.0))
+    else:
+        load = house(1, step=(300.0, hw))
+    try:
+        f = lambda: run(load, n=2, delay=delay)
+        return f() if fix else no_fix(f)
+    finally:
+        rig.TICK = 1.0
+
+
+def per_quarter(c):
+    return [sum(1 for t in notes(c) if int(t // QUARTER) == q)
+            for q in range(8)]
+
+
+def every_quarter(c):
+    return all(n >= 1 for n in per_quarter(c)[1:])
+
+
+_nv = {t: never(t) for t in (2.0, 5.0, 10.0, 15.0)}
+_nv_old = {t: never(t, fix=False) for t in (2.0, 5.0, 10.0, 15.0)}
+_nv_r1 = patched(Controller, "_settling", round1)(lambda: never(5.0))
+for _t in _nv:
+    print(f"    N=2, {_t:.0f} s meter, house 5050 W: notifications "
+          f"{len(notes(_nv[_t][1]))} (per quarter "
+          f"{per_quarter(_nv[_t][1])}), without the fix "
+          f"{len(notes(_nv_old[_t][1]))}, highest quarter "
+          f"{max(quarters(_nv[_t][1], _t)):.0f} W")
+print(f"    round 1's rule at 5 s: {len(notes(_nv_r1[1]))}")
+check("⭐ 2, 5, 10 and 15 s meters: it warns in every quarter after the "
+      "first (round 2 gave none at 10 and 15 s)",
+      all(every_quarter(_nv[t][1]) for t in _nv))
+check("non-vacuous: round 1's rule (a window per hand-back) never warned "
+      "here, and the fix still hides some of what was raised without it",
+      notes(_nv_r1[1]) == [] and all(
+          _nv[t][1].clamp_wd.bound < _nv_old[t][1].clamp_wd.bound
+          for t in _nv))
+check("...every command is the same as without the fix, at 2, 5, 10 and "
+      "15 s",
+      all(commands(_nv[t][0]) == commands(_nv_old[t][0]) for t in _nv))
+check("...and at 5 s the cap held",
+      len(quarters(_nv[5.0][1], 5.0)) == 8
+      and max(quarters(_nv[5.0][1], 5.0)) < 5000.0)
+
+# SAFETY-121, the rig's shape (TEST-23, F-1): the meter is read in the same
+# cycle as the battery, so the guard's charge headroom is right after it
+# hands back and the guard and the charge do not chase each other. The loop
+# then holds the wire once a quarter, at its start, and is at its bound on
+# 1 to 5 cycles (5 s), not 20. House 5100 W +- 30 W (5300 W at 15 s, where
+# 5100 W is over the rating in one quarter only, without the fix too).
+RIG = {1.0: 5100.0, 2.0: 5100.0, 5.0: 5100.0, 10.0: 5100.0, 15.0: 5300.0}
+_rg = {t: never(t, hw, seed=1, delay=0) for t, hw in RIG.items()}
+_rg_old = {t: never(t, hw, fix=False, seed=1, delay=0)
+           for t, hw in RIG.items()}
+# SAFETY-119 as merged (bee7431) at 5 s: a settle of 12 cycles, budget 8.
+_rg_119 = patched(app_main, "HANDBACK_CYCLES", app_main.SHORT_CYCLES)(
+    lambda: patched(app_main, "ROLLING_BOUND_CYCLES", 8)(
+        lambda: never(5.0, 5100.0, seed=1, delay=0)))
+for _t in _rg:
+    print(f"    rig shape, {_t:.0f} s meter, house {RIG[_t]:.0f} W: per "
+          f"quarter {per_quarter(_rg[_t][1])}, without the fix "
+          f"{per_quarter(_rg_old[_t][1])}, highest quarter "
+          f"{max(quarters(_rg[_t][1], _t)):.0f} W")
+print(f"    rig shape, 5 s, SAFETY-119's settle and budget: per quarter "
+      f"{per_quarter(_rg_119[1])}")
+check("⭐ the rig's shape at 1, 2, 5, 10 and 15 s meters: it warns in every "
+      "quarter after the first, as without the fix",
+      all(every_quarter(_rg[t][1]) and every_quarter(_rg_old[t][1])
+          for t in _rg))
+check("non-vacuous (F-1): with SAFETY-119's settle of 12 cycles and budget "
+      "of 8, the rig's shape at 5 s warns in at most one quarter",
+      sum(1 for n in per_quarter(_rg_119[1])[1:] if n) <= 1)
+check("...every command the same as without the fix, and the cap held at "
+      "1 to 10 s",
+      all(commands(_rg[t][0]) == commands(_rg_old[t][0]) for t in _rg)
+      and all(max(quarters(_rg[t][1], t)) < 5000.0
+              for t in (1.0, 2.0, 5.0, 10.0)))
+
+# The quarter-edge case (part 1) at the slower meters: still no warning.
+# The meter's own lag limits the cap there, the same with and without the fix.
+_qe = {}
+for _t in (2.0, 5.0, 10.0, 15.0):         # with part 1: 1, 2, 5, 10, 15 s
+    rig.TICK = _t
+    for _seed, _dl in ((1, 1), (2, 1), (3, 2)):
+        _qe[_t, _seed] = (run(house(_seed), delay=_dl),
+                          no_fix(lambda: run(house(_seed), delay=_dl)))
+    rig.TICK = 1.0
+    print(f"    {_t:.0f} s meter, quarter edge: notifications "
+          f"{[len(notes(r[0][1])) for k, r in _qe.items() if k[0] == _t]} "
+          f"(without the fix "
+          f"{[len(notes(r[1][1])) for k, r in _qe.items() if k[0] == _t]})")
+check("⭐ the quarter-edge case at 2, 5, 10 and 15 s meters, seeds 1 to 3: "
+      "no notification",
+      all(notes(r[0][1]) == [] and r[0][1].clamp_wd.bound == 0
+          for r in _qe.values()))
+check("...every command the same as without the fix; without it the false "
+      "alarm is there at each meter (non-vacuous)",
+      all(commands(r[0][0]) == commands(r[1][0]) for r in _qe.values())
+      and all(any(len(notes(_qe[_t, k][1][1])) >= 1 for k in (1, 2, 3))
+              for _t in (2.0, 5.0, 10.0, 15.0)))
+
+# The budget's margins (DECISIONS/SAFETY-121): 9 to 13 met both cases in the
+# sweep. 8 warns at the quarter edge (2 s, seed 25); 14 misses quarters in
+# the rig's shape (1 s, house 5050 W, seed 1).
+rig.TICK = 2.0
+_q25 = (run(house(25), delay=2),
+        patched(app_main, "ROLLING_BOUND_CYCLES", 8)(
+            lambda: run(house(25), delay=2)))
+rig.TICK = 1.0
+_m14 = patched(app_main, "ROLLING_BOUND_CYCLES", 14)(
+    lambda: never(1.0, 5050.0, seed=1, delay=0))
+_m11 = never(1.0, 5050.0, seed=1, delay=0)
+print(f"    2 s, quarter edge, seed 25: {notes(_q25[0][1])}, budget 8 "
+      f"{notes(_q25[1][1])}; rig shape 1 s 5050 W per quarter "
+      f"{per_quarter(_m11[1])}, budget 14 {per_quarter(_m14[1])}")
+check("...the budget's margins: 11 is silent at 2 s seed 25 and warns every "
+      "quarter in the rig's shape at 1 s and 5050 W; 8 warns there, 14 "
+      "misses a quarter there",
+      notes(_q25[0][1]) == [] and len(notes(_q25[1][1])) >= 1
+      and every_quarter(_m11[1]) and not every_quarter(_m14[1]))
+check("the rule is the one the sweep chose. Changing it means re-running "
+      "the sweep in DECISIONS/SAFETY-121-bound-every-quarter.md",
+      app_main.HANDBACK_CYCLES == 4 and app_main.ROLLING_BOUND_CYCLES == 11
+      and app_main.ROLLING_S == 900.0 and app_main.SHORT_SPAN_S == 22.0)
+
+# A start, or a blind cycle, is not a hand-back: the loop at its rail after
+# 20 s of not running warns at once (R2: a restart counted as a hand-back).
+_bl = run(house(1, base=4000.0), dur=120.0, charging=False, blind=20.0)
+_bl_old = no_fix(lambda: run(house(1, base=4000.0), dur=120.0,
+                             charging=False, blind=20.0))
+print(f"    the loop not running until 20 s, then at its rail: "
+      f"{notes(_bl[1])}, without the fix {notes(_bl_old[1])}")
+check("⭐ a start after a blind spell is not a hand-back: it warns at the "
+      "same cycle as without the fix",
+      notes(_bl[1])[:1] and 20.0 <= notes(_bl[1])[0] <= 26.0
+      and notes(_bl[1]) == notes(_bl_old[1]))
+
+# One hand-back to a loop at its rail at 600 s: the first warning comes when
+# the settle ends, 22 s and 4 cycles after it (SAFETY-119: 12 cycles, 40 s at
+# 5 s and 80 s at 10 s).
+_sl = {}
+for _t in (5.0, 10.0):
+    rig.TICK = _t
+    _sl[_t] = run(house(1, step=(600.0, -6000.0)), dur=900.0,
+                  extra={"peak_cap_w": 20000})
+    rig.TICK = 1.0
+_sl1 = {t: [x for x in notes(r[1]) if x >= 600.0][:1] for t, r in _sl.items()}
+print(f"    hand-back to a loop at its rail at 600 s, first notification: "
+      f"5 s {_sl1[5.0]}, 10 s {_sl1[10.0]}")
+check("⭐ one hand-back (the loop has the wire from the cycle after the "
+      "step): the first warning comes 25 s after it at a 5 s meter (the "
+      "22 s span), 30 s after it at 10 s (4 cycles)",
+      _sl1[5.0] == [630.0] and _sl1[10.0] == [640.0])
+
+# ============================================================================ #
+print("\n5. the rule at its boundaries")
+
+
+class _C:
+    _settling = Controller._settling
+
+    def __init__(self):
+        self._wire_lost, self._handback, self._hidden = False, None, ()
+        self.loop_clamped = (False, "", False)
+
+
+def seq(c, steps):
+    """(owned, time[, the loop's bound that cycle]) -> does it count not."""
+    out = []
+    for st in steps:
+        c.loop_clamped = (len(st) > 2 and st[2], "", False)
+        out.append(c._settling(st[0], st[1]))
+    return out
+
+
+SPAN = app_main.SHORT_SPAN_S
+K, M, ROLL = 4, 11, 900.0     # the chosen rule, written out on purpose
+_c = _C()
+check("from the start, owned every cycle: never settling (no hand-back)",
+      seq(_c, [(True, float(i)) for i in range(30)]) == [False] * 30)
+_c = _C()
+_out = seq(_c, [(False, 0.0)] + [(True, 2.0 * i) for i in range(1, 15)])
+check(f"after another owner at 2 s: settling for 11 owned cycles, then not "
+      f"(the span, {SPAN:.0f} s, decides)",
+      _out == [False] + [True] * 11 + [False] * 3)
+_c = _C()
+_out = seq(_c, [(False, 0.0)] + [(True, 0.5 * i) for i in range(1, 60)])
+_end = _out.index(False, 1) if False in _out[1:] else -1
+check(f"at a 0.5 s meter the span decides: settling until {SPAN:.0f} s",
+      _end == 1 + int(SPAN / 0.5) and all(_out[1:_end]))
+_set = {}
+for _tick in (10.0, 30.0, 60.0):
+    _c = _C()
+    _set[_tick] = seq(_c, [(False, 0.0)]
+                      + [(True, _tick * i) for i in range(1, K + 2)])
+check(f"at 10, 30 and 60 s the cycles decide: settling for {K - 1} owned "
+      f"cycles, then not (SAFETY-119: 11)",
+      all(o == [False] + [True] * (K - 1) + [False] * 2
+          for o in _set.values()))
+_c = _C()
+_out = seq(_c, [(False, 0.0), (True, 2.0), (True, 4.0), (False, 6.0),
+                (True, 8.0), (True, 10.0)])
+check("losing the wire again restarts the settle",
+      _out == [False, True, True, False, True, True]
+      and _c._handback == (8.0, 2))
+_c = _C()
+check("no monotonic clock: the cycle count alone decides",
+      seq(_c, [(False, None)] + [(True, None)] * (K + 1))
+      == [False] + [True] * (K - 1) + [False] * 2)
+
+# One hand-back, the loop's bound on every cycle: the settle (5 s) or the
+# budget (1 s) ends the hiding.
+_c = _C()
+_o5 = seq(_c, [(False, 0.0)] + [(True, 5.0 * i, True) for i in range(1, 9)])
+_c = _C()
+_o1 = seq(_c, [(False, 0.0)] + [(True, 1.0 * i, True) for i in range(1, 21)])
+check("one hand-back, the bound on every cycle: 5 hidden at 5 s (22 s), "
+      f"then counted; {M} hidden at 1 s (the budget), then counted",
+      _o5 == [False] + [True] * 5 + [False] * 3
+      and _o1 == [False] + [True] * M + [False] * (20 - M))
+
+
+def turns(c, tick, lost, periods, first=0.0, bound=True):
+    """A hand-back, then `periods` x (1 owned cycle with the loop's bound,
+    `lost` cycles away). Returns [(time, hidden)] of the owned cycles."""
+    t, out = first, []
+    for _ in range(lost):
+        c._settling(False, t)
+        t += tick
+    for _ in range(periods):
+        c.loop_clamped = (bound, "", False)
+        out.append((t, c._settling(True, t)))
+        t += tick
+        for _ in range(lost):
+            c._settling(False, t)
+            t += tick
+    return out, t
+
+
+# The rolling budget: the loop's bound is hidden on at most M cycles in any
+# ROLL seconds, across all hand-backs.
+_c = _C()
+_o, _ = turns(_c, 5.0, 3, 60)
+_hid = [t for t, h in _o if h]
+check(f"across hand-backs (one bound cycle per turn, 5 s): the first {M} "
+      "are hidden, then every one counts",
+      [h for _t, h in _o[:M + 5]] == [True] * M + [False] * 5)
+check(f"...never more than {M} hidden in any {ROLL:.0f} s, and they come "
+      f"back as the oldest ages out (exactly {M} in the first {ROLL:.0f} s "
+      "after the first)",
+      all(sum(1 for x in _hid if t <= x < t + ROLL) <= M for t in _hid)
+      and sum(1 for x in _hid if x < _hid[0] + ROLL) == M
+      and any(x >= _hid[0] + ROLL for x in _hid))
+_c = _C()
+_c._hidden = (0.0,) * M
+_c._wire_lost, _c._handback = False, (ROLL - 30.0, 0)
+_c.loop_clamped = (True, "", False)
+_a = _c._settling(True, ROLL - 1.0)
+_c.loop_clamped = (True, "", False)
+_b = _c._settling(True, ROLL)
+check(f"the budget refills {ROLL:.0f} s after the oldest hidden cycle: "
+      f"counted at {ROLL - 1:.0f} s, hidden again at {ROLL:.0f} s",
+      _a is False and _b is True)
+_c = _C()
+_o1, _t = turns(_c, 2.0, 3, 20)
+for _ in range(12):                             # the wire away a whole settle
+    _c._settling(False, _t)
+    _t += 2.0
+_o2, _ = turns(_c, 2.0, 3, 5, first=_t)
+check("the budget is not per hand-back or per run: after a whole settle "
+      "with the wire away, a new hand-back within the same "
+      f"{ROLL:.0f} s hides nothing more",
+      [h for _t2, h in _o1[:M]] == [True] * M
+      and not any(h for _t2, h in _o2))
+_c = _C()
+_o1, _t = turns(_c, 2.0, 3, 20)
+_ = [_c._settling(True, _t + 2.0 * i) for i in range(13)]
+_c._settling(False, _t + 40.0)
+_c.loop_clamped = (True, "", False)
+check("the loop holding the wire a whole settle ends the window: the next "
+      "hand-back hides nothing more while the budget is spent",
+      _c._settling(True, _t + 42.0) is False)
+_c = _C()
+_c._wire_lost = True
+_t = 0.0
+for _ in range(M + 4):                          # an over-rating: always counts
+    _c.loop_clamped = (True, "", True)
+    _c._settling(True, _t)
+    _c._wire_lost = True
+    _t += 5.0
+_c._settling(False, _t)
+_c.loop_clamped = (True, "", False)
+check("an over-rating does not use up the budget",
+      _c._settling(True, _t + 5.0) is True and len(_c._hidden) == 1)
+
+# The budget is one number at every cycle length (SAFETY-119 scaled it).
+_bud = {}
+for _tick in (1.0, 2.0, 3.0, 5.0, 10.0, 15.0, 20.0, 30.0):
+    _c = _C()
+    _o, _ = turns(_c, _tick, 1, 14)
+    _bud[_tick] = sum(1 for _t2, h in _o if h)
+_c = _C()
+_o60, _ = turns(_c, 60.0, 1, 14)
+print(f"    hidden before the first counts, one bound cycle per turn: {_bud}; "
+      f"at 60 s, turns of 2 cycles: {sum(1 for _t2, h in _o60 if h)} of 14 "
+      "hidden (the budget never runs out: DECISIONS limit)")
+check(f"the budget does not follow the cycle length: {M} hidden at 1 to "
+      "30 s, then counted",
+      set(_bud.values()) == {M})
+
+# No monotonic clock: the budget cannot refill, so a bound that stays is
+# counted after the budget however often the wire changes hands.
+_c = _C()
+_nc = []
+for _ in range(40):
+    for _ in range(3):
+        _c._settling(False, None)
+    _c.loop_clamped = (True, "", False)
+    _nc.append(_c._settling(True, None))
+check(f"no monotonic clock, repeated hand-backs: the budget holds ({M} "
+      "hidden, then every bound counts)", _nc == [True] * M + [False] * (40 - M))
+
+# An over-rating (a command over `max_w`) is a bug, never settled away.
+_ctl = _hb[1]
+_ctl.loop_clamped = (True, "x", True)
+_ctl._wire_lost, _ctl._handback, _ctl._hidden = True, None, ()
+
+
+class _Res:
+    winner, bound_by, target_w = "loop", "", 0.0
+    unit_bounds = {}
+
+
+class _D:
+    held, target_w = False, 0.0
+
+
+_ctl._loop_decision, _ctl.allocation = _D(), None
+_ctl._loop_alarm_input(_Res())
+check("an over-rating on a hand-back cycle still counts (bug=True kept)",
+      _ctl.loop_clamped == (True, "x", True) and _ctl._handback is not None)
+_ctl.loop_clamped = (True, "y", False)
+_ctl._loop_alarm_input(_Res())
+check("...while the integrator bound on the next cycle is not counted",
+      _ctl.loop_clamped[0] is False)
+
+# A stop ends the window but does not give the budget back (review F2, X3).
+_now = _ctl._now_mono
+_ctl._hidden = (_now,) * M
+_ctl._wire_lost, _ctl._handback = True, (1.0, 3)
+_ctl._loop_decision = None                    # stopped or blind
+_ctl._loop_alarm_input(_Res())
+_st, _kept = (_ctl._wire_lost, _ctl._handback), _ctl._hidden
+_ctl._settling(False, _now + 1.0)
+_ctl.loop_clamped = (True, "", False)
+_after = _ctl._settling(True, _now + 2.0)
+check("a stop clears the window (the next start is not a hand-back) and "
+      f"keeps the budget: with {M} hidden, the bound after the next "
+      "hand-back counts",
+      _st == (False, None) and _kept == (_now,) * M and _after is False)
+print(f"    after the stop: hidden kept {len(_kept)}, the next hand-back's "
+      f"bound hidden {_after}")
+
+# ============================================================================ #
+print("\n6. the pinned digests of test_safety84 and test_safety87: only the "
+      "log changes")
+# Those harnesses run at the 5 s tick with a battery that follows at once.
+rig._Hass.power, rig.TICK, s79._feed = _real_power, 5.0, _real_feed
+rig._Hass.number = _real_number
+import safety87_identity as s87                               # noqa: E402
+
+RUNS = dict({f"s84 {k}": (lambda v=v: s84.run(**v))
+             for k, v in s84.SCENARIOS.items()},
+            **{f"s87 {k}": (lambda v=v: s87_run(v))
+               for k, v in s87.SCENARIOS.items()})
+
+
+def s87_run(v):
+    v = dict(v)
+    return s84.run(1, dur=s87.DUR, store=s87.store(v.pop("store", None)), **v)
+
+
+_moved, _gone = [], 0
+for k, fn in RUNS.items():
+    new, old = fn()[0], no_fix(fn)[0]
+    same = all(a[:-1] == b[:-1] and a[-1][:4] == b[-1][:4]
+               for a, b in zip(new, old)) and len(new) == len(old)
+    logs = {e for r in old for e in [r[-1][5]] if e} - {
+        e for r in new for e in [r[-1][5]] if e}
+    _gone += len(logs)
+    if not same or any("OUTPUT_CLAMP episode" not in e for e in logs):
+        _moved.append(k)
+    print(f"    {k}: commands and claims "
+          f"{'the same' if same else 'DIFFER'}, log rows differ {len(logs)}, "
+          f"digest {s84.digest(new)[:16]}")
+check("⭐ in all twelve, every command, loop field, claim, guard decision "
+      "and phase is the same as without the fix; the only log rows that "
+      "differ are OUTPUT_CLAMP rows (gone, or a lower count)",
+      not _moved and _gone > 0)
+
+print()
+if fails:
+    print(f"FAILED: {len(fails)} check(s)")
+    for f in fails:
+        print(f"  - {f}")
+    sys.exit(1)
+print("all SAFETY-119 checks passed")
@@ -472,6 +472,10 @@ print("\n8. the N=1 and N=2 digests")
 # charge pin stands. n2_charge and _banked change only the loop's reason and
 # claim on 2 cycles; n2_charge_dear changes commands on 98 cycles, where A's
 # pin lifts (t=1800) and B no longer jumps 1390 W, and after the surplus step.
+# SAFETY-119 re-pinned all six: only the log. OUTPUT_CLAMP rows from the
+# 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).
 PINNED = {
    "n1_charge":
        "0ed25c856456b97acb07a39299a8cb7b1a762c4d0005b88a0823c03057a80be5",
@@ -482,7 +486,7 @@ PINNED = {
    "n2_charge":
        "b16d692128f14bcce3d87b142d290e0d6b13724289680e44a05215c9eaa24a7c",
    "n2_charge_dear":
-        "00a197d89a5dd1e8b3ae6a5d1af66329a4dc4850476569c5931c125fa4d9eaee",
+        "aa2bbc677a8e2274b25ba1170de1b1635e08a3bd93105e2a38a9bb1575b5b6db",
    "n2_charge_banked":
        "a6973faea916e4c88ca1770047f94478346eeb1efa4889b154fad0747f91267f",
 }
@@ -492,7 +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), 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")))
@@ -518,13 +518,18 @@ check("...a stopped controller still says so: the peak alarm does not take "

 # ============================================================================ #
 print("\n9. N=1 is byte-identical to release/1.0 b8ddfd7")
+# SAFETY-119 re-pinned n1_crossing, n1_above and n1_charge_low: only the
+# 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).
 PINNED = {   # tools/safety87_identity.py on b8ddfd7
    "n1_under":
        "d2395ef8d74fb23607ad864d5a4bf62c03044bbd9367e873675d7ad10e8c169f",
    "n1_crossing":
        "97f7321017d9d34ee17a40dfd4abf73d915f25b9faef086a483d2b5cd124b198",
    "n1_above":
-        "45726a285aa84f40542d56482652397c3c1e212ba4fe2009f6cc52f537ccad52",
+        "9229b0f0e8addd1bd114461cc36c7f02e9734012b3b7e154d7747bd4cc69b773",
    "n1_under_banked":
        "a2876c7cc873bc4c974d2b4bd98e23bba2d007b84545587d2fe0b713b0a6249b",
    "n1_charge_low":
@@ -536,8 +541,9 @@ _now = s87.digests()
 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, under, crossing and above the reserve, in a "
-      "charge and a HOLD, and under a banked peak",
+      "log) equals b8ddfd7's (the log as re-pinned by SAFETY-121), under, "
+      "crossing and above the reserve, in a charge and a HOLD, and under a "
+      "banked peak",
      _now == PINNED)

 # ============================================================================ #
@@ -82,6 +82,11 @@ from app.validate import validate_startup_config

 HERE = Path(__file__).resolve().parent
 UTC = timezone.utc
+
+# PRICE-02: `TariffPlan.arbitrage(now=...)` is required. This instant is before every
+# point these fixtures build, so no period has ended and the whole series counts.
+from datetime import datetime as _DT, timezone as _TZ  # noqa: E402
+LONG_AGO = _DT(2000, 1, 1, tzinfo=_TZ.utc)
 fails = []


@@ -333,8 +338,8 @@ check(f"...while the two-period spread is the day/night difference "
      f"{_spread_two}, re-derived here as {DAY_P - NIGHT_P:.4f}",
      near(_spread_two, DAY_P - NIGHT_P, 1e-9))

-_v_fixed = p_fixed.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset())
-_v_two = p_two.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset())
+_v_fixed = p_fixed.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset())
+_v_two = p_two.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset())
 check("a fully-fixed tariff REFUSES arbitrage", _v_fixed.kind == "refused")
 check("...for the true reason - the series is flat, so there is nothing to buy "
      "low and sell high, not because a FIXED enum was matched on",
@@ -354,7 +359,7 @@ _flat_dayahead = TariffPlan(
    None, "provider")
 check("a DAY_AHEAD series that happens to be flat is refused too, so the rule "
      "is arithmetic and not a product label",
-      _flat_dayahead.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused")
+      _flat_dayahead.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused")

 # The numbers an optimiser needs exist ONLY on the permitting variant.
 check("the allowed verdict carries the spread, the cheapest hour and the "
@@ -379,16 +384,16 @@ check("...and there is no falsy variant, so `if verdict:` cannot look like a "
 # §10.1 priority 2 over priority 3, expressed so OPT-04 cannot skip it.
 check("peak shaving outranks arbitrage: the SAME allowed plan is refused when "
      "the peak guard is holding",
-      p_two.arbitrage(peak_guard_active=True, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused")
+      p_two.arbitrage(now=LONG_AGO, peak_guard_active=True, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused")
 check("...and the reason names the ordering rather than the tariff",
-      "priority 2" in p_two.arbitrage(peak_guard_active=True, min_spread_eur_kwh=0.0, uncertainty=frozenset()).reason)
+      "priority 2" in p_two.arbitrage(now=LONG_AGO, peak_guard_active=True, min_spread_eur_kwh=0.0, uncertainty=frozenset()).reason)
 check("...and the question cannot be skipped: peak_guard_active is required "
      "and keyword-only, so a spread is not obtainable without answering it",
      raises(lambda: p_two.arbitrage(), TypeError)
      and raises(lambda: p_two.arbitrage(False), TypeError))
 check("...nor answered with a truthy 'unknown'",
-      raises(lambda: p_two.arbitrage(peak_guard_active=None), TypeError)
-      and raises(lambda: p_two.arbitrage(peak_guard_active="no"), TypeError))
+      raises(lambda: p_two.arbitrage(now=LONG_AGO, peak_guard_active=None), TypeError)
+      and raises(lambda: p_two.arbitrage(now=LONG_AGO, peak_guard_active="no"), TypeError))


 # --------------------------------------------------------------------------- #
@@ -524,7 +529,7 @@ check("...and its underlying read has no .points at all, so `min(read.points)` "
      "cannot run against it",
      raises(lambda: _none.read.points, Absence))
 check("...and arbitrage is refused, per §11.4",
-      _none.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused"
+      _none.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused"
      and arbitrage_allowed(_none.read) is False)
 check("...and static_status() says so in words rather than reporting a price",
      static_status(opts(None), THU) == (False, "No fixed tariff set"))
@@ -776,12 +781,12 @@ check("...marked PROVISIONAL, which is the one flag that differs",
      _fb.provisional and plan_is_provisional(_fb.read))
 check("...and arbitrage is refused on it, per §11.4, even though a full series "
      "exists and has a real spread",
-      _fb.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused"
+      _fb.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "refused"
      and near(_fb.spread_eur_kwh(), DAY_P - NIGHT_P))
 check("...while the SAME profile as the configured product allows it - so the "
      "refusal is about provisionality and not about the profile",
      static_plan(opts(TWO_PERIOD), THU, THU + timedelta(days=1)
-                  ).arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "allowed")
+                  ).arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "allowed")
 check("...and the provisional plan has no cheap window either: §8.3 forbids an "
      "irreversible action on a provisional price, and a grid top-up is one",
      not any(_fb.cheap_now(at_local(THU, h)) for h in range(24)))
@@ -821,8 +826,8 @@ check("a live feed is used in preference to the static profile",
      and _live_plan.product is PriceProduct.DAY_AHEAD)
 check("...and arbitrage is allowed on it, with the spread derived from the "
      "feed rather than from the profile",
-      _live_plan.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "allowed"
-      and near(_live_plan.arbitrage(peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).spread_eur_kwh,
+      _live_plan.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).kind == "allowed"
+      and near(_live_plan.arbitrage(now=LONG_AGO, peak_guard_active=False, min_spread_eur_kwh=0.0, uncertainty=frozenset()).spread_eur_kwh,
               0.023, 1e-9))


@@ -1036,7 +1041,7 @@ check(f"each tiny-spread probe really carries the spread it is named for, and "
      all(near(p.spread_eur_kwh(), d, 1e-12)
          and len([q for q in p.read.points if not q.provisional]) == 2
          for d, p in _tiny9))
-_tinyv9 = [(d, rung9(p.arbitrage(**_A9))) for d, p in _tiny9]
+_tinyv9 = [(d, rung9(p.arbitrage(now=LONG_AGO, **_A9))) for d, p in _tiny9]
 check(f"TEST-16 AC1: a spread that is SMALL BUT REAL is ALLOWED at "
      f"min_spread_eur_kwh=0.0 - down to 0.000001 EUR/kWh, so the flat rung is "
      f"`spread == 0.0` and not `spread <= epsilon` for any epsilon "
@@ -1045,7 +1050,7 @@ check(f"TEST-16 AC1: a spread that is SMALL BUT REAL is ALLOWED at "
 check("...and the exactly flat series on the OTHER side of that boundary is "
      "still refused, and refused BY THE FLAT RUNG - without this the sweep "
      "above would also pass for a rung that had been deleted outright",
-      rung9(plan9([0.20000, 0.20000]).arbitrage(**_A9)) == "flat")
+      rung9(plan9([0.20000, 0.20000]).arbitrage(now=LONG_AGO, **_A9)) == "flat")
 _q9 = plan9([0.20000, 0.2000005])
 check(f"...and a difference below the rung's own 6-decimal rounding is flat BY "
      f"CONSTRUCTION and says so: the raw difference is "
@@ -1056,10 +1061,10 @@ check(f"...and a difference below the rung's own 6-decimal rounding is flat BY "
      f"to bisect further",
      not near(_q9.spread_eur_kwh(), 0.0, 1e-9)
      and near(round(_q9.spread_eur_kwh(), 6), 0.0, 1e-12)
-      and rung9(_q9.arbitrage(**_A9)) == "flat")
+      and rung9(_q9.arbitrage(now=LONG_AGO, **_A9)) == "flat")

 # --- and what D's survival actually costs: the sentence, not the verdict -----
-_lie9 = plan9([0.20000, 0.20050]).arbitrage(**_A9)
+_lie9 = plan9([0.20000, 0.20050]).arbitrage(now=LONG_AGO, **_A9)
 check(f"TEST-16 AC4: the 0.0005 verdict carries the real spread rather than a "
      f"flatness claim about a tariff that is not flat - the false sentence is "
      f"what a loosened rung ships to the operator while the outcome at a "
@@ -1085,19 +1090,19 @@ check(f"the one-firm probe is well formed: exactly ONE firm hour out of three, "
 check("TEST-16 AC2: one firm hour is refused BY §8.3's FIRM-PAIR RUNG, named "
      "in the reason - not by the flat rung that would also have refused it. "
      "This is what takes `len(firm) < 2` -> `< 1` red on its own",
-      rung9(_one9.arbitrage(**_A9)) == "firm-pair")
+      rung9(_one9.arbitrage(now=LONG_AGO, **_A9)) == "firm-pair")
 check("...and the sentence is §8.3's in full, so the operator is told the "
      "series is half-published rather than told it is fixed-price",
-      "§8.3" in _one9.arbitrage(**_A9).reason
-      and "only 1 of 3" in _one9.arbitrage(**_A9).reason
-      and "flat" not in _one9.arbitrage(**_A9).reason)
+      "§8.3" in _one9.arbitrage(now=LONG_AGO, **_A9).reason
+      and "only 1 of 3" in _one9.arbitrage(now=LONG_AGO, **_A9).reason
+      and "flat" not in _one9.arbitrage(now=LONG_AGO, **_A9).reason)
 # The rung pinned from ABOVE as well. Without this, `len(firm) < 3` - the same
 # +0 B edit in the other direction - would pass everything above.
 _two9 = plan9([0.20, 0.40, 0.10], [False, False, True])
 check("...and TWO firm hours are ALLOWED on the identical series shape, so the "
      "rung is pinned from above too and `< 3` is red as well as `< 1`",
-      rung9(_two9.arbitrage(**_A9)) == "allowed"
-      and near(_two9.arbitrage(**_A9).spread_eur_kwh, 0.20))
+      rung9(_two9.arbitrage(now=LONG_AGO, **_A9)) == "allowed"
+      and near(_two9.arbitrage(now=LONG_AGO, **_A9).spread_eur_kwh, 0.20))
 # ...and from below, where the failure is not a wrong sentence but a crash:
 # `max()` over an empty `firm` raises ValueError, so `< 0` does not degrade the
 # reason, it takes the verdict away entirely.
@@ -1105,7 +1110,7 @@ _zero9 = plan9([0.20, 0.40, 0.10], [True, True, True])
 check("...and a FULLY provisional series is refused by the same rung and does "
      "not raise - `max()` over an empty firm set is a ValueError, so this row "
      "is what makes `len(firm) < 0` red",
-      rung9(derived(lambda: _zero9.arbitrage(**_A9))) == "firm-pair")
+      rung9(derived(lambda: _zero9.arbitrage(now=LONG_AGO, **_A9))) == "firm-pair")

 # --- AC3: the two rungs do not mask each other ------------------------------
 # ⚠️ THE POINT OF THE TICKET, AND IT IS A PROPERTY OF THE TABLE, NOT OF A ROW.
@@ -1130,7 +1135,7 @@ _TABLE9 = (
    ("two firm hours of three", _two9, "allowed"),
    ("no firm hours at all", _zero9, "firm-pair"),
 )
-_got9 = [(name, want, rung9(derived(lambda p=pl: p.arbitrage(**_A9))))
+_got9 = [(name, want, rung9(derived(lambda p=pl: p.arbitrage(now=LONG_AGO, **_A9))))
         for name, pl, want in _TABLE9]
 check(f"TEST-16 AC3: each stimulus is answered by the rung that OWNS it, and "
      f"by no other - the flat rung is asked a question the firm-pair rung "
@@ -0,0 +1,583 @@
+"""UX-46: the Dutch pages show Dutch status rows, notes and wizard lines.
+`python3 -B test_ux46.py`
+
+Before this, Home's status rows, the settings page's notes and the setup
+wizard's checks were built in English and sent as they were, so the NL pages
+showed English under Dutch titles (SAFETY-118 I-1, UX-44 I-2, UX-45 I-3).
+
+1. Rows: every row in `messages.status_samples()` carries a Dutch twin
+   (`messages.Bi`), the Dutch follows STYLE.md, and the Home page's status
+   payload gives it for lang=nl and the English text for everything else.
+2. Notes: every `_advise()` call in app/validate.py gives a Dutch twin, the
+   notes the validator really builds carry it, and /config/validate sends the
+   page's language, for the settings notes and for the wizard's check list.
+3. The setting labels the Dutch notes quote are the labels in nl.yaml, and the
+   peak forecast label has no "(W)", since any power unit is read.
+4. The rules above catch spoiled input.
+
+Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
+"""
+
+import ast
+import asyncio
+import copy
+import json
+import logging
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from aiohttp import ClientSession, web as aioweb
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE / "tools"))
+logging.disable(logging.WARNING)
+
+import translations_lint as TL                                  # noqa: E402
+import ux13_demo as D                                           # noqa: E402
+from style_rules import sentences, text_problems, words        # noqa: E402
+from app import messages, uimodel as U, uitext, web             # noqa: E402
+from app.main import Controller                                 # noqa: E402
+from named_absence import field, nth, present                   # noqa: E402
+from app.validate import (Note, note_text, setup_checks,        # noqa: E402
+                          config_notes)
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+# STYLE.md for a Dutch row or note: the same length and shape rules, plus the
+# Dutch words that test_ui_text.py bans for the same things. A quoted setting
+# label may keep its own words ("Setpoint-entiteit" is the label in nl.yaml).
+JARGON_NL = re.compile(
+    r"\b(?:setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
+    r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
+    r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|ESP32|"
+    r"master)\b", re.I)
+# English function words that never belong in a Dutch sentence.
+ENGLISH = re.compile(r"\b(?:the|not|and|for|with|from|reads|check|so|no|set|"
+                     r"keeps|stays|has|have|ran|ago|seconds?|minutes?)\b", re.I)
+QUOTED = re.compile(r"“[^”]*”")
+
+
+def dutch_problems(text):
+    bare = re.sub(r"\b[a-z_]+\.[a-z0-9_]+\b", "X", QUOTED.sub("X", text))
+    out = []
+    if JARGON_NL.search(bare):
+        out.append("jargon: " + JARGON_NL.search(bare).group(0))
+    names = re.sub(r"\binverter-[a-z0-9]+\b|\b[a-z_]+\.[a-z0-9_]+\b", "X",
+                   bare)
+    eng = ENGLISH.search(names)
+    if eng:
+        out.append("English word: " + eng.group(0))
+    return out
+
+
+def row_problems_nl(colour, text):
+    n_s, n_w = sentences(text), len(words(text))
+    out = []
+    if colour == messages.RED:
+        if n_s > 3 or n_w > 30:
+            out.append(f"red row over 3 sentences / 30 words ({n_s}/{n_w})")
+    elif n_s > 1 or n_w > 15:
+        out.append(f"row over 1 sentence / 15 words ({n_s}/{n_w})")
+    if ";" in text:
+        out.append("semicolon")
+    return out + text_problems(text, keys=False, entities=False) \
+        + dutch_problems(text)
+
+
+# --------------------------------------------------------------------------- #
+print("1. every status row has a Dutch twin, and the page picks one")
+# --------------------------------------------------------------------------- #
+ROWS = [(fn, c, t) for fn, c, t in messages.status_samples() if c is not None]
+check(f"there are rows to grade ({len(ROWS)})", len(ROWS) > 80)
+_none = [(fn, str(t)) for fn, c, t in ROWS
+         if not (isinstance(t, messages.Bi) and t.nl)]
+check(f"every row has a Dutch text ({_none})", not _none)
+_same = [(fn, str(t)) for fn, c, t in ROWS
+         if isinstance(t, messages.Bi) and t.nl == str(t)]
+check(f"no Dutch row is the English one ({_same})", not _same)
+_bad = [(fn, p) for fn, c, t in ROWS if isinstance(t, messages.Bi) and t.nl
+        for p in row_problems_nl(c, t.nl)]
+for x in _bad:
+    print(f"       STYLE  {x}")
+check(f"every Dutch row follows STYLE.md ({len(_bad)} problems)", not _bad)
+BANNERS = [(fn, t) for fn, c, t in messages.status_samples() if c is None]
+_nob = [(fn, str(t)) for fn, t in BANNERS
+        if not (isinstance(t, messages.Bi) and t.nl and t.nl != str(t))]
+check(f"every banner has a Dutch text ({_nob})", BANNERS and not _nob)
+_bb = [(fn, t.nl) for fn, t in BANNERS if isinstance(t, messages.Bi) and t.nl
+       and (len(words(t.nl)) > 12 or ";" in t.nl or dutch_problems(t.nl)
+            or text_problems(t.nl, keys=False, entities=False))]
+check(f"every Dutch banner is at most 12 words and follows STYLE.md ({_bb})",
+      not _bb)
+_cat = {k for k, v in vars(messages).items()
+        if callable(v) and k.startswith("row_")}
+check("the samples cover every row_ function, so none can skip the check",
+      _cat <= {fn for fn, _c, _t in ROWS})
+_lat = {"row_direction_trip": "herstart heft dit niet op",
+        "row_site_direction_trip": "regeling starten heft dit op",
+        "row_circulating_trip": "regeling starten heft dit op",
+        "row_not_delivering": "stoppen en starten heft dit op"}
+_unclear = [fn for fn, _c, t in ROWS if fn in _lat and _lat[fn] not in t.nl]
+check(f"a Dutch latch row says how it clears too ({_unclear})", not _unclear)
+check("pick() gives the English for en, the Dutch for nl, and leaves other "
+      "text alone",
+      messages.pick(messages.row_estop_fitted(), "en") == "Emergency stop: fitted"
+      and type(messages.pick(messages.row_estop_fitted(), "en")) is str
+      and messages.pick(messages.row_estop_fitted(), "nl") == "Noodstop: geplaatst"
+      and messages.pick("Plain", "nl") == "Plain"
+      and messages.pick(messages.Bi("A"), "nl") == "A")
+check("a Bi survives copy and pickle, and JSON",
+      copy.deepcopy(messages.row_estop_fitted()).nl == "Noodstop: geplaatst"
+      and json.dumps(messages.row_estop_fitted()) == '"Emergency stop: fitted"')
+
+
+# --- the page: a real Controller -------------------------------------------- #
+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 []
+
+
+ONE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+       "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+       "meter_source": "off", "max_w": 5000, "shadow_mode": "off",
+       "maintenance_enabled": False, "peak_forecast_entity": "sensor.fc"}
+TWO = dict(ONE, inverters=[
+    {"name": "Battery A", "setpoint_entity": "number.a", "soc_entity":
+     "sensor.soc_a", "batt_entity": "sensor.batt_a", "max_w": 2500},
+    {"name": "Battery B", "setpoint_entity": "", "soc_entity":
+     "sensor.soc_b", "batt_entity": "sensor.batt_b", "max_w": 2500}])
+
+
+def make(opts, soc=(62.0, 35.0), batt=(-2500.0, -300.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 = soc[i], batt[i]
+        inv.dev_min, inv.dev_max = -5000.0, 5000.0
+    c.grid = 10.0
+    return c
+
+
+def attention(payload, rid):
+    return next((a for a in payload["attention"] if a["id"] == rid), None)
+
+
+c = make(ONE, soc=(62.0,), batt=(960.0,))
+c._peak_fc_fault = "kWh"
+s_en, s_nl = c.status_payload(), c.status_payload(lang="nl")
+def fc_row(payload):
+    return nth([r for r in payload["checks"] if r.get("id") == "peak_forecast"])
+
+
+_en, _nl = fc_row(s_en), fc_row(s_nl)
+check("Home, English: the peak forecast row is the English sentence",
+      present(_en) and field(_en, "text") == messages.peak_forecast_unit("kWh")
+      and attention(s_en, "peak_forecast")["body"]
+      == messages.peak_forecast_unit("kWh"))
+check("Home, Dutch: the row, the Needs-attention entry and the title are "
+      "Dutch",
+      present(_nl) and field(_nl, "text") == messages.peak_forecast_unit("kWh", "nl")
+      and attention(s_nl, "peak_forecast")["body"]
+      == messages.peak_forecast_unit("kWh", "nl")
+      and attention(s_nl, "peak_forecast")["title"]
+      == uitext.words("nl")["home_words"]["attn"]["peak_forecast"])
+c._peak_fc_fault = ""
+_nl0 = fc_row(c.status_payload(lang="nl"))
+check("...and with no unit at all, the Dutch is the 'no unit' sentence",
+      present(_nl0) and field(_nl0, "text") == messages.peak_forecast_unit("", "nl")
+      and messages.peak_forecast_unit("", "nl")
+      != messages.peak_forecast_unit("kWh", "nl"))
+check("a language that is not Dutch gets the English, and the default call "
+      "is unchanged",
+      c.status_payload(lang="fr")["checks"] == c.status_payload()["checks"]
+      and all(type(r["text"]) is str for r in c.status_payload()["checks"]))
+
+# A site with faults of many kinds: every row it shows is Dutch on the NL page.
+SCEN = {}
+SCEN["two, one without a setpoint, meter stale"] = make(TWO)
+SCEN["one, nothing read"] = make(ONE, soc=(None,), batt=(None,))
+SCEN["one, no forecast set"] = make(dict(ONE, peak_forecast_entity=""))
+SCEN["one, shadow, estop fitted"] = make(dict(ONE, shadow_mode="on",
+                                              estop_fitted=True))
+SCEN["one, solar sources"] = make(dict(ONE, pv_entity="sensor.pv"))
+SCEN["two, solar list"] = make(dict(TWO, pv_entities=["sensor.a", "sensor.b"]))
+SCEN["one, peak forecast unit fault"] = c
+SCEN["one, control stopped"] = make(ONE)
+SCEN["one, control stopped"].auto = False
+_English, _rows_seen = [], 0
+for name, ctl in SCEN.items():
+    raw = ctl.checks()
+    en = ctl.status_payload()["checks"]
+    nl = ctl.status_payload(lang="nl")["checks"]
+    check(f"[{name}] {len(raw)} rows: same rows in both languages",
+          len(raw) == len(en) == len(nl))
+    for r, e, n in zip(raw, en, nl):
+        _rows_seen += 1
+        if not (isinstance(r["text"], messages.Bi) and r["text"].nl):
+            _English.append((name, r.get("id"), str(r["text"])))
+        elif e["text"] != str(r["text"]) or n["text"] != r["text"].nl:
+            _English.append((name, r.get("id"), "page did not pick"))
+_banners = {n: (ctl.status_payload()["banner"],
+                ctl.status_payload(lang="nl")["banner"])
+            for n, ctl in SCEN.items()}
+print(f"    banners: {_banners}")
+check("the banner at the top of Home is Dutch on the Dutch page, English on "
+      "the English one", all(e != n and not dutch_problems(n)
+                             for e, n in _banners.values()))
+check(f"{_rows_seen} rows over {len(SCEN)} sites: none shows English on the "
+      f"Dutch page when it has no Dutch text ({_English})", not _English)
+check("the row's details list in /status is picked the same way",
+      all(isinstance(v, str) and not isinstance(v, messages.Bi)
+          for ctl in SCEN.values()
+          for _k, v in ctl.status_payload(lang="nl")["rows"]))
+
+# --------------------------------------------------------------------------- #
+print("\n2. every settings note and wizard line has a Dutch twin")
+# --------------------------------------------------------------------------- #
+tree = ast.parse((HERE / "app" / "validate.py").read_text(encoding="utf-8"))
+_calls = [n for n in ast.walk(tree) if isinstance(n, ast.Call)
+          and ast.unparse(n.func) == "_advise"]
+_bare = [n.lineno for n in _calls if not any(k.arg == "nl" for k in n.keywords)]
+check(f"every _advise() call in validate.py gives `nl` ({len(_calls)} calls, "
+      f"without: {_bare})", len(_calls) >= 30 and not _bare)
+
+OPTS = dict(D.defaults(D.CONFIG), setpoint_entity="number.sp",
+            meter_entity="sensor.grid", soc_entity="sensor.soc",
+            batt_entity="sensor.batt", pv_entity="sensor.pv",
+            peak_forecast_entity="sensor.fc")
+
+
+def ent(state, unit=None):
+    return {"state": state, "unit": unit}
+
+
+GOOD = {"number.sp": ent("0"), "sensor.grid": ent("402", "W"),
+        "sensor.soc": ent("62", "%"), "sensor.batt": ent("-800", "W"),
+        "sensor.pv": ent("-1200", "W"), "sensor.fc": ent("820", "kWh")}
+NOTES = []
+NOTES += setup_checks(OPTS, entities=GOOD, running=None)
+NOTES += setup_checks(OPTS, entities=None)
+NOTES += setup_checks(dict(OPTS, meter_invert=True, pv_invert_entities=["sensor.pv"]),
+                      entities=dict(GOOD, **{"sensor.batt": ent("0", "W")}))
+NOTES += setup_checks(dict(OPTS, soc_entity="sensor.x", batt_entity="sensor.y",
+                           setpoint_entity="number.typo"),
+                      entities=GOOD)
+NOTES += setup_checks(dict(OPTS, meter_source="homewizard_local"),
+                      entities=GOOD, running=None)
+NOTES += setup_checks(dict(OPTS, meter_source="homewizard_local",
+                           price_provider="generic_dayahead"),
+                      entities=GOOD, running=dict(OPTS, meter_source="homewizard_local",
+                                                  price_provider="generic_dayahead"),
+                      meter_now_w=-350.0, prices_known=18)
+NOTES += setup_checks(dict(OPTS, price_provider="generic_dayahead"), entities=GOOD,
+                      running=None)
+NOTES += setup_checks(dict(OPTS, price_provider="off", static_profile=""),
+                      entities=GOOD)
+NOTES += setup_checks(dict(OPTS, price_provider="off",
+                           static_profile='{"periods":[]}'), entities=GOOD)
+NOTES += setup_checks(dict(OPTS, batt_entity="sensor.batt2"),
+                      entities=dict(GOOD, **{"sensor.batt2": ent("unavailable")}))
+NOTES += setup_checks(dict(OPTS, soc_entity="sensor.soc2"),
+                      entities=dict(GOOD, **{"sensor.soc2": ent("unavailable")}))
+NOTES += setup_checks(dict(OPTS, meter_entity="sensor.m2"),
+                      entities=dict(GOOD, **{"sensor.m2": ent("unavailable")}))
+_TWO = dict(OPTS, inverters=[
+    {"name": "a", "setpoint_entity": "number.sp", "soc_entity": "sensor.soc",
+     "batt_entity": "sensor.batt", "max_w": 2000, "bms_soc_floor": 10},
+    {"name": "b", "setpoint_entity": "number.b", "max_w": 2000,
+     "bms_soc_floor": 10}])
+NOTES += setup_checks(_TWO, entities=dict(GOOD, **{"sensor.batt": ent("-0.5", "kW")}))
+NOTES += setup_checks(dict(OPTS, meter_source="ha_signed",
+                           p1_net_entity="sensor.net"),
+                      entities=dict(GOOD, **{"sensor.net": ent("-3.1", "kW")}))
+NOTES += config_notes(dict(OPTS, integrator_max_w=9000, max_w=2000,
+                           peak_cap_w=2000), entities=GOOD, month_peak_w=3000)
+NOTES += config_notes(dict(OPTS, pv_forecast_entity="sensor.f1",
+                           pv_forecast_tomorrow_entity="sensor.f2",
+                           peak_forecast_entity="sensor.fc2"),
+                      entities=dict(GOOD, **{"sensor.f1": ent("5", "W"),
+                                             "sensor.f2": ent("6", "kWh"),
+                                             "sensor.fc2": ent("5")}))
+NOTES += config_notes(dict(OPTS, meter_entity="sensor.gone"), entities=GOOD)
+NOTES += config_notes(dict(OPTS, pv_forecast_tomorrow_entity="sensor.f2"),
+                      entities=dict(GOOD, **{"sensor.f2": ent("6", "kWh")}))
+NOTES += config_notes(dict(OPTS, batt_entity="sensor.kw"),
+                      entities=dict(GOOD, **{"sensor.kw": ent("1", "kW")}))
+print(f"    {len(NOTES)} notes built")
+_nonl = [n.text for n in NOTES if not n.nl]
+check(f"every note the validator builds has a Dutch twin ({_nonl})",
+      NOTES and not _nonl)
+_same = [n.text for n in NOTES if n.nl == n.text]
+check(f"...which is not the English ({_same})", not _same)
+_bad = []
+for n in NOTES:
+    nw, ns = len(words(n.nl)), sentences(n.nl)
+    p = text_problems(n.nl, keys=True, entities=True) + dutch_problems(n.nl)
+    if nw > 25 and not n.text.startswith(("The 15-minute", "Home Assistant")):
+        p.append(f"over 25 words ({nw})")
+    if ns > 2:
+        p.append(f"over 2 sentences ({ns})")
+    if ";" in n.nl:
+        p.append("semicolon")
+    if len(words(n.nl)) > len(words(n.text)) + 6:
+        p.append("much longer than the English")
+    _bad += [(n.nl, x) for x in p]
+for x in _bad:
+    print(f"       STYLE  {x}")
+check(f"every Dutch note follows STYLE.md ({len(_bad)} problems)", not _bad)
+_l = {t: [n for n in NOTES if n.text.startswith(t)] for t in (
+    "Prices for today are in", "The 15-minute demand forecast")}
+check("the wizard's price line, and the peak forecast unit note, are among "
+      "them", all(_l.values()))
+check("note_text() picks: Dutch for nl, English for en, the old twin table "
+      "for a note with no `nl`",
+      note_text(_l["Prices for today are in"][0], "nl")
+      == "De prijzen van vandaag zijn binnen, voor 18 van 24 uur."
+      and note_text(_l["Prices for today are in"][0], "en")
+      == "Prices for today are in, for 18 of 24 hours."
+      and note_text(Note("info", (), messages.FIXED_TARIFF_NOTE), "nl")
+      == messages.FIXED_TARIFF_NOTE_NL
+      and note_text(Note("info", (), "Other"), "nl") == "Other")
+
+# --- over HTTP: the settings page and the wizard, in both languages --------- #
+SCHEMA = D.schema_ui(D.CONFIG)
+TRANSLATIONS = {l: TL.parse_translation_file(HERE / "translations" / f"{l}.yaml")
+                for l in ("en", "nl")}
+STATES = [{"entity_id": e, "state": v["state"],
+           "attributes": ({"unit_of_measurement": v["unit"]} if v["unit"]
+                          else {})} for e, v in GOOD.items()]
+
+
+class Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def states(self):
+        return copy.deepcopy(STATES)
+
+    async def state(self, entity):
+        return next((copy.deepcopy(s) for s in STATES
+                     if s["entity_id"] == entity), None)
+
+
+class Supervisor:
+    def __init__(self, options):
+        self.options = copy.deepcopy(options)
+
+    async def info(self):
+        return {"options": copy.deepcopy(self.options), "schema": SCHEMA,
+                "translations": TRANSLATIONS}
+
+    async def write_options(self, options):
+        pass
+
+    async def restart(self, confirm):
+        pass
+
+
+class Ctl:
+    def __init__(self, opts):
+        self.o, self.hass, self.inverters = dict(opts), Hass(), []
+        self.store, self.auto, self.grid = None, True, 402.0
+
+    def log_event(self, text, hint=None):
+        pass
+
+    def status_payload(self, lang="en"):
+        return {"banner": "", "level": "ok", "rows": [], "checks": [],
+                "plan": {"prices": [{"label": f"{h:02d}:00", "eur_kwh": 0.2}
+                            for h in range(20)]
+                         + [{"label": f"{h:02d}:00", "eur_kwh": None}
+                            for h in range(20, 24)]}}
+
+
+async def serve(opts, steps):
+    runner = aioweb.AppRunner(web.build_app(Ctl(opts), Supervisor(opts)))
+    await runner.setup()
+    site = aioweb.TCPSite(runner, "127.0.0.1", 0)
+    await site.start()
+    root = f"http://127.0.0.1:{site._server.sockets[0].getsockname()[1]}/"
+    try:
+        async with ClientSession() as s:
+            return await steps(s, root)
+    finally:
+        await runner.cleanup()
+
+
+async def post(s, url, body):
+    async with s.post(url, json=body) as r:
+        return await r.json()
+
+
+RUN = dict(OPTS, meter_source="homewizard_local", p1_host="192.0.2.50",
+           price_provider="generic_dayahead")
+
+
+async def pages(s, root):
+    out = {}
+    # The settings notes read the entity list the picker has cached, so the
+    # first call only warms it.
+    await post(s, root + "config/validate",
+               {"model": U.options_to_ui(RUN), "setup": True})
+    for lang in ("en", "nl"):
+        async with s.get(root + f"config/model?lang={lang}") as r:
+            m = await r.json()
+        model = U.options_to_ui(RUN)
+        out[lang] = await post(s, root + "config/validate",
+                               {"model": model, "setup": True, "lang": lang})
+    out["none"] = await post(s, root + "config/validate", {
+        "model": U.options_to_ui(RUN), "setup": True})
+    return out
+
+
+R = asyncio.run(serve(RUN, pages))
+_texts = {l: [m["text"] for m in R[l].get("messages", [])] for l in ("en", "nl")}
+_setup = {l: [m["text"] for m in R[l].get("setup", [])] for l in ("en", "nl")}
+FC_EN = messages.peak_forecast_unit("kWh") + " Pick a sensor in W or kW."
+FC_NL = messages.peak_forecast_unit("kWh", "nl") + " Kies een sensor in W of kW."
+print(f"    settings notes en: {_texts['en']}")
+print(f"    settings notes nl: {_texts['nl']}")
+print(f"    wizard lines nl:   {_setup['nl']}")
+check("settings page, English: the peak forecast unit note is English",
+      FC_EN in _texts["en"])
+check("settings page, Dutch: it is the Dutch sentence, and no English "
+      "sentence of it is left", FC_NL in _texts["nl"]
+      and FC_EN not in _texts["nl"])
+check("wizard, English: the price line and the checks are English",
+      "Prices for today are in, for 20 of 24 hours." in _setup["en"])
+check("wizard, Dutch: the price line is Dutch",
+      "De prijzen van vandaag zijn binnen, voor 20 van 24 uur."
+      in _setup["nl"] and "Prices for today are in, for 20 of 24 hours."
+      not in _setup["nl"])
+_left = [t for t in _setup["nl"] + _texts["nl"]
+         if ENGLISH.search(QUOTED.sub("X", t))
+         and not t.startswith("Home Assistant has no entity")]
+check(f"no wizard line or settings note on the Dutch page has English words "
+      f"left ({_left})", not _left)
+check("a request with no language gets English (an old page keeps working)",
+      [m["text"] for m in R["none"].get("setup", [])]
+      == [m["text"] for m in R["en"].get("setup", [])])
+check("the raw `notes` list keeps the English `text` and adds `nl`",
+      R["nl"]["notes"] and all(n["text"] != n["nl"] for n in R["nl"]["notes"]))
+
+# --------------------------------------------------------------------------- #
+print("\n3. labels")
+# --------------------------------------------------------------------------- #
+for lang in ("en", "nl"):
+    name = TRANSLATIONS[lang]["configuration"]["peak_forecast_entity"]["name"]
+    check(f"[{lang}] the peak forecast label has no unit: {name!r}",
+          "(W)" not in name and "(kW)" not in name
+          and name.split("·")[-1].strip() == (
+              "15-minute demand forecast entity" if lang == "en"
+              else "Entiteit kwartierprognose"))
+check("DOCS.md shows the same label, so the table cannot drift",
+      "| Limits | 15-minute demand forecast entity | `peak_forecast_entity` |"
+      in (HERE / "DOCS.md").read_text(encoding="utf-8"))
+
+
+def stems(key):
+    tr = TRANSLATIONS["nl"]["configuration"]
+    out = []
+    for c in (tr, tr["inverters"]["fields"]):
+        if isinstance(c.get(key), dict):
+            n = c[key]["name"].split("·")[-1].strip()
+            while re.search(r"\s*\([^()]*\)$", n):
+                n = re.sub(r"\s*\([^()]*\)$", "", n)
+            out.append(n)
+    return out
+
+
+_drift = sorted(k for k, v in messages.LABELS_NL.items() if v not in stems(k))
+check(f"every Dutch label a note quotes is the setting's name in nl.yaml "
+      f"(drifted: {_drift})", not _drift
+      and set(messages.LABELS_NL) == set(messages.LABELS))
+_unit = sorted(k for k, v in messages.UNIT_LABELS_NL.items() if v not in stems(k))
+check(f"...and so are the two the inverter list names differently ({_unit})",
+      not _unit)
+check("setting() in Dutch keeps the key, so the config panel can find it",
+      messages.setting("max_w", "", "nl") == "“Vermogen van de omvormer” (max_w)"
+      and messages.setting("max_w", "inverter-b", "nl")
+      == "“Vermogen van deze omvormer” voor inverter-b (inverters.max_w)"
+      and messages.setting("max_w") == "“Inverter rating” (max_w)")
+
+# --------------------------------------------------------------------------- #
+print("\n4. the rules catch spoiled input")
+# --------------------------------------------------------------------------- #
+check("a Dutch row left in English is caught",
+      row_problems_nl(messages.AMBER, "Control: last ran 2 seconds ago"))
+check("an over-long Dutch row is caught",
+      row_problems_nl(messages.AMBER, " ".join(["woord"] * 16) + "."))
+check("Dutch jargon is caught", dutch_problems("Het commando is geweigerd"))
+check("a row with no Dutch is caught",
+      not isinstance(messages.pick("x", "nl"), messages.Bi)
+      and not getattr(messages.Bi("x"), "nl"))
+check("the untranslated-call scan sees a bare _advise",
+      any(isinstance(n, ast.Call) and not any(k.arg == "nl" for k in n.keywords)
+          for n in ast.walk(ast.parse('_advise(notes, "warn", (), "x")'))))
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print("  -", f)
+    sys.exit(1)
+print("all passed")
@@ -105,6 +105,13 @@ class _Hass:
            return self.power(u)
        return None

+    async def state(self, e):
+        """SAFETY-118: the peak forecast is read as a state object; every
+        number this rig serves is in watts."""
+        v = await self.number(e)
+        return None if v is None else {
+            "state": str(v), "attributes": {"unit_of_measurement": "W"}}
+
    async def set_number(self, e, v):
        self.cmd[e[-1]] = float(v)
        return True
@@ -17,6 +17,7 @@ test_modes_p3.py part 1 holds this tree to the digests printed on 7a00f12.
 import functools
 import hashlib
 import os
+import re
 import sys
 import tempfile
 import time
@@ -117,6 +118,31 @@ def digest(rows) -> str:
    return hashlib.sha256(repr(rows).encode()).hexdigest()


+def _trade_words(text):
+    """PRICE-02: the trade sentence as release/1.0 before it printed it. The
+    plan now drops price periods that have ended, so a sale's "above the
+    cheapest" figure is a different number once the first cheap period is
+    over, and the sentences say "price period" where they said "hour". Both
+    maps are applied to both sides, so only those two things are hidden.
+
+    ONLY FOR COMPARING WITH A TREE OLDER THAN PRICE-02. A pin of this tree
+    itself uses `digest()`, with nothing hidden."""
+    text = text.replace("this hour is neither the buy hour nor the sell hour",
+                        "now is not the cheapest or the dearest price period")
+    text = re.sub(r"[0-9]+\.[0-9]+ above the cheapest",
+                  "N above the cheapest", text)
+    return text.replace("firm hour at", "firm price period at")
+
+
+def trade_digest(rows) -> str:
+    """`digest()` with the trade sentence passed through `_trade_words()`:
+    every command, integrator and allocation, and the action, watts and the
+    rest of the sentence, byte for byte."""
+    return digest([r[:-1] + (None if r[-1] is None else
+                             (r[-1][0], r[-1][1], _trade_words(r[-1][2])),)
+                   for r in rows])
+
+
 def digests() -> dict:
    return {k: digest(run(**v)[0]) for k, v in SCENARIOS.items()}

@@ -164,8 +164,8 @@ configuration:
    name: "Limits · Margin below the peak limit (W)"
    description: "The add-on aims this much below the peak limit, so a 15-minute period that ends a little high still stays under it."
  peak_forecast_entity:
-    name: "Limits · 15-minute demand forecast entity (W)"
-    description: "Optional. A forecast of this 15-minute period's average power. Leave it empty and there is no peak limit."
+    name: "Limits · 15-minute demand forecast entity"
+    description: "Optional. A forecast of this 15-minute period's average power, in W or kW. With no power unit it is not used. Leave it empty and there is no peak limit."
  peak_soc_floor:
    name: "Limits · Peak reserve (%)"
    description: "Peak limiting will not draw the battery below this level, but ordinary use can. Derived value, leave it unchanged."
@@ -145,8 +145,8 @@ configuration:
    name: "Grenzen · Marge onder de piekgrens (W)"
    description: "De add-on mikt zoveel onder de piekgrens, zodat een kwartier dat iets hoger uitvalt er toch onder blijft."
  peak_forecast_entity:
-    name: "Grenzen · Entiteit kwartierprognose (W)"
-    description: "Optioneel. Een prognose van het gemiddelde vermogen in het lopende kwartier. Laat u dit leeg, dan is er geen piekgrens."
+    name: "Grenzen · Entiteit kwartierprognose"
+    description: "Optioneel. Een prognose van het gemiddelde vermogen in het lopende kwartier, in W of kW. Zonder vermogenseenheid wordt ze niet gebruikt. Laat u dit leeg, dan is er geen piekgrens."
  peak_soc_floor:
    name: "Grenzen · Piekreserve (%)"
    description: "De piekbeperking laat de batterij niet onder dit niveau zakken, gewoon verbruik wel. Afgeleide waarde, laat ze ongewijzigd."