Merge pull request 'SAFETY-119: no "not keeping up" when the loop takes the wire back' (#203) from SAFETY-119 into release/1.0

Merge pull request 'SAFETY-119: no "not keeping up" when the loop takes the wire back' (#203) from SAFETY-119 into release/1.0

FIELD-GUIDE.md

@@ -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

HANDOVER.md

@@ -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`.
 

README.md

@@ -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.

docs/build_guide.py

@@ -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>

docs/field-guide.html

@@ -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>

goodwe_controller/CHANGELOG.md

@@ -1,5 +1,209 @@
 # 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.**
+No option was added, removed or renamed, and no default changed (86 options).
+**Existing installs need no option change:** options that start 0.18.0 also
+start 0.18.1. The changes below apply with one inverter or two.
+
+**Price rounding on 0.18.0.** On 0.18.0, the new settings page saved the fixed,
+day and night prices rounded to 2 decimals (0.34512 became 0.35); prices in time
+windows kept their decimals. If you typed more than 2 decimals in those
+fields on 0.18.0, enter them again.
+
+Contents of this release, in merge order since 0.18.0 (`a0e091c`):
+
+| | |
+|---|---|
+| `b703aaa` | The four tariff price fields on the new settings page (fixed, day, night and time windows) take 5 decimals, for example 0.34512 €/kWh, and are saved as typed. A short hint says to divide the c€/kWh on your bill by 100 ([[UX-43]], #194) |
+| `8e02a09` | The dynamic contract choice on the new settings page now says "Dynamic, every 15 minutes" ("Dynamisch, per kwartier") instead of "hourly". The choice works as before, and one line in the docs no longer calls dynamic prices hourly ([[UX-44]], #195) |
+
+### 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]]).
+- If the 15-minute demand forecast sensor reads in kW, the settings page warns that its number is taken as watts and asks for a sensor in W. The add-on does turn kW into W, so a kW sensor works ([[SAFETY-118]]).
+- 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.0
+
+**A minor bump: new behaviour, three new options and one new value for an
+existing option.** No option was removed or renamed, and no default of an
+existing option changed (83 options -> 86). **Existing installs need no option
+change:** options that start 0.17.0 also start 0.18.0, and the new options are
+off or empty until you use them. The changes below apply with one inverter or
+two, unless a line says "Two inverters".
+
+New options, and what they do if you leave them alone:
+
+| option | default | left alone |
+|---|---|---|
+| `pv_forecast_entities`, `pv_forecast_tomorrow_entities` | `[]` | the single forecast sensors work as before ([[OPT-17]]) |
+| `price_service_token` | empty | not used; it is read only with `price_provider: price_service` ([[PRICE-01]]) |
+
+`price_provider` also accepts a new value, `price_service`. Its default is
+unchanged, so the price source stays as it is.
+
+**Price service.** The new price source `price_service` reads prices from the
+add-on's price server, with the token you were given. If it does not answer,
+prices come from energy-charts.info, then from the prices the add-on saved.
+Sites on the Home Assistant price sensors or a fixed tariff need no change. To
+move a site over, see `DOCS.md`, "Moving a site from the Home Assistant price
+sensors to `price_service`".
+
+Contents of this release, in merge order since 0.17.0 (`e36565f`):
+
+| | |
+|---|---|
+| `3050fa5` | The solar forecast can come from several sensors, added up, for example one per inverter. If one of them has no reading, that day's forecast is not used, and the status says which one. The single sensor still works ([[OPT-17]]) |
+| `e3e4ba6` | While Home Assistant is still starting, the page now says "Waiting for Home Assistant" and the log says the add-on waits, instead of looking like a fault. Control itself is unchanged: it starts when Home Assistant answers ([[SAFETY-112]]) |
+| `79dd077` | Battery modes on only: a charge in a cheap run no longer stops at the start of a new 15-minute period, and with two inverters a battery that refused to charge is tried again every 15 min. In one test, the export at the end of a charge was 48 W where the code before this fix gave 746 W ([[OPT-15]]) |
+| `0ce7d35` | Two inverters: each battery card has Start cycle and Stop cycle buttons, so you can start or stop the cycle on the battery you choose. Only one battery can cycle at a time, and a second start is refused with a short message ([[MAINT-11]]) |
+| `bf9019e` | New price source `price_service`. If it fails, prices come from energy-charts.info, then from saved prices. With no price at all and the monthly cycle on, a notice shows and the cycle waits ([[PRICE-01]]) |
+| `004f859` | Two inverters, battery modes on: the 15-minute retry of a battery that refused to charge now asks that battery for 200 W, and no longer puts the rest of the charge on another battery. In the test, without this fix, a battery in its maintenance charge took about 2,300 W for about 34 s at each retry ([[OPT-20]]) |
+
+### 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]]).
+
+### 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.17.0
 
 **A minor bump: changed behaviour, and no option changes.** No option was

goodwe_controller/DECISIONS/MAINT-11-cycle-per-battery.md

@@ -0,0 +1,37 @@
+# MAINT-11 - start or stop the maintenance cycle per battery
+
+**Status: for review.** Tests: `test_maint11.py`. No option added.
+
+**The fault.** At two or more batteries the page had one "start a battery cycle"
+button, and `_maint_button()` chose the battery. An operator could not cycle a
+chosen one (inverter B, new after storage, needed its first cycle).
+
+## Rule
+
+1. `maint_start` and `maint_abort` take an optional `unit`. With no unit they
+   run the old code unchanged. The Batteries screen sends the unit from a
+   per-battery Start cycle and Stop cycle button, at two or more batteries only.
+2. **A start while any battery holds the maintenance slot is refused, not
+   queued.** The message names the battery that is cycling. One slot per site
+   stays the rule, and the scheduler is untouched.
+3. Also refused, with a plain message: an unknown unit, a start on a battery
+   that is switched off (battery modes on), and a stop on a battery that is not
+   cycling. Nothing changes on a refusal.
+4. A stop on the cycling battery is today's abort: the cycle ends, then every
+   inverter goes to 0 W.
+
+## Why refuse and not queue
+
+A queued start is a cycle that begins hours later, unseen, after the operator
+has moved on. A refusal is immediate and says why. The scheduler already
+queues by waiting time, so nothing is lost.
+
+## What this does not cover
+
+- Today's bare button never refused a battery that is refusing to give power
+  (SAFETY-73); its drain waits. The per-battery start does the same.
+- A start on the battery that is already cycling is refused as "busy", where
+  the bare button restarts its drain. The bare button is unchanged.
+- At one battery, a request that names the battery uses the new path, so a
+  second start is refused instead of restarting the drain. Nothing sends a name
+  at one battery, and the bare request is unchanged.

goodwe_controller/DECISIONS/OPT-11-battery-modes.md

@@ -132,6 +132,23 @@ P1 is its section 6 P1, and the pull request lists what was measured.
     own, and a rise past that is the peak floor's, which ends the hold.
     A maintenance drain, hold or charge that starts during the hold ends it
     on that tick (replayed at edge + 3 s).
+- OPT-20 (TEST-23 OPT-15 g7, `test_opt20.py`): a probe asks only PROBE_W.
+  The trade was sized at the probing battery's rating (2500 W), B's pin held
+  200 W of it, and the allocator put the other 2300 W on A, in its
+  maintenance charge phase (no mode range there, so nothing kept it out):
+  grid 3100 W for 34 s. Now the ask is PROBE_W for the probing battery plus
+  what the other chargers would have had without the probe (none: 200 W
+  alone), and it carries the pin only on the ticks the pin is filed (the
+  window's first and last cycle moved another battery's share by 200 W).
+  - Chosen: the probe sits on top of a headroom-sized charge, so beside a
+    normal charger its command is the same and the grid rises 200 W (about
+    7 W on the quarter) rather than that charger giving 200 W up. A probe
+    that the headroom or the bound cannot hold at 200 W is not filed.
+  - Unchanged, same on bf9019e: with a charge ask the other batteries cannot
+    give (one sign), so an idle-looking A that gives the house stops for the
+    window and the grid rises by what it gave. The trade line now says 200 W
+    for a probe alone; its words are UX-38's. The base P4 F4 path (a normal
+    trade on a battery in maintenance charge) is not touched.
 
 ## P4: the solar forecast and the day plan (2026-09-29)
 - Input: a Home Assistant forecast sensor (`pv_forecast_entity`, kWh left

goodwe_controller/DECISIONS/PRICE-01-own-price-server.md

@@ -0,0 +1,117 @@
+# PRICE-01 - the owner's price server as the price source, with fallbacks
+
+**Status: for review.** Tests: `test_price_service.py`. One option added,
+`price_service_token` (password). Follows [[TARIFF-10]], whose section 4 this
+card answers for one provider. Design: the owner's price service note of
+2026-10-05. Owner go 2026-10-05 and 2026-10-14.
+
+## What it is
+
+`price_provider: price_service` reads `GET https://prices.kammenstraatha.duckdns.org/v1/dayahead/BE`
+with `Authorization: Bearer <token>`. The answer is the energy-charts layout
+plus `covers`, so the existing columnar parser reads it. The price is wholesale
+energy only; the framework adds markup and taxes, as for `generic_dayahead`.
+
+## Rules
+
+1. **The host is a constant in the plugin**, declared as its only egress host,
+   HTTPS only. The operator's `price_feed_url` is not read by this provider.
+   *Cost:* every client talks to the one host, and moving the server is a new
+   add-on version. *What replaces the per-site setting:* the egress allow-list,
+   TLS, and a token per client that the server can revoke.
+2. **The chain is server, then energy-charts, then the saved prices**
+   (`app/price_chain.py`). A step counts only if it has a price for *now*: a
+   server that answers with old prices is skipped like one that is down. A step
+   down and a step up are each one log line, written when the step changes. The
+   operator's `price_feed_url` is cleared for the energy-charts step, which is
+   asked for its own feed.
+3. **The saved prices are `/data/price_history.json`**, the file `PriceHistory`
+   already keeps (the last three Brussels days of what was published). They are
+   the all-in prices as stored; a change of markup shows from the next fetch
+   that works. A read from the store is not filed again.
+4. **No price for now** means no published price covers the present moment. Not
+   "none for the coming hours": before about 13:00 tomorrow's prices are not
+   published on any healthy day, and carried hours are already marked estimated.
+   It sets one status row (*Prices*), one Home plan line (English and Dutch),
+   and one notification (*No prices*, English and Dutch), taken down when a
+   price returns. A start-up before the first refresh finished is not a gap.
+   The notification is not re-asserted after a Home Assistant core restart
+   (SAFETY-34 does that for latched safety alarms); the status row stays.
+   *Open for the owner:* if "coming hours" should mean a look-ahead of N hours,
+   that is a change to `gate_for()` and `PriceWatch`, not to the chain.
+5. **The maintenance charge gate** (owner's decision, 2026-10-14): the charge may
+   run when the *current 15-minute price is at or below today's average*, today
+   being the Brussels day, computed from the provider's prices. This is the rule
+   the Home Assistant pair gave (`price_service.yaml`), so a site that moves from
+   the pair to the provider does not change when the maintenance charge runs.
+   It is not `TariffPlan.cheap_now()` (strictly below the mean of the firm
+   hours of the whole plan). This replaces, for this provider only,
+   TARIFF-10 section 4: its three reasons are answered as follows. (1) Two
+   writers: the pair beside a provider stays refused; `static_profile` beside
+   `price_service` is accepted and no longer writes `cheap`. (2) An expired or
+   absent plan shuts the gate (the charge waits), as an unavailable HA sensor
+   did. (3) The basis is the one above, not `cheap_now()`.
+6. **The token is a secret.** `password?` in the schema; hidden on the settings
+   page (`uilayout.HIDDEN`), which can keep `price_service` but not choose it;
+   never put in a message by the plugin; taken out of any reason text by
+   `price.scrub()`; the real transport reports only a status or an exception's
+   name. validate.py refuses `price_service` with no token, a token with a
+   space or line break, and one under 16 characters (so `scrub()`, which skips
+   values under 4 characters, always has something to take out). Round 2: the
+   token is in no page and no JSON answer of the web app. Every `password`
+   option of the schema is shown as `********` (set) or empty, in
+   `/config/model` (`options`, `running`, `ui`) and in a stale refusal; the
+   classic page draws it as a password field; a save or a validate that sends
+   `********` or nothing keeps the stored value, any other value replaces it.
+   A token can therefore be changed but not cleared from the page.
+7. **A fixed tariff beside `price_service` is allowed and quietly noted.** It is
+   still the plan's last fallback (`resolve_tariff` -> `_degrade`); only the
+   cheap window and the gate ignore it, because they read the provider's
+   prices. Keeping it set is the recommended setup, and clearing it triggers the
+   "static_profile is empty" warning, so no notification (round 2's *Fixed
+   tariff not used* was false and fired on every sound start; round 3 removed
+   it). Instead one INFO line at start (English, as every log line) and an info
+   note beside the setting (EN and NL, "With the price service, the fixed
+   tariff is only used if no prices are available."), both
+   only with a non-blank `static_profile` (whitespace counts as blank). At
+   start the add-on dismisses the old notification id, in case a pre-release
+   build raised it.
+8. **The no-price words show only with the maintenance charge on** (owner,
+   2026-10-14): the status row, the Home line and the notification say
+   'maintenance waits', so with `maintenance_enabled` off none is shown.
+
+## Where the gate equals the Home Assistant pair, and where it does not
+
+Equal: `test_price_service.py` section 8 feeds the same day both ways, to the
+rules in `price_service.yaml` (price at the quarter, average of today's
+quarters rounded to 0.00001 EUR/kWh, `<=`), over 6 days including both
+clock-change days, at three instants in every period, and through a real
+`Controller` for a whole day. Every answer is the same.
+
+Not equal, by design or by arithmetic:
+
+- The comparison is made on all-in prices. With a flat taxes figure and a
+  markup and taxes of at most five decimals the offset cancels and the answer
+  is the same. With `price_taxes_profile` (an hour-varying levy) the all-in
+  prices differ by hour, so the answer can differ from the wholesale comparison
+  the HA sensors made. A site on that profile should check before moving.
+- A quarter within 0.00001 EUR/kWh of the average can differ if markup or taxes
+  have more than five decimals.
+- The plan is retired when no refresh has succeeded for 90 minutes
+  (`TARIFF_MAX_AGE_S`) and the gate shuts then. How long the HA pair kept an
+  answer after its REST sensor stopped updating was not measured here.
+- The average is over the firm prices the provider holds for today. After a
+  restart in the middle of a day with only the saved part of today, it is the
+  average of that part.
+
+## Not covered
+
+- **No real answer of the server was seen.** No token was available. The
+  layout is the design's; `test_price_service.py` uses a mock and, for the
+  parser, the real energy-charts capture reshaped with the design's extra keys.
+  The first capture from the live server (rig test) should replace the mock.
+- The 429 limit (about 60 calls an hour) is not approached: one fetch per
+  30 minutes, and at most two requests when the server fails.
+- Battery modes read the plan as for `generic_dayahead` and were not changed.
+- The `price_service` REST and template sensors in Home Assistant are not
+  touched; they stop being read when the pair is cleared.

goodwe_controller/DECISIONS/SAFETY-118-peak-forecast-unit.md

@@ -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.

goodwe_controller/DECISIONS/SAFETY-119-bound-after-hand-back.md

@@ -0,0 +1,96 @@
+# SAFETY-119 - no "not keeping up" when the loop takes the wire back
+
+**Status: for review.** 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.

goodwe_controller/DOCS.md

@@ -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 (W) | `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. |
@@ -222,6 +223,7 @@ The label and description each setting shows on the Configuration tab, in tab or
 | Tariff | Your own injection formula | `price_export_formula` | Optional. The injection formula from your tariff card, in the same shape as your own tariff formula. Leave it empty to use the flat injection price. |
 | Tariff | Price CSV file | `price_csv_path` | For manual_csv only. Where in /share the add-on reads your price file. |
 | Tariff | Price feed URL override | `price_feed_url` | Leave it empty to use the source's own feed. An override is sent exactly as typed and often returns only one day. |
+| Tariff | Price service token | `price_service_token` | For the price service only. The token you were given for it. Leave it empty with any other price source. |
 | Tariff | Price look-ahead (hours) | `price_horizon_h` | How many hours of prices to ask the source for. |
 | Tariff | Price request timeout (s) | `price_timeout_s` | How long one request to the price source may take before it is given up. |
 | Tariff | Current price entity (older) | `price_now_entity` | The older way to get a price, used only to charge in a cheap window during maintenance. Do not combine it with a dynamic price source. |
@@ -290,6 +292,7 @@ When the add-on refuses to start, each reason names the setting by its label and
 - **Fixed or day/night tariff** (`static_profile`): the periods must cover every day type exactly once with no gap and no overlap, and a gap is refused rather than filled. A window 22:00-07:00 on mon-fri does not cover Saturday morning, so a weekend row is required. See [Static day/night and fully-fixed tariffs](#static-daynight-and-fully-fixed-tariffs-static_profile).
 - **Your own tariff and injection formula** (`price_formula`, `price_export_formula`): type the card's numbers in the card's units. The `card` block is required on the tariff formula: the add-on recomputes the card's example price and refuses to start if it does not come out. Injection is VAT-exempt in Belgium, so `vat_pct` there is normally 0. See [Your own tariff formula](#your-own-tariff-formula-custom_formula) and [`price_export_formula`, field by field](#price_export_formula-field-by-field).
 - **Price feed URL override** (`price_feed_url`): only a host the chosen source declares is accepted. Nothing is added to the URL, not even the date range, so an override often returns one day and the rest of the plan is carried over and excluded from trading. The log warns on every refresh.
+- **Price service token** (`price_service_token`): a password field. Every page of the add-on, and every answer its web app gives, shows only `********` when a token is set and nothing when not; the token itself is never sent to a page. A save that leaves the field empty or as `********` keeps the stored token, and a new value replaces it. It must be at least 16 characters. It is needed with `price_provider: price_service`, and the add-on refuses to start without it. It never appears in the log, the status page, a refusal or a notification. See [`price_service`](#price_service--your-own-price-server-and-what-it-falls-back-to).
 - **Current and average price entities** (`price_now_entity`, `price_avg_entity`): kept because removing them would take the maintenance cycle's only price signal away from a live site.
 - **Trade on the price spread** (`arbitrage_enabled`): off as shipped, on purpose, because it moves energy against the meter by design. It needs a price source and a P1 meter, and the add-on refuses combinations that cannot work.
 - **Battery cycle cost** (`cycle_cost_threshold_eur`): wear plus conversion losses. It is not derived from a measurement: 0.10 is a product decision still open with the owner (OPT-08). At this value a fixed day/night site does not trade, since a realistic Belgian day/night spread is about 0.08 EUR/kWh.
@@ -1695,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` |
@@ -2198,20 +2201,24 @@ does, and only after you have read why.
 > `static_profile` below needs no network at all, so its cheap window is
 > computed on every cycle and reaches the maintenance cycle's grid top-up
 > whether or not arbitrage is armed. ⚠️ **And it is still the only source of
-> that window.** A provider-backed plan now exists on every configured site,
-> but *Cheap window* and the maintenance cycle's grid top-up read
-> `static_profile` and nothing else — a deliberate limit, recorded with what it
-> would take to change in `DECISIONS/TARIFF-10-fetching-is-not-trading.md`.
+> that window, with one exception.** A provider-backed plan exists on every
+> configured site, but *Cheap window* and the maintenance cycle's grid top-up
+> read `static_profile` and nothing else — a deliberate limit, recorded with
+> what it would take to change in
+> `DECISIONS/TARIFF-10-fetching-is-not-trading.md`. The exception is
+> `price_service` (PRICE-01): with it, the window comes from the provider's own
+> prices, as described under [`price_service`](#price_service--your-own-price-server-and-what-it-falls-back-to).
 
 | option | meaning |
 |---|---|
-| `price_provider` | `off` (default) or one of the three plugins below |
+| `price_provider` | `off` (default) or one of the plugins below |
 | `price_markup_eur_kwh` | Your supplier's margin, EUR/kWh. **Added only when the chosen plugin's feed does not already contain it** |
 | `price_taxes_eur_kwh` | Distribution, levies and VAT, EUR/kWh. Same rule. Defaults to **0.11736** — a real Flemish figure, and **yours is probably different**: see *What `price_taxes_eur_kwh` is made of* below |
 | `export_price_eur_kwh` | The **flat injection** price, EUR/kWh. May be negative — see below |
 | `price_export_formula` | The **injection formula**, if your contract has one. Same shape as `price_formula`, its own coefficients, its own `vat_pct` — see below |
 | `price_csv_path` | Where `manual_csv` reads its file |
 | `price_feed_url` | Override the plugin's default feed. Used **exactly as written** — the add-on appends nothing to it, including the date range, so an override gets whatever horizon that URL returns. Only a host the plugin itself declares is accepted |
+| `price_service_token` | The token for `price_service`. A password field. Empty with any other source |
 | `price_horizon_h` | How far ahead to ask for, hours |
 | `price_timeout_s` | Per-request timeout |
 | `static_profile` | A static day/night or fully-fixed tariff. Empty by default — see below |
@@ -2224,6 +2231,7 @@ arbitrage decision wrong by that amount, in a direction nothing reports.
 | plugin | product | the published figure contains | the add-on adds |
 |---|---|---|---|
 | `generic_dayahead` | day-ahead | energy only (wholesale EPEX BE) | markup **and** taxes |
+| `price_service` | day-ahead | energy only (wholesale, from your own price server) | markup **and** taxes |
 | `custom_formula` | day-ahead | energy **and** your contract's markup — your card's `Tariefformule` line | taxes |
 | `manual_csv` | day-ahead | everything, all-in | nothing |
 
@@ -2253,6 +2261,86 @@ from. Any alias would have to invent the numbers your battery is priced against.
 Eneco's dynamic product is *Zon & Wind Dynamisch*, and it is indexed to
 Belpex/EPEX **day-ahead**, not to imbalance.)
 
+#### `price_service` — your own price server, and what it falls back to
+
+*For installers: PRICE-01. The decision is in
+`DECISIONS/PRICE-01-own-price-server.md`.*
+
+`price_provider: price_service` reads the day-ahead prices for Belgium from the
+owner's price server, `https://prices.kammenstraatha.duckdns.org/v1/dayahead/BE`.
+The host is fixed in the add-on and only HTTPS is used. The token goes in
+`price_service_token` and is sent as `Authorization: Bearer <token>`. The server
+answers the energy-charts layout, so the same parser reads it. The price is the
+wholesale energy price and nothing else, so the add-on adds your markup and
+taxes exactly as for `generic_dayahead`.
+
+**Where the prices come from.** Each step is used only if it has a price for
+now. A server that answers with last night's prices is treated as down.
+
+| Step | Source | When it is used | What the log says (once per change) |
+|---|---|---|---|
+| 1 | The price server | It answers, with a price for now | `The price service answers again.` on the way back. |
+| 2 | energy-charts.info | Step 1 fails: down, timeout, refused token (401), error (5xx), a damaged answer, or no price for now | `The price service does not answer, so prices come from energy-charts.` Or `The price service refused the token, so prices come from energy-charts.` |
+| 3 | The prices saved in `/data/price_history.json` | Steps 1 and 2 fail | `No price source answers, so the add-on uses the prices it saved.` |
+| none | Nothing | No saved price covers now either | `No price source answers, and no saved price covers now.` |
+
+The saved prices are the last answers that worked, kept on disk, so a site
+whose server and energy-charts are both down for a day goes on planning from
+what it has. It keeps the days the history holds (today, tomorrow once it was
+fetched, and a day back). They are the all-in prices as stored: a change of
+markup or taxes shows from the next fetch that works. Going back up the chain
+is logged once as well: `Prices come from energy-charts again.` and `The price
+service answers again.` The refresh runs every 30 minutes.
+
+**When there is no price for now (step none).** One status line, `Prices: No
+prices since 00:00, maintenance waits.` (on the add-on page; the Home screen says
+the same in English and Dutch), and one notification, *No prices*. Both go when a
+source has a price for now again. They show only while **Run the monthly battery cycle**
+(`maintenance_enabled`) is on; with it off, neither is shown. "Since" is the moment the last price ran out.
+Before the first refresh has finished there is no line, so a start-up is not a
+gap. Control is not touched: the battery follows the meter as ever, battery
+modes and trading read what prices there are, and only the maintenance charge
+waits.
+
+**The maintenance charge and the cheap window.** With this provider the
+maintenance charge gate reads the provider's prices and no Home Assistant
+entity. It keeps the rule the Home Assistant pair gave: the charge may run
+when the **current 15-minute price is at or below today's average**, today
+being the Brussels day. Moving a site from the pair to `price_service` does not
+change when the charge runs. Where the two can differ is listed in the decision
+record: the Home Assistant average was rounded to 0.00001 EUR/kWh, and so is
+this one before it is compared. With no price for now the gate is shut, as it
+was when an entity was unavailable. *Cheap window* on the status page shows this
+answer. This is not the *cheap hours* rule of battery modes and not
+`cheap_now()`.
+
+**Moving a site from the Home Assistant price sensors to `price_service`.**
+Do this on the Configuration tab, in one save, and restart once:
+
+1. Set **Dynamic price source** (`price_provider`) to `price_service`.
+2. Paste the token into **Price service token** (`price_service_token`).
+3. **Clear** **Current price entity** (`price_now_entity`) and **Average price
+   entity** (`price_avg_entity`). The add-on refuses to start with a price
+   source and these two together.
+4. Check **Supplier markup** and **Distribution, levies and VAT**. With the
+   Home Assistant pair they decided nothing about the maintenance charge. With
+   the provider they are added to the wholesale price, so they set the prices
+   shown on the page and, if battery modes or trading are on, the prices those
+   decide on. The maintenance charge gate does not depend on them.
+5. Keep **Fixed or day/night tariff** (`static_profile`) if you have one; it
+   is fine to leave it set. It is the plan's last fallback: it is used,
+   marked as estimated and without trading, only when no source has a price.
+   *Cheap window* and the maintenance charge never read it: the provider's
+   prices decide them. The add-on logs one INFO line at start ("Fixed tariff
+   is only used if no prices are available.") and shows the same note beside
+   the setting. Nothing needs clearing, and clearing it only removes the
+   fallback (the settings page then warns that the site has no tariff while the
+   price feed is down).
+6. Remove the `price_service` REST and template sensors from Home Assistant
+   when you are satisfied. They are no longer read.
+
+To go back: put the two entities back, set the source to `off`, and restart.
+
 #### So what should a Belgian dynamic-tariff customer do today?
 
 **Honestly: `generic_dayahead` gets you close, and you should know exactly how
@@ -2809,6 +2897,9 @@ uses the result as a cheap-window hint for the maintenance charge. They are
 — configure two of them and the add-on refuses to start, naming the conflict,
 because the add-on reads exactly one and the loser is silent. Use one.
 
+To move a site off them onto the owner's price server, see [`price_service`](#price_service--your-own-price-server-and-what-it-falls-back-to):
+it lists which options to set and which to clear.
+
 ### The three buckets — which price components can move a decision
 
 *For installers: card TARIFF-17.*
@@ -3023,15 +3114,16 @@ second set of 23- and 25-hour-day bugs.
 ### Static day/night and fully-fixed tariffs (`static_profile`)
 
 Most Belgian households are **not** on a dynamic contract, and an EMS that only
-works under hourly pricing is an EMS for a minority. `static_profile` is how a
+works under dynamic pricing is an EMS for a minority. `static_profile` is how a
 two-period day/night tariff or a single fixed price becomes a first-class
 configuration rather than "turn the price feature off and hope".
 
 On the add-on page, choose **Other time windows** under Settings, Tariff and
 prices, or in Setup step 4. Add one row per time window, with its start, end,
 days and price. The page names any overlap, gap or empty price before you can
-save. You only need the JSON below for days the page cannot choose, such as
-Monday and Wednesday only.
+save. Prices take five decimals: divide the c€/kWh on your bill by 100, so
+34.512 c€/kWh is 0.34512 €/kWh. You only need the JSON below for days the page
+cannot choose, such as Monday and Wednesday only.
 
 It is one option, holding a JSON object, on one line:
 
@@ -3282,8 +3374,22 @@ days before it tries again, so it does not empty the battery every night. To
 try sooner, start a cycle on the add-on page. If it keeps happening, check that
 the battery follows its commands and that the cheap hours leave time to charge.
 
+### No prices
+
+No price source has a price for the present moment: not the price server,
+not energy-charts, and nothing saved. The monthly battery cycle waits, because
+it will not charge from the grid without a price to judge by. Control of the
+battery goes on as before. Check that the add-on can reach the internet and that
+the price service token is right. The notification goes by itself when a price
+is back. It is shown only while the monthly battery cycle is switched on.
+
 ### For installers: notifications
 
+A fixed tariff beside the price service raises no notification: it is the
+plan's last fallback, not a fault. An earlier pre-release build raised a card
+with the id `goodwe_fixed_tariff_unused`; the add-on takes that id down at every
+start, which does nothing when it is absent.
+
 This part is for installers. The texts live in `app/messages.py` and follow
 `STYLE.md`. Every notification keeps a fixed `notification_id`, so a repeat
 replaces the card. The ERROR or WARNING line of the add-on log names the
@@ -3302,6 +3408,7 @@ default `info` hides it.
 | *name* is not delivering | alarm | `goodwe_not_delivering_<name>` | SAFETY-42 |
 | Meter reading may be stuck | alarm | `goodwe_meter_frozen` | SAFETY-18 |
 | Battery cycle did not finish | warning | `goodwe_maint_failed_<name>` | MAINT-13 |
+| No prices | warning | `goodwe_no_prices` | PRICE-01 |
 
 **The Details link.** Home Assistant 2026.2 and newer show add-on pages at
 `/config/app/<slug>/documentation`; 2026.5 removed the old
@@ -3413,6 +3520,11 @@ day's price runs.
 An Off battery that the peak limit still needs says so, with the power it
 gives: "Off, but gives 0.5 kW for the peak limit."
 
+With two or more batteries, each card also has **Start cycle** and **Stop
+cycle**, to run the monthly cycle on that battery now. Only one battery cycles
+at a time: a start while another battery is cycling, or on a battery that is
+switched off, is refused and the message names the battery.
+
 **Settings** opens on the **Simple** view, or on the view you last picked:
 the peak limit, the batteries' switches and modes, and shadow mode, each
 marked "Applies right away" or "Applies after a restart". **Installer** shows
@@ -3494,6 +3606,7 @@ for a new install*.
 | Direction check, Site direction check | Whether each inverter's power goes the way the add-on asks. *Opposite for 12 of 60 seconds* counts toward a stop. When it stops, the inverter, or every inverter, is set to 0 W until you start control. |
 | Check for inverters working against each other, Inverters worked against each other | Only with several inverters. See *Inverters working against each other*. |
 | Delivery check, *name* is not delivering | Only with several inverters. See *An inverter is not delivering*. |
+| Prices | Only while no price source has a price for now: *No prices since 00:00, maintenance waits.* See *No prices* under Notifications. |
 | Solar production | Your solar production. Sources are numbered in the order of “Solar production entities, per inverter”. A strongly negative reading by day means that entity reads the wrong way round: add it to “Reversed-sign solar entities”. |
 
 ### For installers: status page

goodwe_controller/app/config_page.py

@@ -221,6 +221,11 @@ function makeInput(field, value, onchange){
       input.step = field.type === 'integer' ? '1' : 'any';
       if(field.min !== undefined) input.min = field.min;
       if(field.max !== undefined) input.max = field.max;
+    } else if(field.type === 'password'){
+      input.type = 'password';
+      input.autocomplete = 'new-password';
+      input.autocapitalize = 'none';
+      input.spellcheck = false;
     } else {
       input.type = 'text';
       input.autocapitalize = 'none';

goodwe_controller/app/configui.py

@@ -206,6 +206,8 @@ def _one_field(node, translations, lang, path=()):
         "multiple": bool(node.get("multiple")),
         "unit": unit_of(key),
     }
+    if node.get("format") == "password":
+        field["type"] = "password"
     if node.get("lengthMin") is not None:
         field["min"] = node["lengthMin"]
     if node.get("lengthMax") is not None:
@@ -306,6 +308,52 @@ def problems_by_field(problems, keys):
     return by_key, unanchored
 
 
+# --------------------------------------------------------------------------- #
+# SECRETS (PRICE-01 F1). A `password` option never leaves this process in a page
+# or a JSON answer. The pages get SECRET_SHOWN when one is set and "" when not.
+# A save that sends SECRET_SHOWN or nothing keeps the stored value; any other
+# value replaces it. The names come from the Supervisor's own schema, so a
+# password option added later is covered without an edit here.
+# --------------------------------------------------------------------------- #
+SECRET_SHOWN = "********"
+
+
+def secret_keys(schema, extra=()):
+    """Names of the options whose schema type is `password`, plus `extra`."""
+    # The Supervisor may spell it `type: password` or `type: string` with
+    # `format: password`; both count.
+    return frozenset(str(n.get("name")) for n in schema or ()
+                     if isinstance(n, dict) and (
+                         n.get("type") == "password"
+                         or n.get("format") == "password")
+                     ) | frozenset(extra)
+
+
+def hide_secrets(value, keys):
+    """A copy of `value` with every secret key's value replaced by
+    SECRET_SHOWN (set) or "" (empty), at any depth."""
+    if isinstance(value, dict):
+        return {k: ((SECRET_SHOWN if v else "") if k in keys
+                    else hide_secrets(v, keys))
+                for k, v in value.items()}
+    if isinstance(value, list):
+        return [hide_secrets(v, keys) for v in value]
+    return value
+
+
+def keep_secrets(proposed, stored, keys):
+    """`proposed` with each secret the page did not change put back from
+    `stored`: absent, empty or SECRET_SHOWN means 'leave it'."""
+    out = dict(proposed)
+    for key in keys:
+        if out.get(key) in (None, "", SECRET_SHOWN):
+            if isinstance(stored, dict) and key in stored:
+                out[key] = stored[key]
+            elif key in out and out[key] == SECRET_SHOWN:
+                out[key] = ""
+    return out
+
+
 def changed_keys(left, right):
     """Sorted keys whose values differ between two option blobs.
 

goodwe_controller/app/homeview.py

@@ -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
@@ -551,13 +596,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)
+    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)}
@@ -582,6 +629,8 @@ def build_plan(c, now, shadow, running, held=False, settled=True):
         cyc, waits = maintenance_runs(c, day0, day1, now, shadow)
         runs += cyc
         lines += waits
+        if getattr(c, "price_gap", False):
+            lines.append(line_no_prices(c.price_gap_since, now))
         runs += peak_run(c, day0, day1, now, shadow, limit_w)
         if c.p1_enabled:
             # The guard's ceiling: the cap, or this month's peak once above it.
@@ -1268,6 +1317,17 @@ def line_cycle_waits(name) -> str:
     return _t("cycle_waits", name=name)
 
 
+def line_no_prices(since, now) -> str:
+    """PRICE-01: no price covers now. `since` is an instant or None."""
+    if since is None:
+        return _t("no_prices_yet")
+    local, today = brussels(since), brussels(now)
+    if local.date() == today.date():
+        return _t("no_prices_since", at=f"{local:%H:%M}")
+    return _t("no_prices_since_day", day=local.day, month=month_name(local),
+              at=f"{local:%H:%M}")
+
+
 def line_peak_limit(limit_w, shadow) -> str:
     return _w(shadow, "step_in", kw=_kw(limit_w))
 
@@ -1387,6 +1447,16 @@ def _samples() -> list:
             ("plan", run_house_why()), ("plan", run_house_why(True)),
             ("plan", run_house_amount()),
             ("plan", line_cycle_waits("Battery B")),
+            ("plan", line_no_prices(None, datetime(2026, 10, 14, 9, 0,
+                                                   tzinfo=timezone.utc))),
+            ("plan", line_no_prices(datetime(2026, 10, 14, 0, 0,
+                                             tzinfo=timezone.utc),
+                                    datetime(2026, 10, 14, 9, 0,
+                                             tzinfo=timezone.utc))),
+            ("plan", line_no_prices(datetime(2026, 10, 13, 22, 0,
+                                             tzinfo=timezone.utc),
+                                    datetime(2026, 10, 14, 9, 0,
+                                             tzinfo=timezone.utc))),
             ("plan", line_prices(0.16, {"eur_kwh": 0.14, "label": "13:00"},
                                  {"eur_kwh": 0.36, "label": "19:00"})),
             ("plan", line_prices(None, None, None)),
@@ -1408,3 +1478,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})

goodwe_controller/app/main.py

@@ -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
@@ -90,6 +90,8 @@ from .p1 import P1Ingest, build_source, is_enabled
 from .price import Absence, Uncertainty, brussels, price_option, provider_configured
 from .price import required_spread as price_required_spread
 from .price import uncertainty_of as price_uncertainty_of
+from .price_chain import (PriceWatch, fixed_tariff_beside_service, gate_for,
+                          uses_chain)
 from .price_history import PriceHistory
 from .static_tariff import resolve_tariff, static_gated, static_status
 from .tariff import PeakStore, PeakTracker, next_quarter
@@ -297,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: across all hand-backs, the loop's bound is hidden on at most
+# ROLLING_BUDGET cycles in any ROLLING_S seconds, fewer on a slower cycle:
+# (cycle seconds up to, cycles), measured in
+# DECISIONS/SAFETY-119-bound-after-hand-back.md. Without a monotonic clock
+# the budget never refills.
+ROLLING_S = 900.0
+ROLLING_BUDGET = ((3.5, 10), (11.0, 8), (16.0, 6), (float("inf"), 4))
+ROLLING_BOUND_CYCLES = 8        # the budget while the cycle length is unknown
 
 
 def _refused_interval(sign: int) -> tuple:
@@ -1200,8 +1210,22 @@ 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
+        # once per change), the last series that was published (so a gap can say
+        # since when), and the gap itself: True while a refresh has finished and
+        # no published price covers now. The notification is raised once per
+        # gap and taken down when it ends.
+        self.price_watch = PriceWatch()
+        self._last_published = None
+        self.price_gap = False
+        self.price_gap_since = None
+        self._price_gap_announced = False
+        self._fixed_note_said = False
         self._gated_key = None        # MAINT-13: (options, hour) of the cache
         # TARIFF-03. One line of prose for the status page saying WHICH tariff
         # window we are in and why it is or is not cheap - so "Cheap window:
@@ -1256,6 +1280,14 @@ 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; the
+        # last cycle's monotonic s and the cycle length.
+        self._wire_lost = False
+        self._handback = None
+        self._hidden = ()
+        self._settle_t, self._settle_dt = None, None
         self.stopping = False
         # SAFETY-61. time.monotonic() at the end of the last run_control() pass.
         self.loop_pass_mono = None
@@ -2428,6 +2460,19 @@ class Controller:
         tick = self.mode_tick
         if tick is None:
             return False
+        if tick.action == modetrade.CHARGE:
+            # OPT-20: the ask carries PROBE_W for exactly the probes whose pin
+            # is filed this tick. `decide()` ran before the pin was (or the
+            # window closed since), so the two can differ by one cycle; left
+            # alone, the allocator takes the pin's watts out of another
+            # battery's share, or hands them to one it can reach.
+            pins = _ctl.PROBE_W * sum(
+                1 for c in claims if c.source == "refused"
+                and c.kind == "set" and c.value < 0)
+            if pins != tick.probe_w:
+                tick = self.mode_tick = dataclasses.replace(
+                    tick, ask_w=tick.ask_w + tick.probe_w - pins,
+                    probe_w=pins)
         size = modetrade.size(tick, self.loop_bound(claims)
                               if tick.action else None, self.arb_headroom_w)
         runs = self.mode_runs
@@ -2777,6 +2822,43 @@ class Controller:
             out["sell"] = pm.sell
         return out
 
+    async def _maint_unit_action(self, what, unit, now) -> dict:
+        """MAINT-11: start or abort the maintenance cycle of ONE named battery.
+
+        Returns `{"error", "code", "unit"}` for a refusal and changes nothing.
+        The site keeps its one maintenance slot: a start while any battery
+        holds it is refused (no queue), see DECISIONS/MAINT-11. The phase
+        machine is not touched beyond `force_start()` and `abort()`, the same
+        two calls the bare button makes.
+        """
+        inv = next((i for i in self.inverters if i.name == unit), None)
+        if inv is None:
+            return self._maint_refusal("unit")
+        machine = self.maints[self.inverters.index(inv)]
+        if what == "maint_start":
+            holder = next((i for i, m in zip(self.inverters, self.maints)
+                           if m.phase in POWER_MOVING), None)
+            if holder is not None:
+                return self._maint_refusal("busy", holder.name)
+            if self.modes_on and not self.pack_mode(inv).use:
+                return self._maint_refusal("off", inv.name)
+            for msg in machine.force_start(now):
+                self.log_event(msg, hint=messages.hint(
+                    "maintenance", phase=machine.phase))
+            return {"unit": inv.name, "phase": machine.phase}
+        if machine.phase not in POWER_MOVING:
+            return self._maint_refusal("idle", inv.name)
+        for msg in machine.abort(now, "operator"):
+            self.log_event(msg, hint=messages.hint("maintenance",
+                                                   phase=machine.phase))
+        await self.command_site_zero()
+        return {"unit": inv.name, "phase": machine.phase}
+
+    @staticmethod
+    def _maint_refusal(code, unit="") -> dict:
+        return {"error": messages.maint_refused(code, unit), "code": code,
+                "unit": unit}
+
     def mode_values(self) -> dict:
         """OPT-11 P2: each battery's mode and switch, for their HA state
         topics. Read from the store, so they are right after a restart. Empty
@@ -3295,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."""
@@ -3385,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:
@@ -3398,6 +3502,12 @@ class Controller:
             self.cheap = (now_p is not None and avg_p is not None and now_p <= avg_p)
             self._price_gated = True
             self.tariff_words = "Prices from Home Assistant entities"
+        elif uses_chain(o):
+            # PRICE-01. A provider with fallbacks gives the maintenance gate
+            # its own prices: the current 15-minute price against today's
+            # average, as the Home Assistant pair did. Still no I/O here - the
+            # series is the one the background refresh stored.
+            self._provider_gate(datetime.now(timezone.utc))
         else:
             # TARIFF-03. §9.2 makes a static day/night tariff a first-class
             # product, and its required EMS handling is TIME-WINDOW SHIFTING.
@@ -3961,6 +4071,38 @@ class Controller:
                            inv.refusal_note())]
                 if n]
 
+    def _provider_gate(self, now: datetime) -> None:
+        """PRICE-01: `cheap`, the gate and the gap from the standing plan.
+
+        The gate exists whenever the provider does: no price for now is a
+        closed gate, so the charge waits and does not run unpriced. The gap
+        flag stays False until the first refresh has finished, so a start-up
+        is not a gap.
+        """
+        plan = self.fresh_tariff_plan(now)
+        published = None if plan is None else plan.published
+        if published is not None:
+            self._last_published = published
+        gate = gate_for(published, now)
+        self.cheap, self._price_gated = gate.cheap, True
+        self.tariff_words = gate.words
+        # Owner, 2026-10-14: the words say 'maintenance waits', so they show
+        # only while the maintenance charge is on.
+        self.price_gap = ((not gate.covered) and self.tariff_at is not None
+                          and MaintConfig.from_options(self.o).enabled)
+        last = self._last_published
+        if gate.covered or last is None:
+            self.price_gap_since = None
+        elif last.covers(now):
+            # The last series still covers now, but no refresh has made it
+            # current for TARIFF_MAX_AGE_S: the refresh task has stopped. The
+            # gap began when the plan was retired.
+            self.price_gap_since = (
+                None if self.tariff_at is None
+                else self.tariff_at + timedelta(seconds=TARIFF_MAX_AGE_S))
+        else:
+            self.price_gap_since = last.last_end_before(now)
+
     def _static_gated(self, o: dict, now: datetime) -> bool:
         """`static_gated()`, worked out once an hour: it builds the same
         month-long plan as `static_status()` (about 20 ms with a profile), and
@@ -5499,6 +5641,12 @@ class Controller:
         # is not, and test_freeze.py part 5 fails on exactly that.
         await self.check_meter_frozen()
 
+        # --- PRICE-01: no price for now, said once and taken down once --------
+        # Not a safety check, so it is one of the cheap ones: an attribute test
+        # and, on a change only, one Home Assistant call.
+        await self.check_price_gap()
+        await self.check_fixed_note()
+
         # --- SAFETY-31's alarm, and its boundary is the LATCH, not a number ---
         # Unconstrained where the two above are not: it grades
         # `self.circ_wd.tripped`, which was advanced near the top of this method
@@ -5681,6 +5829,8 @@ class Controller:
         if d is None:
             self._short_run = 0
             self._asked_hist = {}
+            self._wire_lost, self._handback = False, None
+            self._settle_t = None             # a stop is not a cycle length
             return
         unmet = self.allocation.unmet_w if self.allocation is not None else 0
         cut = (resolution.bound_by or "").split("(")[0]
@@ -5706,7 +5856,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
@@ -5715,6 +5867,49 @@ 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. The settle is SHORT_CYCLES cycles and SHORT_SPAN_S
+        after the hand-back; losing the wire restarts it. Across all
+        hand-backs the bound is hidden on at most ROLLING_BUDGET[cycle
+        length] cycles in any ROLLING_S, so a bound that stays is counted
+        however often the wire changes hands.
+        DECISIONS/SAFETY-119-bound-after-hand-back.md."""
+        def aged(t0, span):
+            return now is None or t0 is None or now - t0 >= span
+
+        # The cycle length (a gap over two minutes is not one).
+        if now is not None and self._settle_t is not None \
+                and 0.0 < now - self._settle_t <= 120.0:
+            self._settle_dt = now - self._settle_t
+        self._settle_t = now
+        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 >= SHORT_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))
+            dt = self._settle_dt
+            budget = ROLLING_BOUND_CYCLES if dt is None else next(
+                m for up, m in ROLLING_BUDGET if dt <= up)
+            if len(kept) >= budget:
+                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.
 
@@ -6115,6 +6310,50 @@ class Controller:
             await self.hass.call("persistent_notification", "create",
                                  messages.not_delivering(inv.name, slug).data())
 
+    async def check_price_gap(self) -> None:
+        """PRICE-01. One notification when no price covers now, gone when one does.
+
+        `price_gap` is worked out on the tick from the stored plan. A gap
+        raises the notification once: the flag is set BEFORE the await, for
+        `check_circulating()`'s reason (a Home Assistant call can raise or
+        hang, and a retry every cycle would be a storm). When the gap ends the
+        same notification is taken down. Control is not touched either way: the
+        maintenance charge waits because its gate is shut (`_provider_gate`),
+        and nothing here decides that.
+        """
+        if self.price_gap and not self._price_gap_announced:
+            self._price_gap_announced = True
+            await self.hass.call("persistent_notification", "create",
+                                 messages.no_prices(*self._gap_args()).data())
+        elif not self.price_gap and self._price_gap_announced:
+            self._price_gap_announced = False
+            await self.hass.call("persistent_notification", "dismiss",
+                                 messages.prices_back().data())
+
+    async def check_fixed_note(self) -> None:
+        """PRICE-01 G1. At the first cycle only: one INFO line when a
+        `static_profile` is set beside `price_service` (it is the plan's last
+        fallback, not a fault, so no notification), and a dismiss of the card an
+        earlier build raised, which is harmless when absent."""
+        if self._fixed_note_said:
+            return
+        self._fixed_note_said = True
+        if fixed_tariff_beside_service(self.o):
+            _LOG.info(messages.FIXED_TARIFF_LOG)
+        try:
+            await self.hass.call("persistent_notification", "dismiss",
+                                 messages.fixed_tariff_card_gone().data())
+        except Exception:  # noqa: BLE001 - housekeeping never stops a cycle
+            _LOG.debug("Could not take down the old fixed-tariff card.")
+
+    def _gap_args(self) -> tuple:
+        """`(since, now)` in Brussels time for the gap's words. `since` is None
+        when no price was ever published."""
+        now = brussels(datetime.now(timezone.utc))
+        if self.price_gap_since is None:
+            return None, now
+        return brussels(self.price_gap_since), now
+
     async def check_meter_frozen(self) -> None:
         """SAFETY-18. Alarm on a meter that answers forever without changing.
 
@@ -6249,7 +6488,7 @@ class Controller:
             try:
                 plan = await resolve_tariff(
                     self.o, now, now + timedelta(hours=horizon), now=now,
-                    history=self.price_history)
+                    history=self.price_history, watch=self.price_watch)
                 standing = self.fresh_tariff_plan(now)
                 # Three terms, and each of them is the only false one in some
                 # check: the feed answered (replace), nothing current stands
@@ -7089,6 +7328,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", ())
@@ -7326,6 +7569,9 @@ class Controller:
             ("Maintenance due", "now" if next_due is None else next_due.strftime("%Y-%m-%d")),
             ("Cheap window", "yes" if self.cheap else "no"),
             ("Tariff", self.tariff_words),
+            # PRICE-01: only while no price covers now.
+            *((("Prices", messages.row_no_prices(*self._gap_args())),)
+              if self.price_gap else ()),
             # FCST-04. WHAT §8.3 HAS TO CARRY FORWARD, which is the difference
             # between a 48-hour plan and a 12-hour one on a weekday morning.
             # It is its own row rather than a clause of "Tariff" because it
@@ -7513,6 +7759,10 @@ class Controller:
                 # would read as the stop button not working.
                 await self.command_site_zero()
             return {"auto": self.auto}
+        if what in ("maint_start", "maint_abort") and unit is not None:
+            # MAINT-11: the operator named the battery. A request with no unit
+            # falls through to the branches below, unchanged.
+            return await self._maint_unit_action(what, unit, now)
         if what == "maint_start":
             # ⚠️ WHICH PACK, BECAUSE THERE ARE NOW SEVERAL AND THE BUTTON HAS
             # ONE LABEL. `_maint_button()` answers it: the pack that holds the
@@ -7523,10 +7773,8 @@ class Controller:
             # picked on its own. At N=1 both branches are `maints[0]` and this
             # is the shipped call, byte for byte.
             #
-            # A PER-PACK BUTTON IS A UI CARD, NOT THIS ONE. `web.py` posts a
-            # bare `maint_start` with no unit, and inventing a unit parameter
-            # here would ship half a surface: the page would still have one
-            # button and the API would have two meanings.
+            # This is the bare request (no unit). A request naming a battery
+            # was handled above by `_maint_unit_action()` (MAINT-11).
             _m = self._maint_button(now)
             for msg in _m.force_start(now):
                 self.log_event(msg, hint=messages.hint("maintenance",

goodwe_controller/app/messages.py

@@ -129,6 +129,8 @@ S_NOT_DELIVERING = "An inverter is not delivering"
 T_METER_FROZEN = "Meter reading may be stuck"
 T_MAINT_FAILED = "Battery cycle did not finish"
 T_MAINT_FAILED_NL = "Batterijcyclus niet afgerond"
+T_NO_PRICES = "No prices"
+T_NO_PRICES_NL = "Prijzen ontbreken"
 
 ID_LOOP_BOUND = "goodwe_integrator_bound"
 ID_OUTPUT_CLAMP = "goodwe_output_clamp"
@@ -138,6 +140,10 @@ ID_CIRCULATING = "goodwe_circulating_power"
 ID_NOT_DELIVERING = "goodwe_not_delivering_{slug}"
 ID_METER_FROZEN = "goodwe_meter_frozen"
 ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
+ID_NO_PRICES = "goodwe_no_prices"
+# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
+# the add-on only dismisses it at start.
+OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
 
 # Which limit cut a command (clamp.ClampResult.bound, plus the loop's own).
 # The setting is named by its label, "Inverter rating (W)".
@@ -314,6 +320,77 @@ def maint_failed(kind: str, days: int, unit: str = "", slug: str = "") -> Notice
                   T_MAINT_FAILED, en, body_nl=f"{T_MAINT_FAILED_NL}. {nl}")
 
 
+NL_MONTHS = ("jan", "feb", "mrt", "apr", "mei", "jun", "jul", "aug", "sep",
+             "okt", "nov", "dec")
+
+
+def since_text(since, now, lang="en") -> str:
+    """`00:00` for a moment today, `13 Oct at 21:00` (`13 okt om 21:00` in
+    Dutch) for an earlier day. Both arguments are already in the site's zone.
+    Empty for no moment."""
+    if since is None:
+        return ""
+    if since.date() == now.date():
+        return f"{since:%H:%M}"
+    if lang == "nl":
+        return f"{since.day} {NL_MONTHS[since.month - 1]} om {since:%H:%M}"
+    return when(since)
+
+
+def no_prices(since=None, now=None) -> Notice:
+    """PRICE-01: no source has a price for now. Said once, gone with the gap.
+    `since` is the moment the last price ran out, or None."""
+    if since is not None:
+        en = (f"No prices since {since_text(since, now)}, so the monthly "
+              f"battery cycle waits until they return.")
+        nl = (f"Sinds {since_text(since, now, 'nl')} zijn er geen prijzen, dus "
+              f"de maandelijkse batterijcyclus wacht tot ze terug zijn.")
+    else:
+        en = ("No prices have come in yet, so the monthly battery cycle waits "
+              "until they do.")
+        nl = ("Er zijn nog geen prijzen binnen, dus de maandelijkse "
+              "batterijcyclus wacht tot ze er zijn.")
+    return Notice(ID_NO_PRICES, WARNING, T_NO_PRICES, en,
+                  body_nl=f"{T_NO_PRICES_NL}. {nl}")
+
+
+@dataclass(frozen=True)
+class Dismiss:
+    """The payload that takes one notification down again."""
+    id: str
+
+    def data(self) -> dict:
+        return {"notification_id": self.id}
+
+
+def prices_back() -> Dismiss:
+    """PRICE-01: the 'No prices' notification, taken down when a price is back."""
+    return Dismiss(ID_NO_PRICES)
+
+
+# PRICE-01: a fixed tariff beside the price service. One true sentence, for the
+# start-up log (English only, as every log line) and the settings page (EN, NL).
+FIXED_TARIFF_LOG = "Fixed tariff is only used if no prices are available."
+FIXED_TARIFF_NOTE = ("With the price service, the fixed tariff is only used if "
+                     "no prices are available.")
+FIXED_TARIFF_NOTE_NL = ("Met de prijsdienst wordt het vaste tarief alleen "
+                        "gebruikt als er geen prijzen zijn.")
+# Settings-page notes that have a Dutch twin (uipage.anchors).
+NOTE_NL = {FIXED_TARIFF_NOTE: FIXED_TARIFF_NOTE_NL}
+
+
+def fixed_tariff_card_gone() -> Dismiss:
+    """PRICE-01: takes down the card an earlier build raised."""
+    return Dismiss(OLD_FIXED_CARD_ID)
+
+
+def row_no_prices(since=None, now=None) -> str:
+    """PRICE-01: the status row while no price covers now."""
+    if since is not None:
+        return f"No prices since {since_text(since, now)}, maintenance waits."
+    return "No prices yet, maintenance waits."
+
+
 def row_maint_waits(until_text: str) -> str:
     """MAINT-13: the status row while a failed cycle waits."""
     return f"Waits until {until_text} after a cycle that did not finish."
@@ -711,6 +788,25 @@ def row_no_peak_forecast() -> str:
             "the peak limit")
 
 
+def peak_forecast_unit(unit, lang="en") -> str:
+    """SAFETY-118. The 15-minute demand forecast has a number but no power
+    unit, so it is not used. `unit` is "" for none. One sentence, for the log
+    line, the status row and the settings page. Log lines stay English."""
+    if lang == "nl":
+        return ("De kwartierprognose heeft geen eenheid, dus ze wordt niet "
+                "gebruikt." if not unit else
+                "De kwartierprognose heeft geen vermogenseenheid, dus ze "
+                "wordt niet gebruikt.")
+    return ("The 15-minute demand forecast has no unit, so it is not used."
+            if not unit else
+            "The 15-minute demand forecast is not in a power unit, so it is "
+            "not used.")
+
+
+def row_peak_forecast_unit(unit) -> str:
+    return peak_forecast_unit(unit)
+
+
 def row_peak_guard_waiting() -> str:
     return "Peak guard: no decision yet, control has not run"
 
@@ -1022,6 +1118,21 @@ def pack_refused(why: str) -> str:
     return PACK_REFUSED[why]
 
 
+# MAINT-11: why a start or stop of ONE battery's cycle was refused. `{unit}` is
+# the battery the sentence is about (for "busy", the one that is cycling). The
+# page shows the same sentences in Dutch from app/ui_text, keyed by the code.
+MAINT_REFUSED = {
+    "unit": "There is no battery with that name.",
+    "busy": "Only one battery can cycle at a time, and {unit} is cycling now.",
+    "off": "{unit} is switched off, so it cannot start a cycle.",
+    "idle": "{unit} is not running a cycle.",
+}
+
+
+def maint_refused(why: str, unit: str = "") -> str:
+    return MAINT_REFUSED[why].format(unit=unit)
+
+
 def hint(key: str, **kw) -> str:
     """The plain words for one event. `w` is formatted as watts, `sw` as
     watts with their sign (positive gives power, negative charges)."""
@@ -1043,6 +1154,11 @@ def hint_samples() -> list:
 RED, AMBER, GREEN = "bad", "warn", "ok"
 
 
+# PRICE-01 samples: a gap that began today, and one that began the day before.
+_SINCE_SAMPLE = (datetime(2026, 10, 14, 0, 0), datetime(2026, 10, 14, 9, 0))
+_SINCE_OLDER = (datetime(2026, 10, 13, 21, 0), datetime(2026, 10, 14, 9, 0))
+
+
 def status_samples() -> list:
     """`(function name, colour, text)` for every row and banner, for the test.
 
@@ -1132,6 +1248,8 @@ def status_samples() -> list:
         ("row_no_estop", AMBER, row_no_estop()),
         ("row_estop_fitted", GREEN, row_estop_fitted()),
         ("row_no_peak_forecast", AMBER, row_no_peak_forecast()),
+        ("row_peak_forecast_unit", AMBER, row_peak_forecast_unit("")),
+        ("row_peak_forecast_unit", AMBER, row_peak_forecast_unit("kWh")),
         ("row_peak_guard_waiting", AMBER, row_peak_guard_waiting()),
         ("row_pv", GREEN, row_pv(3200, 2)),
         ("row_pv", GREEN, row_pv(1800, 1, True)),
@@ -1171,6 +1289,9 @@ def status_samples() -> list:
                                                            True)),
         ("row_circulating_check", GREEN, row_circulating_check(0, 0, 60)),
         ("row_maint_waits", AMBER, row_maint_waits("2026-10-13")),
+        ("row_no_prices", AMBER, row_no_prices(*_SINCE_SAMPLE)),
+        ("row_no_prices", AMBER, row_no_prices(*_SINCE_OLDER)),
+        ("row_no_prices", AMBER, row_no_prices()),
     ]
 
 
@@ -1203,6 +1324,9 @@ def samples() -> list:
         meter_frozen(90),
         maint_failed("charge", 7),
         maint_failed("drain", 7, "inverter-b", "inverter_b"),
+        no_prices(*_SINCE_SAMPLE),
+        no_prices(*_SINCE_OLDER),
+        no_prices(),
     ]
 
 
@@ -1235,6 +1359,7 @@ LABELS = {
     "price_formula": "Your own tariff formula",
     "price_export_formula": "Your own injection formula",
     "price_csv_path": "Price CSV file",
+    "price_service_token": "Price service token",
     "price_now_entity": "Current price entity",
     "price_avg_entity": "Average price entity",
     "arbitrage_enabled": "Trade on the price spread",

goodwe_controller/app/modetrade.py

@@ -47,12 +47,17 @@ Rules that keep this safe (tests: test_modes_p3.py, test_price_run_fixes.py):
     is its SAFETY-73 probe inside a cheap run (OPT-15): it is a charger then,
     pinned at PROBE_W by its own claim, so the others rest (one sign) and the
     card's "tries again every 15 minutes" holds in the run too;
+  * OPT-20: a probe asks PROBE_W for the probing battery and nothing more.
+    The rest of the ask is what the other chargers would have had without
+    the probe (none: PROBE_W alone), so a probe never places charge on a
+    battery in a maintenance phase or on one that rests;
   * no grid charge while another battery drains for its monthly cycle
     (`draining`, SAFETY-78): it would charge against the drain.
 """
 
 from dataclasses import dataclass
 
+from .control import PROBE_W
 from .packmode import (CHEAP_HOURS, GRID_CHARGE_MODES, LEFTOVER_SOLAR,
                        PLAN_CHARGE_MODES, SOLAR_FIRST)
 
@@ -88,6 +93,7 @@ class Tick:
     action: str | None          # "charge" | "sell" | None
     ask_w: float                # signed site ask before sizing (0 if none)
     why: str | None             # why no trade when a run is on, else None
+    probe_w: float = 0.0        # OPT-20: the part of `ask_w` that is a probe
 
 
 def _room_kwh(p: Pack, pct: float) -> float:
@@ -232,8 +238,12 @@ def decide(runs, now, packs, *, charge_ok, sell_ok, trade_why, price_now,
             ranges[p.name] = (lo, hi)
 
     if charging:
-        ask = -sum(abs(p.rating_w) for p in ch)
-        return Tick(ranges, roles, CHARGE, ask, None)
+        # OPT-20: a probing refuser is asked PROBE_W (its own pin holds it
+        # there); only the batteries that charge without a probe are asked
+        # for their rating.
+        probe_w = PROBE_W * sum(1 for p in ch if p.refused < 0)
+        ask = -sum(abs(p.rating_w) for p in ch if p.refused >= 0) - probe_w
+        return Tick(ranges, roles, CHARGE, ask, None, probe_w)
     if selling:
         ask = sum(abs(p.rating_w) for p in se) + max(0.0, float(house_w))
         return Tick(ranges, roles, SELL, ask, None)
@@ -250,8 +260,20 @@ def size(tick: Tick, bound, headroom_w) -> float:
         return 0.0
     lo, hi = bound
     if tick.action == CHARGE:
-        cap = min(-float(tick.ask_w), -float(lo),
-                  float(headroom_w) if headroom_w is not None else 0.0)
+        room = float(headroom_w) if headroom_w is not None else 0.0
+        pw = float(tick.probe_w)
+        if pw > 0.0:
+            # OPT-20: the others' share is sized as without the probe; the
+            # probe's PROBE_W is added on top (the grid rises by PROBE_W at
+            # most), and alone it is sized by the bound and the headroom.
+            rest = max(0.0, min(-float(tick.ask_w) - pw, -float(lo) - pw,
+                                room))
+            if rest > 0.0:
+                return -(rest + pw)
+            # PROBE_W exactly or no trade: less would void the pin and hand
+            # the remainder to whichever battery the allocator can reach.
+            return -pw if min(-float(lo), room) >= pw else 0.0
+        cap = min(-float(tick.ask_w), -float(lo), room)
         return -max(0.0, cap)
     return max(0.0, min(float(tick.ask_w), float(hi)))
 

goodwe_controller/app/mqtt.py

@@ -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",
 }
 

goodwe_controller/app/price.py

@@ -750,6 +750,18 @@ class _Series(PriceRead):
         except Absence:
             return False
 
+    def last_end_before(self, instant: datetime):
+        """When the last price that has run out by `instant` stopped covering,
+        or None if no price has (PRICE-01: "no prices since 00:00").
+
+        Each point's end is the one `_cover_table()` worked out, so a hole in
+        the series is reported from where the hole starts and not from the end
+        of the day.
+        """
+        u = instant.astimezone(timezone.utc)
+        ends = [end for _start, end, _p in self._cover if end <= u]
+        return max(ends) if ends else None
+
     def window(self, since: datetime, until: datetime) -> tuple:
         """Points whose START falls in [since, until). May legitimately be empty.
 
@@ -906,6 +918,10 @@ PRICE_OPTION_DEFAULTS = {
     "export_price_eur_kwh": 0.04,      # §14 tariffs.export_price_eur_kwh (AC4)
     "price_csv_path": "/share/goodwe_prices.csv",
     "price_feed_url": "",
+    # PRICE-01. The bearer token of the owner's price server. A secret: it is
+    # in SECRET_OPTIONS below, so no text built from an error reaches a log,
+    # the status page or a notification with it in.
+    "price_service_token": "",
     "price_horizon_h": 48,
     "price_timeout_s": 10,
     # TARIFF-03. §14 `tariffs.static_profile: null`. A JSON object describing a
@@ -992,6 +1008,26 @@ FRAMEWORK_KEYS = frozenset({
 })
 
 
+# PRICE-01. Options whose VALUE must never be printed. `scrub()` removes them
+# from any text the price code builds out of an error.
+SECRET_OPTIONS = frozenset({"price_service_token"})
+
+
+def scrub(text, opts) -> str:
+    """`text` with every secret option's value replaced by `***`.
+
+    The price code builds reasons out of library errors, and a library may put
+    a request header into its error text. Taking the value out here is the
+    last line of defence; the plugin also never puts it in a message itself.
+    """
+    out = str(text)
+    for key in SECRET_OPTIONS:
+        secret = str((opts or {}).get(key) or "").strip()
+        if len(secret) >= 4:
+            out = out.replace(secret, "***")
+    return out
+
+
 class PluginOptions:
     """The options dict, minus the keys only the framework may read.
 
@@ -1216,6 +1252,13 @@ class PriceProvider(ABC):
 
     id = "?"
 
+    # PRICE-01. The ids to try, in order, when this source cannot answer, and
+    # whether the last answer is kept for a day without any source. Empty and
+    # False for every plugin that existed before, which is what keeps them
+    # exactly as they were: `price_chain.py` is not used for them at all.
+    FALLBACKS: tuple = ()
+    KEEPS_LAST_GOOD: bool = False
+
     @classmethod
     @abstractmethod
     def capabilities(cls) -> ProviderCapabilities:
@@ -1533,19 +1576,58 @@ def assemble(caps: ProviderCapabilities, raw, markup: float,
 # Transport - one place, HTTPS only, host checked against the declaration
 # --------------------------------------------------------------------------- #
 
-async def https_get(url: str, timeout_s: float) -> bytes:
+async def https_get(url: str, timeout_s: float, headers=None) -> bytes:
     """The default transport. §16: outbound is allow-listed and TLS'd.
 
     Imported lazily so `manual_csv` - the offline fallback - never needs aiohttp
     to be importable at all. AC3 says it works fully offline; that includes a
     machine where the HTTP stack is missing.
+
+    PRICE-01. `headers` is None for every plugin but `price_service`, and with
+    None this is the code it has always been, byte for byte. With headers it
+    answers in the SAFE words of `status_words()` and never lets a library
+    error through: an error from a request that carried a token is the one
+    place a token could be printed by somebody else's code.
     """
     import aiohttp
     t = aiohttp.ClientTimeout(total=float(timeout_s))
-    async with aiohttp.ClientSession(timeout=t) as s:
-        async with s.get(url) as r:
-            r.raise_for_status()
-            return await r.read()
+    if headers is None:
+        async with aiohttp.ClientSession(timeout=t) as s:
+            async with s.get(url) as r:
+                r.raise_for_status()
+                return await r.read()
+    try:
+        async with aiohttp.ClientSession(timeout=t) as s:
+            # No redirects: the host is fixed in code, and a redirect would
+            # take the request (and the token) somewhere the allow-list never
+            # saw. A 3xx is reported like any other status.
+            async with s.get(url, headers=headers,
+                             allow_redirects=False) as r:
+                if r.status != 200:
+                    raise SourceUnavailable(status_words(r.status))
+                return await r.read()
+    except SourceUnavailable:
+        raise
+    except Exception as e:                                    # noqa: BLE001
+        raise SourceUnavailable(
+            f"the price service did not answer ({type(e).__name__})")
+
+
+# PRICE-01. The one phrase a refused token is reported with. The fallback chain
+# reads it to tell "the owner must act" from "the server is down", so it is a
+# constant both sides import.
+AUTH_REFUSED = "the price service refused the token"
+
+
+def status_words(status: int) -> str:
+    """What an HTTP status from the price service is called. No header text."""
+    if status in (401, 403):
+        return f"{AUTH_REFUSED} ({status})"
+    if status == 429:
+        return "the price service says too many requests (429)"
+    if status >= 500:
+        return f"the price service has an error ({status})"
+    return f"the price service answered {status}"
 
 
 def check_egress(url: str, caps: ProviderCapabilities) -> str:
@@ -1870,6 +1952,91 @@ class GenericDayAhead(PriceProvider):
                                           provisional_default=False)
 
 
+@register
+class PriceService(PriceProvider):
+    """The owner's own price server (PRICE-01), COLUMNAR, in EUR/MWh.
+
+    SOURCES: energy
+    The framework ADDS: markup, taxes
+
+    The server answers the energy-charts layout (`unix_seconds`, `price`,
+    `unit`) plus `covers`, the complete Brussels days it holds. The price is
+    the wholesale energy price and nothing else, so markup and taxes are added
+    by the framework exactly as for `generic_dayahead`.
+
+    The host is fixed here, HTTPS only, and a bearer token (the option
+    `price_service_token`) goes in the `Authorization` header. The token is not
+    put into any message this class builds.
+
+    `FALLBACKS` names the next source down. `app/price_chain.py` walks it and
+    then the stored prices; this class only fetches.
+    """
+
+    id = "price_service"
+
+    HOST = "prices.kammenstraatha.duckdns.org"
+    URL = "https://prices.kammenstraatha.duckdns.org/v1/dayahead/BE"
+    FALLBACKS = ("generic_dayahead",)
+    KEEPS_LAST_GOOD = True
+
+    @classmethod
+    def capabilities(cls):
+        return ProviderCapabilities(
+            product=PriceProduct.DAY_AHEAD,
+            sources=frozenset({Component.ENERGY}),
+            egress_hosts=(cls.HOST,))
+
+    async def fetch(self, opts, since, until, transport):
+        token = str(opts.get("price_service_token") or "").strip()
+        if not token:
+            raise SourceUnavailable("no token is set for the price service")
+        if any(c.isspace() or not c.isprintable() for c in token):
+            raise SourceUnavailable(
+                "the price service token has a space or a line break in it")
+        check_egress(self.URL, self.capabilities())
+        try:
+            body = await transport(
+                self.URL, float(opts.get("price_timeout_s")),
+                headers={"Authorization": "Bearer " + token})
+        except SourceUnavailable:
+            raise
+        except Exception as e:                                # noqa: BLE001
+            raise SourceUnavailable(
+                f"the price service did not answer ({type(e).__name__})")
+        points = _points_from_columnar_json(body, expect_unit="EUR / MWh",
+                                            scale=0.001,
+                                            provisional_default=False)
+        covers = _covered_days(body)
+        if covers is None:
+            return points
+        whole = [p for p in points
+                 if brussels(p.start).date().isoformat() in covers]
+        if not whole:
+            raise SourceUnavailable(
+                "the price service sent no complete day")
+        return whole
+
+
+def _covered_days(body):
+    """The `covers` list of a price service answer as a set, or None if absent.
+
+    A day the server does not list as complete is not used: an hour missing
+    inside a day is a hole, and a hole is not a free hour.
+    """
+    try:
+        text = body.decode("utf-8") if isinstance(body, (bytes, bytearray)) \
+            else str(body)
+        covers = json.loads(text).get("covers")
+    except (ValueError, UnicodeDecodeError, AttributeError):
+        return None
+    if covers is None:
+        return None
+    if not isinstance(covers, list) or \
+            not all(isinstance(d, str) for d in covers):
+        raise SourceUnavailable("the price service sent a bad list of days")
+    return set(covers)
+
+
 @register
 class ManualCsv(PriceProvider):
     """A file on disk. AC3: the documented fallback, fully offline.
@@ -2169,9 +2336,10 @@ async def load_prices(opts: dict, since: datetime, until: datetime,
     except FrameworkOption:
         raise                       # a plugin bug, not a site condition
     except SourceUnavailable as e:
-        return PriceRead.no_data(f"{pid}: {e}")
+        return PriceRead.no_data(scrub(f"{pid}: {e}", opts))
     except Exception as e:          # noqa: BLE001 - see the docstring
-        return PriceRead.no_data(f"{pid}: {type(e).__name__}: {e}")
+        return PriceRead.no_data(
+            scrub(f"{pid}: {type(e).__name__}: {e}", opts))
 
     _emit_startup_preview(plugin, pid, points)
     return PriceRead.series(points, caps.product, pid,

goodwe_controller/app/price_chain.py

@@ -0,0 +1,228 @@
+"""PRICE-01 - where the prices come from when the first source does not answer.
+
+A provider that names `FALLBACKS` (app/price.py) is read through this module
+instead of straight from `load_prices()`. The order is fixed:
+
+    1. the provider itself (the owner's price server)
+    2. each id in its `FALLBACKS` (energy-charts.info)
+    3. the prices the history store kept from the last fetch that worked
+
+A step counts only if its answer holds a price for NOW. A server that answers
+200 with yesterday's prices is as useless to a battery as one that is down, so
+it is skipped, with the same log line.
+
+Every other provider never comes here (`uses_chain()` is False for it), so
+`generic_dayahead`, `manual_csv`, `custom_formula` and `off` take the road they
+always took.
+
+THE GATE. `gate_for()` is the maintenance charge rule for a site on such a
+provider: the current 15-minute price is at or below today's average. It is the
+rule the Home Assistant pair (`price_now_entity`, `price_avg_entity`) gave, read
+from the provider's own prices, so moving a site from the pair to the provider
+does not change WHEN the charge runs. DECISIONS/PRICE-01-own-price-server.md
+says how equal, and where it is not.
+"""
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+
+from .price import (AUTH_REFUSED, PROVIDERS, PriceRead, brussels,
+                    price_option, provider_id, scrub)
+
+_LOG = logging.getLogger("goodwe.price.chain")
+
+# The four places a plan can come from, best first. A higher number is further
+# down the chain.
+STEP_OWN, STEP_PUBLIC, STEP_STORED, STEP_NONE = 0, 1, 2, 3
+
+# What a step is called in a status line.
+SOURCE_WORDS = {
+    "price_service": "the price service",
+    "generic_dayahead": "energy-charts",
+    "price_history": "saved prices",
+}
+
+
+def uses_chain(opts: dict) -> bool:
+    """Does the selected provider ask for the fallback chain?"""
+    cls = PROVIDERS.get(provider_id(opts))
+    return bool(cls is not None and (cls.FALLBACKS or cls.KEEPS_LAST_GOOD))
+
+
+def fixed_tariff_beside_service(opts: dict) -> bool:
+    """PRICE-01: a fixed tariff is set beside `price_service`. Not a fault: it
+    stays the plan's last fallback (`resolve_tariff`), and only the cheap window
+    and the gate ignore it. A blank or whitespace-only value is not set."""
+    return (provider_id(opts) == "price_service"
+            and bool(str(price_option(opts, "static_profile")).strip()))
+
+
+@dataclass(frozen=True)
+class Resolved:
+    """What the chain found. `published` is the series BEFORE the yesterday
+    fill and the window, which is what the day's average has to be read from:
+    the plan itself starts at the current hour."""
+
+    read: PriceRead
+    step: int
+    reasons: tuple = ()
+
+    @property
+    def published(self):
+        return self.read.match(series=lambda r: r, no_data=lambda _r: None)
+
+
+class PriceWatch:
+    """Which step the prices come from, and one log line per change of it.
+
+    The line is written when the step CHANGES and not before. Nothing repeats
+    while a source stays down, and nothing is written for a refresh that
+    changes nothing. The reasons (a status code, a timeout) go on a DEBUG line
+    beside it, with the token taken out.
+    """
+
+    def __init__(self):
+        self.step = None
+        self.auth_refused = False
+
+    def note(self, step: int, reasons=(), opts=None) -> None:
+        old, self.step = self.step, step
+        self.auth_refused = any(AUTH_REFUSED in r for r in reasons)
+        if old == step:
+            return
+        if reasons:
+            _LOG.debug("Price sources said: %s.",
+                       scrub("; ".join(reasons), opts))
+        if step == STEP_OWN:
+            if old is None:
+                _LOG.info("Prices come from the price service.")
+            else:
+                _LOG.info("The price service answers again.")
+        elif step == STEP_PUBLIC:
+            if old is not None and old > step:
+                _LOG.info("Prices come from energy-charts again.")
+            elif self.auth_refused:
+                _LOG.warning("The price service refused the token, so prices "
+                             "come from energy-charts.")
+            else:
+                _LOG.warning("The price service does not answer, so prices "
+                             "come from energy-charts.")
+        elif step == STEP_STORED:
+            if old is not None and old > step:
+                _LOG.info("The add-on uses the prices it saved again.")
+            else:
+                _LOG.warning("No price source answers, so the add-on uses "
+                             "the prices it saved.")
+        else:
+            _LOG.warning("No price source answers, and no saved price covers "
+                         "now.")
+
+
+async def resolve(opts: dict, since: datetime, until: datetime, transport,
+                  history, stamp: datetime, watch: PriceWatch,
+                  load) -> Resolved:
+    """Walk the chain and return the first step that has a price for `stamp`.
+
+    `load` is the caller's `load_prices`, passed in so that `static_tariff.py`
+    stays the one module that fetches prices. Never raises
+    for a source condition: a read that gets nowhere is a `no_data` whose
+    reason names every step, so the §11.4 row applies exactly as for a single
+    provider that failed.
+    """
+    pid = provider_id(opts)
+    cls = PROVIDERS[pid]
+    reasons = []
+    for step, sid in enumerate((pid,) + tuple(cls.FALLBACKS)):
+        # A fallback is asked for ITS OWN feed. The operator's feed override is
+        # for the first provider and would send energy-charts' request to a
+        # URL it was never meant for.
+        o = opts if step == 0 else dict(opts, price_provider=sid,
+                                        price_feed_url="")
+        read = await load(o, since, until, transport)
+        if read.match(series=lambda r: r.covers(stamp), no_data=lambda _r: False):
+            # One fallback is shipped. Any further one would also be "public".
+            where = STEP_OWN if step == 0 else STEP_PUBLIC
+            watch.note(where, reasons, opts)
+            return Resolved(read, where, tuple(reasons))
+        reasons.append(read.match(
+            series=lambda r: f"{sid}: it has no price for now",
+            no_data=lambda r: r.reason))
+    if cls.KEEPS_LAST_GOOD:
+        kept = history.stored(stamp)
+        if kept.match(series=lambda r: r.covers(stamp),
+                      no_data=lambda _r: False):
+            watch.note(STEP_STORED, reasons, opts)
+            return Resolved(kept, STEP_STORED, tuple(reasons))
+        reasons.append(kept.match(
+            series=lambda r: "price_history: it has no price for now",
+            no_data=lambda r: r.reason))
+    watch.note(STEP_NONE, reasons, opts)
+    # The reason is short on purpose: it is printed on the status page and in
+    # a WARNING every refresh. What each step said is on the DEBUG line.
+    return Resolved(PriceRead.no_data(
+        "no price source has a price for now"), STEP_NONE,
+        tuple(scrub(r, opts) for r in reasons))
+
+
+# --------------------------------------------------------------------------- #
+# The maintenance charge gate, read from the provider's prices
+# --------------------------------------------------------------------------- #
+
+@dataclass(frozen=True)
+class Gate:
+    """What the 30 s tick takes from the standing plan.
+
+    `covered` is whether a published price covers now. When it is False,
+    `cheap` is False and the charge waits: no price is not a cheap price.
+    `since` is when the cover ended, for the status line, or None when nothing
+    was ever published.
+    """
+
+    cheap: bool
+    covered: bool
+    since: datetime | None
+    words: str
+
+
+NO_PLAN = Gate(False, False, None, "No prices yet")
+
+
+def _round5(value: float) -> float:
+    # The Home Assistant template rounded the average to 5 decimals, and a
+    # price to 5 as well. Both sides are compared as it did, so a quarter that
+    # sits within 0.00001 EUR/kWh of the average gets the same answer.
+    return round(float(value), 5)
+
+
+def gate_for(published, now: datetime) -> Gate:
+    """The charge gate for `now`, from the series the chain published.
+
+    THE RULE (owner's decision, PRICE-01): the current 15-minute price is at or
+    below the average of today's prices, today being the Brussels day. This is
+    what `now_p <= avg_p` was on the Home Assistant pair. It is NOT
+    `TariffPlan.cheap_now()`, which is strictly below the mean of the firm
+    hours of the whole plan, and it is not meant to be.
+
+    `published` is a series or None. With no price for now there is no gate
+    answer: the charge waits.
+    """
+    if published is None:
+        return NO_PLAN
+    if not published.covers(now):
+        return Gate(False, False, published.last_end_before(now),
+                    "No price for now")
+    today = brussels(now).date()
+    todays = [p.eur_per_kwh for p in published.points
+              if not p.provisional and brussels(p.start).date() == today]
+    here = published.at(now)
+    if here.provisional or not todays:
+        return Gate(False, False, published.last_end_before(now),
+                    "No price for now")
+    avg = sum(todays) / len(todays)
+    cheap = _round5(here.eur_per_kwh) <= _round5(avg)
+    source = SOURCE_WORDS.get(published.provider, published.provider)
+    return Gate(cheap, True, None,
+                f"Prices from {source}, {here.eur_per_kwh:.4f} EUR/kWh now, "
+                f"{'cheap' if cheap else 'not cheap'} against today's average "
+                f"of {avg:.4f}")

goodwe_controller/app/price_history.py

@@ -581,7 +581,7 @@ class PriceHistory:
 
     # -- the one public entry point -----------------------------------------
     def carry(self, read: PriceRead, *, since: datetime, until: datetime,
-              stamp: datetime) -> PriceRead:
+              stamp: datetime, remember: bool = True) -> PriceRead:
         """Remember what this read published, then §8.3-fill the missing hours.
 
         THE ORDER IS DELIBERATE AND IS THE POINT OF THE METHOD. The read is
@@ -599,7 +599,11 @@ class PriceHistory:
         source can price is left out (§11.4 for that hour), and `no_data` comes
         back when that is every hour.
         """
-        self._remember(read, stamp)
+        if remember:
+            # PRICE-01: False only for a read that CAME FROM this store
+            # (`stored()`), which is already filed; filing it again would
+            # rewrite the same file for nothing, and nothing else may pass it.
+            self._remember(read, stamp)
         return fill_from_yesterday(read, yesterday=self.yesterday(stamp),
                                    since=since, until=until, stamp=stamp)
 
@@ -798,6 +802,37 @@ class PriceHistory:
                                 str(rec.get("provider") or "price_history"),
                                 stamp)
 
+    def stored(self, stamp: datetime) -> PriceRead:
+        """PRICE-01: every price this store holds, as one series, or no_data.
+
+        This is the LAST step of the price server's fallback (price_chain.py):
+        the answer of the last fetch that worked, kept on disk, so a site can
+        plan for as long as the days it holds last. It is a read of what was
+        PUBLISHED and filed, in the order they happened, and it is never the
+        carried fill (rule 1 holds: `carry(..., remember=False)` is how this
+        read is filled, and it is not filed again).
+
+        The prices are the all-in ones stored when they were fetched. They are
+        not worked out again, so a change of markup or taxes shows from the
+        next fetch that works, not in these.
+        """
+        if stamp.tzinfo is None or stamp.utcoffset() is None:
+            raise ValueError(f"stored({stamp!r}): a naive datetime is not an "
+                             f"instant")
+        points = []
+        for day in sorted(self._days):
+            rec = self._days[day]
+            got, _bad = _parse_points(rec.get("points") if isinstance(
+                rec, dict) else None)
+            points.extend(got)
+        if not points:
+            why = self.last_error or "it holds no prices"
+            return PriceRead.no_data(
+                f"the price history at {self.path} gives nothing: {why}")
+        points.sort(key=lambda p: p.start.astimezone(timezone.utc))
+        return PriceRead.series(points, PriceProduct.DAY_AHEAD,
+                                "price_history", stamp)
+
     # -- observability -------------------------------------------------------
     @property
     def words(self) -> str:
@@ -873,9 +908,14 @@ class NoHistory:
     last_error = "no history is kept by this caller"
     words = "not kept"
 
-    def carry(self, read: PriceRead, *, since, until, stamp) -> PriceRead:
+    def carry(self, read: PriceRead, *, since, until, stamp,
+              remember: bool = True) -> PriceRead:
         return read
 
+    def stored(self, stamp: datetime) -> PriceRead:
+        return PriceRead.no_data("this caller keeps no price history, so "
+                                 "there are no stored prices")
+
     def yesterday(self, stamp: datetime) -> PriceRead:
         return PriceRead.no_data(
             "this caller keeps no price history, so there are no prices from "

goodwe_controller/app/pv.py

@@ -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:

goodwe_controller/app/static/app.css

@@ -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}

goodwe_controller/app/static/app.js

@@ -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 + "."]);
@@ -336,6 +337,39 @@
     finally { packBusy = false; }
     await refresh(true);
   }
+  // MAINT-11: start or stop ONE battery's cycle. Two or more batteries only;
+  // the add-on refuses a second cycle and says which battery is cycling.
+  async function cycleAct(what, b) {
+    if (packBusy) return;
+    packBusy = true;
+    try {
+      const r = await fetch("action", { method: "POST", headers: { "Content-Type": "application/json" },
+                                        body: JSON.stringify({ action: what, unit: b.name }) });
+      const j = await r.json().catch(() => ({}));
+      const own = j.code && t("batteries.cycle." + j.code);
+      if (!r.ok) toast(own ? say(own.description, { name: j.unit || b.name }) : (j.error || t("toast.failed")));
+      else toast(say(t("batteries.cycle.toast." + (what === "maint_start" ? "started" : "stopped")), { name: b.name }));
+    } catch (e) { toast(t("toast.failed")); }
+    finally { packBusy = false; }
+    await refresh(true);
+  }
+  // A button that cannot work is disabled (the add-on still refuses it): Stop
+  // needs this battery cycling; Start needs no battery cycling and this one on.
+  function cycleState(b) {
+    const cycling = (x) => x.maintenance !== "idle";
+    return { start: !S.batteries.some(cycling) && b.use !== false, abort: cycling(b) };
+  }
+  function cycleButtons(b, i) {
+    const can = cycleState(b);
+    const ask1 = (key, what) => () => {
+      const w = t("batteries.cycle." + key);
+      ask({ name: say(w.name, { name: b.name }), description: say(w.description, { name: b.name }), yes: w.yes },
+          () => cycleAct(what, b));
+    };
+    return h("div", { class: "cyc", style: "display:flex;gap:8px;flex-wrap:wrap;margin-top:10px" },
+      h("button", { type: "button", class: "btn", id: "bcs-" + i, disabled: !can.start, onclick: ask1("start_dialog", "maint_start") }, t("batteries.cycle.start")),
+      h("button", { type: "button", class: "btn danger", id: "bca-" + i, disabled: !can.abort, onclick: ask1("abort_dialog", "maint_abort") }, t("batteries.cycle.abort")));
+  }
   function onSwitch(b, i, where, lid) {
     const sw = h("button", { type: "button", class: "switch", role: "switch", id: "bsw-" + where + i,
                              "aria-checked": String(b.use), "aria-labelledby": lid,
@@ -370,7 +404,8 @@
         h("dt", {}, t("batteries.level")), h("dd", {}, lvl + stored),
         h("dt", {}, t("batteries.now")), h("dd", {}, b.now),
         h("dt", {}, t("batteries.today")), h("dd", {}, todayLines(b)),
-        h("dt", {}, t("batteries.why")), h("dd", { class: "muted" }, b.why || "–")));
+        h("dt", {}, t("batteries.why")), h("dd", { class: "muted" }, b.why || "–")),
+      S.batteries.length > 1 ? cycleButtons(b, i) : null);
   }
   function simpleRow(b, i) {
     const lid = "bsname-" + i;

goodwe_controller/app/static/settings.js

@@ -311,7 +311,7 @@
       const days = h("select", { class: "sel", "aria-label": say(P.days) });
       for (const [v, label] of f.days || []) days.append(h("option", { value: v, selected: v === row.days }, label));
       days.addEventListener("change", () => set("days", days.value));
-      const price = h("input", { class: "num", type: "number", inputmode: "decimal", step: "0.01",
+      const price = h("input", { class: "num", type: "number", inputmode: "decimal", step: String(f.step || 0.01),
                                  value: row.price == null ? "" : row.price, "aria-label": say(P.price) });
       price.addEventListener("input", () => set("price", price.value === "" || isNaN(+price.value) ? null : +price.value));
       const cell = (label, ...kids) => h("label", { class: "pf" }, h("span", { class: "tiny muted" }, label), ...kids);

goodwe_controller/app/static_tariff.py

@@ -204,12 +204,13 @@ import math
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 
-from . import messages
+from . import messages, price_chain
 from .price import (
     MAX_PLAUSIBLE_EUR_KWH, Absence, PricePoint, PriceProduct, PriceRead,
     Uncertainty, _Outcome, brussels, load_prices, price_option,
     provider_configured, required_spread, uncertainty_of, widen_factor,
 )
+from .price_chain import uses_chain
 
 _LOG = logging.getLogger("goodwe.tariff.static")
 
@@ -793,6 +794,13 @@ class TariffPlan:
         self.read = read
         self.profile = profile
         self.origin = origin
+        # PRICE-01. The series the price chain found, BEFORE the yesterday fill
+        # cut it to the hours ahead: the maintenance gate needs the whole of
+        # today to know its average. None for every plan that did not come
+        # through the chain, which is every plan of every other provider.
+        self.published = None
+        self.step = None
+        self.reasons = ()
 
     # -- derived facts -------------------------------------------------------
     @property
@@ -1274,7 +1282,8 @@ def static_status(opts: dict, now: datetime):
 
 
 async def resolve_tariff(opts: dict, since: datetime, until: datetime,
-                         transport=None, now=None, *, history) -> TariffPlan:
+                         transport=None, now=None, *, history,
+                         watch=None) -> TariffPlan:
     """The full §9.2 + §11.4 resolution. MAY PERFORM I/O - see `static_plan`.
 
     ⚠️ NOT ON THE 30 s TICK, and that is a deliberate boundary rather than an
@@ -1330,13 +1339,30 @@ async def resolve_tariff(opts: dict, since: datetime, until: datetime,
     if not provider_configured(opts):
         return static_plan(opts, since, until, provisional=False, now=stamp)
 
+    if uses_chain(opts):
+        # PRICE-01. The provider names fallbacks, so its prices come from the
+        # first step of the chain that has one for now. Nothing else does.
+        found = await price_chain.resolve(
+            opts, since, until, transport, history, stamp,
+            watch if watch is not None else price_chain.PriceWatch(),
+            load=load_prices)
+        plan = found.read.match(
+            series=lambda r: _provider_plan(
+                opts, r, since, until, stamp, history,
+                remember=found.step != price_chain.STEP_STORED),
+            no_data=lambda r: _degrade(opts, r, since, until, stamp))
+        plan.published, plan.step = found.published, found.step
+        plan.reasons = found.reasons
+        return plan
+
     read = await load_prices(opts, since, until, transport)
     return read.match(
         series=lambda r: _provider_plan(opts, r, since, until, stamp, history),
         no_data=lambda r: _degrade(opts, r, since, until, stamp))
 
 
-def _provider_plan(opts, read, since, until, stamp, history) -> TariffPlan:
+def _provider_plan(opts, read, since, until, stamp, history, *,
+                   remember=True) -> TariffPlan:
     """§8.3: record what the feed published, carry yesterday into the gaps.
 
     The fill can itself return `no_data` - a feed whose points all fall outside
@@ -1344,7 +1370,12 @@ def _provider_plan(opts, read, since, until, stamp, history) -> TariffPlan:
     §11.4 row arrived at one step later, so it degrades exactly as a failed
     fetch does rather than being special-cased here.
     """
-    filled = history.carry(read, since=since, until=until, stamp=stamp)
+    if remember:
+        filled = history.carry(read, since=since, until=until, stamp=stamp)
+    else:
+        # PRICE-01: a read that came out of the store is not filed again.
+        filled = history.carry(read, since=since, until=until, stamp=stamp,
+                               remember=False)
     return filled.match(
         series=lambda r: TariffPlan(r, _quiet_profile(opts), "provider"),
         no_data=lambda r: _degrade(opts, r, since, until, stamp))

goodwe_controller/app/ui_text/en.json

@@ -23,19 +23,19 @@
     "contract": {"name": "Your contract", "description": "How your supplier prices each kWh you take from the grid."},
     "region": {"name": "Region", "description": "Fills in grid costs, levies and VAT for the year shown, but not yet for Wallonia or Brussels, so check your bill."},
     "fallback": {"name": "Price when the feed is down", "description": "Used when the price source does not answer."},
-    "fixed_price": {"name": "Price per kWh, all in", "description": "Energy, supplier costs, grid costs, levies and VAT together."},
-    "day_price": {"name": "Day price, weekdays 07:00 to 22:00", "description": "All in, as on your bill."},
-    "night_price": {"name": "Night and weekend price", "description": "All in, as on your bill."},
-    "periods": {"name": "Time windows and prices", "description": "One price per kWh for each time window, all in, as on your bill."}
+    "fixed_price": {"name": "Price per kWh, all in", "description": "Energy, supplier costs, grid costs, levies and VAT together: divide c€/kWh from the bill by 100, so 34.512 c€/kWh is 0.34512."},
+    "day_price": {"name": "Day price, weekdays 07:00 to 22:00", "description": "All in, as on your bill: divide c€/kWh by 100, so 34.512 c€/kWh is 0.34512."},
+    "night_price": {"name": "Night and weekend price", "description": "All in, as on your bill: divide c€/kWh by 100, so 34.512 c€/kWh is 0.34512."},
+    "periods": {"name": "Time windows and prices", "description": "One price per kWh for each time window, all in, as on your bill: divide c€/kWh by 100, so 34.512 c€/kWh is 0.34512."}
   },
   "choices": {
-    "contract": {"none": "No prices", "fixed": "Fixed price", "daynight": "Day and night", "dynamic": "Dynamic, hourly", "custom": "Other time windows"},
+    "contract": {"none": "No prices", "fixed": "Fixed price", "daynight": "Day and night", "dynamic": "Dynamic, every 15 minutes", "custom": "Other time windows"},
     "fallback": {"none": "None", "fixed": "One price", "daynight": "Day and night", "custom": "Other time windows"},
     "region": {"flanders": "Flanders, Fluvius Antwerpen", "own": "I enter my own figure"},
     "meter_source": {"off": "One grid power entity", "ha_dsmr": "Import and export entities", "mqtt_p1": "Meter over MQTT", "ha_signed": "One net power entity", "homewizard_local": "HomeWizard meter on the network"},
     "meter_phases": {"1": "1 phase", "3": "3 phases"},
     "shadow_mode": {"auto": "Automatic", "on": "Always on", "off": "Off"},
-    "price_provider": {"generic_dayahead": "Day-ahead market price", "custom_formula": "Your own price formula", "manual_csv": "A price file"},
+    "price_provider": {"generic_dayahead": "Day-ahead market price", "custom_formula": "Your own price formula", "manual_csv": "A price file", "price_service": "Your own price service"},
     "log_level": {"trace": "Everything, for support", "debug": "Detailed, to find a problem", "info": "Normal", "warning": "Warnings and errors", "error": "Errors only"},
     "period_days": {"mon-sun": "Every day", "mon-fri": "Monday to Friday", "sat,sun": "Saturday and Sunday", "mon": "Monday", "tue": "Tuesday", "wed": "Wednesday", "thu": "Thursday", "fri": "Friday", "sat": "Saturday", "sun": "Sunday"}
   },
@@ -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"},
@@ -92,6 +91,7 @@
         "off": {"name": "Off", "description": "Rests, and helps only when the peak limit needs it."}
       },
       "today": "Today", "why": "Why",
+      "cycle": {"start": "Start cycle", "abort": "Stop cycle", "start_dialog": {"name": "Start a cycle on {name}?", "description": "{name} empties, refills and holds full, which takes a few hours.", "yes": "Start the cycle"}, "abort_dialog": {"name": "Stop the cycle on {name}?", "description": "Every inverter is set to 0 W for a moment, then control carries on.", "yes": "Stop the cycle"}, "toast": {"started": "Cycle started on {name}.", "stopped": "Cycle stopped on {name}."}, "unit": {"description": "There is no battery with that name."}, "busy": {"description": "Only one battery can cycle at a time, and {name} is cycling now."}, "off": {"description": "{name} is switched off, so it cannot start a cycle."}, "idle": {"description": "{name} is not running a cycle."}},
       "modes_off": {"name": "Battery modes are off"},
       "how": {"name": "How the modes work", "description": "Which battery gets solar first, and when each gives power.",
         "solar_first": {"description": "Solar first gets spare solar before the other batteries, and covers the house at any hour."},
@@ -409,6 +409,9 @@
       "give_would": "Tomorrow: would give power at {at}, {eur} per kWh."
     },
     "cycle_waits": "{name} waits its turn for the monthly cycle.",
+    "no_prices_yet": "No prices yet, maintenance waits.",
+    "no_prices_since": "No prices since {at}, maintenance waits.",
+    "no_prices_since_day": "No prices since {day} {month} at {at}, maintenance waits.",
     "step_in": "The batteries step in above {kw}.",
     "step_in_would": "The batteries would step in above {kw}.",
     "period": "This 15-minute period is heading for {kw}.",

goodwe_controller/app/ui_text/nl.json

@@ -23,19 +23,19 @@
     "contract": {"name": "Uw contract", "description": "Hoe uw leverancier elke kWh prijst die u van het net afneemt."},
     "region": {"name": "Regio", "description": "Vult nettarieven, heffingen en btw in voor het getoonde jaar, nog niet voor Wallonië of Brussel, dus kijk uw factuur na."},
     "fallback": {"name": "Prijs als de feed wegvalt", "description": "Gebruikt als de prijsbron niet antwoordt."},
-    "fixed_price": {"name": "Prijs per kWh, alles inbegrepen", "description": "Energie, kosten van de leverancier, nettarieven, heffingen en btw samen."},
-    "day_price": {"name": "Dagprijs, weekdagen 07:00 tot 22:00", "description": "Alles inbegrepen, zoals op uw factuur."},
-    "night_price": {"name": "Nacht- en weekendprijs", "description": "Alles inbegrepen, zoals op uw factuur."},
-    "periods": {"name": "Tijdvakken en prijzen", "description": "Eén prijs per kWh voor elk tijdvak, alles inbegrepen, zoals op uw factuur."}
+    "fixed_price": {"name": "Prijs per kWh, alles inbegrepen", "description": "Energie, kosten van de leverancier, nettarieven, heffingen en btw samen: deel c€/kWh van de factuur door 100, dus 34,512 c€/kWh is 0,34512."},
+    "day_price": {"name": "Dagprijs, weekdagen 07:00 tot 22:00", "description": "Alles inbegrepen, zoals op uw factuur: deel c€/kWh door 100, dus 34,512 c€/kWh is 0,34512."},
+    "night_price": {"name": "Nacht- en weekendprijs", "description": "Alles inbegrepen, zoals op uw factuur: deel c€/kWh door 100, dus 34,512 c€/kWh is 0,34512."},
+    "periods": {"name": "Tijdvakken en prijzen", "description": "Eén prijs per kWh voor elk tijdvak, alles inbegrepen, zoals op uw factuur: deel c€/kWh door 100, dus 34,512 c€/kWh is 0,34512."}
   },
   "choices": {
-    "contract": {"none": "Geen prijzen", "fixed": "Vaste prijs", "daynight": "Dag en nacht", "dynamic": "Dynamisch, per uur", "custom": "Andere tijdvakken"},
+    "contract": {"none": "Geen prijzen", "fixed": "Vaste prijs", "daynight": "Dag en nacht", "dynamic": "Dynamisch, per kwartier", "custom": "Andere tijdvakken"},
     "fallback": {"none": "Geen", "fixed": "Eén prijs", "daynight": "Dag en nacht", "custom": "Andere tijdvakken"},
     "region": {"flanders": "Vlaanderen, Fluvius Antwerpen", "own": "Ik vul zelf een bedrag in"},
     "meter_source": {"off": "Eén entiteit voor netvermogen", "ha_dsmr": "Entiteiten voor afname en injectie", "mqtt_p1": "Meter via MQTT", "ha_signed": "Eén entiteit voor nettovermogen", "homewizard_local": "HomeWizard-meter op het netwerk"},
     "meter_phases": {"1": "1 fase", "3": "3 fasen"},
     "shadow_mode": {"auto": "Automatisch", "on": "Altijd aan", "off": "Uit"},
-    "price_provider": {"generic_dayahead": "Day-aheadprijs van de markt", "custom_formula": "Uw eigen prijsformule", "manual_csv": "Een prijsbestand"},
+    "price_provider": {"generic_dayahead": "Day-aheadprijs van de markt", "custom_formula": "Uw eigen prijsformule", "manual_csv": "Een prijsbestand", "price_service": "Uw eigen prijsdienst"},
     "log_level": {"trace": "Alles, voor support", "debug": "Uitgebreid, om een probleem te vinden", "info": "Normaal", "warning": "Waarschuwingen en fouten", "error": "Alleen fouten"},
     "period_days": {"mon-sun": "Elke dag", "mon-fri": "Maandag tot vrijdag", "sat,sun": "Zaterdag en zondag", "mon": "maandag", "tue": "dinsdag", "wed": "woensdag", "thu": "donderdag", "fri": "vrijdag", "sat": "zaterdag", "sun": "zondag"}
   },
@@ -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"},
@@ -89,6 +88,7 @@
         "off": {"name": "Uit", "description": "Rust, en helpt alleen als de piekgrens haar nodig heeft."}
       },
       "today": "Vandaag", "why": "Waarom",
+      "cycle": {"start": "Cyclus starten", "abort": "Cyclus stoppen", "start_dialog": {"name": "Cyclus starten op {name}?", "description": "{name} loopt leeg, laadt weer op en blijft vol, wat enkele uren duurt.", "yes": "Cyclus starten"}, "abort_dialog": {"name": "Cyclus stoppen op {name}?", "description": "Elke omvormer gaat even naar 0 W, daarna gaat de regeling verder.", "yes": "Cyclus stoppen"}, "toast": {"started": "Cyclus gestart op {name}.", "stopped": "Cyclus gestopt op {name}."}, "unit": {"description": "Er is geen batterij met die naam."}, "busy": {"description": "Er kan maar één batterij tegelijk een cyclus doen, en {name} is nu bezig."}, "off": {"description": "{name} staat uit en kan dus geen cyclus starten."}, "idle": {"description": "{name} doet nu geen cyclus."}},
       "modes_off": {"name": "Batterijmodi staan uit"},
       "how": {"name": "Zo werken de modi", "description": "Welke batterij eerst zonne-energie krijgt, en wanneer elke batterij levert.",
         "solar_first": {"description": "Eerst zonne-energie krijgt het overschot vóór de andere batterijen, en dekt het huis op elk uur."},
@@ -344,6 +344,9 @@
     },
     "tomorrow_trade": {"grid": "Morgen: laadt om {at}, {eur} per kWh.", "grid_would": "Morgen: zou laden om {at}, {eur} per kWh.", "give": "Morgen: levert stroom om {at}, {eur} per kWh.", "give_would": "Morgen: zou stroom leveren om {at}, {eur} per kWh."},
     "cycle_waits": "{name} wacht zijn beurt af voor de maandelijkse cyclus.",
+    "no_prices_yet": "Nog geen prijzen, onderhoud wacht.",
+    "no_prices_since": "Geen prijzen sinds {at}, onderhoud wacht.",
+    "no_prices_since_day": "Geen prijzen sinds {day} {month} om {at}, onderhoud wacht.",
     "step_in": "De batterijen springen bij boven {kw}.",
     "step_in_would": "De batterijen zouden bijspringen boven {kw}.",
     "period": "Dit kwartier gaat richting {kw}.",

goodwe_controller/app/uilayout.py

@@ -164,13 +164,13 @@ GROUPS = (
                   wizard=4),
             Field("price_export_formula", TEXT),
             Field("ui.fallback", SEGMENTED, show=_DYNAMIC, wizard=4),
-            Field("ui.fixed_price", NUMBER, "€/kWh", step=0.01,
+            Field("ui.fixed_price", NUMBER, "€/kWh", step=0.00001,
                   show=(("ui.fallback", "==", "fixed"),), wizard=4),
-            Field("ui.day_price", NUMBER, "€/kWh", step=0.01,
+            Field("ui.day_price", NUMBER, "€/kWh", step=0.00001,
                   show=(("ui.fallback", "==", "daynight"),), wizard=4),
-            Field("ui.night_price", NUMBER, "€/kWh", step=0.01,
+            Field("ui.night_price", NUMBER, "€/kWh", step=0.00001,
                   show=(("ui.fallback", "==", "daynight"),), wizard=4),
-            Field("ui.periods", PERIOD_LIST, "€/kWh", step=0.01,
+            Field("ui.periods", PERIOD_LIST, "€/kWh", step=0.00001,
                   show=(("ui.fallback", "==", "custom"),), wizard=4),
         )),
         Part("selling", (
@@ -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", (
@@ -297,7 +297,9 @@ DERIVED = {
     "price_taxes_profile": "ui.region",   # a preset writes it, "own" keeps it
 }
 # Option keys the page never shows and never writes: passed through as stored.
-HIDDEN: dict = {}
+# PRICE-01: the price service token is a secret. It is set in the Configuration
+# tab (a password field there) and this page never draws it.
+HIDDEN: dict = {"price_service_token": "a secret, set on the Configuration tab"}
 
 
 def fields():

goodwe_controller/app/uipage.py

@@ -12,14 +12,17 @@ import copy
 import os
 import re
 
+from . import messages
 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
 
-# A choice the page cannot make, only keep. None since P5's period editor.
-ONLY_IF_HELD = ()
+# 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
+# the Configuration tab and the page only keeps it (PRICE-01).
+ONLY_IF_HELD = ("price_service",)
 _TIERS = ("bad", "warn", "info")
 
 
@@ -245,7 +248,7 @@ def derive_messages(errors, problems, notes, model, keys, lang="en"):
     kept = [p for p in problems if p in kept]
     notes = [n for n in notes if not set(n.keys or ()) & failed]
     return ([derive_message(err, lang) for err in errors]
-            + anchors(kept, notes, model, keys))
+            + anchors(kept, notes, model, keys, lang))
 
 
 # --------------------------------------------------------------------------- #
@@ -290,9 +293,10 @@ def targets(key: str, text: str, model: dict) -> list:
     return [(None, None)]
 
 
-def anchors(problems, notes, model, keys) -> list:
+def anchors(problems, notes, model, keys, lang="en") -> list:
     """[{field, card, tier, text}] for the refusals and notes. `field` is
-    None for a sentence that names no setting on the page."""
+    None for a sentence that names no setting on the page. A note with a Dutch
+    twin in `messages.NOTE_NL` is shown in Dutch when `lang` is "nl"."""
     out, seen = [], set()
 
     def add(field, card, tier, text):
@@ -310,10 +314,11 @@ def anchors(problems, notes, model, keys) -> 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
         for key in note.keys or (None,):
             for field, card in (targets(key, note.text, model) if key
                                 else [(None, None)]):
-                add(field, card, tier, note.text)
+                add(field, card, tier, text)
     # A sentence placed on one inverter's field is not also put on the list.
     roster = _roster()
     placed = {m["text"] for m in out

goodwe_controller/app/validate.py

@@ -1659,6 +1659,12 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                 f"{S('static_profile')} is empty, so the site has no tariff "
                 "at all while the price feed is down.")
 
+    # 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)
+
     # ⚠️ 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
     # fire is indistinguishable from one that fires and finds no opportunity -
@@ -1706,6 +1712,26 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
             f"{S('price_csv_path')} is empty. Set the path to the CSV file, or "
             "choose 'off'.")
 
+    # PRICE-01. The price service answers only to its token. Without one every
+    # fetch is refused and the add-on lives on its fallbacks, which the
+    # operator would not see: a source they chose, overridden by a layer they
+    # cannot see. A token the server cannot read as a header is the same case.
+    if pid == "price_service":
+        token = str(opts.get("price_service_token", "") or "").strip()
+        if not token:
+            problems.append(
+                f"{S('price_provider')} is 'price_service', but "
+                f"{S('price_service_token')} is empty. Set the token, or "
+                "choose another source.")
+        elif any(c.isspace() or not c.isprintable() for c in token):
+            problems.append(
+                f"{S('price_service_token')} has a space or a line break in "
+                "it. Paste the token again, with nothing around it.")
+        elif len(token) < PRICE_TOKEN_MIN:
+            problems.append(
+                f"{S('price_service_token')} is too short. Paste the whole "
+                "token.")
+
     return problems
 
 
@@ -1715,11 +1741,12 @@ def _card_note(option: str, spec) -> str:
 
 
 # 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.
@@ -1762,6 +1789,11 @@ def _entities_read(opts: dict) -> list[tuple[str, str, str]]:
     return out
 
 
+# PRICE-01 F5. A shorter value is not a token; it also could not be scrubbed
+# from a log (price.scrub skips values under 4 characters).
+PRICE_TOKEN_MIN = 16
+
+
 def config_notes(opts: dict, *, entities: dict | None = None,
                  month_peak_w=None) -> list[Note]:
     """UX-13: warnings that need live data, for the settings page. Never a
@@ -1798,6 +1830,10 @@ def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
             _advise(notes, "warn", (key,),
                     f"{entity} reads in {unit}, but {S(key, where)} is "
                     "taken as watts, so pick a 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.")
         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 "

goodwe_controller/app/web.py

@@ -48,18 +48,21 @@ from datetime import datetime, timezone
 
 from aiohttp import web
 
-from . import messages, selfconfig, uipage, uitext
+from . import messages, price, selfconfig, uipage, uitext
 from .haentities import EntityCache
-from .homeview import region_of
+from .homeview import priced_hours, region_of
 from .validate import config_notes, setup_checks
 from .config_page import CONFIG_PAGE
-from .configui import changed_keys, field_model, problems_by_field
+from .configui import (changed_keys, field_model, hide_secrets, keep_secrets,
+                       problems_by_field, secret_keys)
 from .uimodel import DeriveError, options_to_ui
 
 _LOG = logging.getLogger("goodwe.web")
 
 # OPT-11: the per-battery actions, which name a battery and a value.
 PACK_ACTIONS = ("pack_use", "pack_mode", "pack_sell")
+# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
+MAINT_ACTIONS = ("maint_start", "maint_abort")
 
 # UX-13 P1: the page lives in app/static/ as three files - index.html,
 # app.css, app.js - plus the page words from app/ui_text/<lang>.json (English
@@ -163,6 +166,14 @@ def build_app(controller, selfcfg=None) -> web.Application:
                 return web.json_response({"ok": False,
                                           "error": result["error"]},
                                          status=400)
+        elif what in MAINT_ACTIONS and body.get("unit") is not None:
+            # MAINT-11: one battery's cycle. No unit = the old bare call below.
+            result = await controller.handle_action(what, unit=body["unit"])
+            if isinstance(result, dict) and "error" in result:
+                return web.json_response(
+                    {"ok": False, "error": result["error"],
+                     "code": result["code"], "unit": result["unit"]},
+                    status=409 if result["code"] != "unit" else 400)
         else:
             result = await controller.handle_action(what)
         if result is None:
@@ -199,6 +210,11 @@ def build_app(controller, selfcfg=None) -> web.Application:
             raise web.HTTPBadRequest(text="expected an options object")
         return body, options, None
 
+    def _secrets(info):
+        # PRICE-01 F1: every `password` option of the schema, and the price
+        # token by name in case a schema is missing.
+        return secret_keys((info or {}).get("schema"), price.SECRET_OPTIONS)
+
     async def config_model(request):
         """Everything the page needs to draw itself, from ONE Supervisor call.
 
@@ -217,13 +233,14 @@ def build_app(controller, selfcfg=None) -> web.Application:
             _LOG.error("cannot read the add-on's own options: %s", err)
             return web.json_response({"error": str(err)}, status=502)
         options = info.get("options") or {}
+        secrets = _secrets(info)
         lang = str(request.query.get("lang", "en") or "en")[:8]
         model = field_model(info.get("schema") or [],
                             info.get("translations") or {}, lang)
         model.update({
-            "options": options,
+            "options": hide_secrets(options, secrets),
             "fingerprint": hand_out(options),
-            "running": controller.o,
+            "running": hide_secrets(controller.o, secrets),
             "running_differs": changed_keys(controller.o, options),
             "lang": lang,
             # UX-13 P1: the levies preset and its year, for the P2 Settings
@@ -232,7 +249,7 @@ def build_app(controller, selfcfg=None) -> web.Application:
             # UX-13 P2: the Installer view draws from these two.
             "layout": uipage.layout(info.get("schema") or [],
                                     info.get("translations") or {}, lang),
-            "ui": options_to_ui(options),
+            "ui": hide_secrets(options_to_ui(options), secrets),
             # UX-13 P4: the setup wizard, and why it opens by itself.
             "setup": uipage.setup_spec(),
             "setup_needed": uipage.setup_needed(
@@ -271,6 +288,12 @@ def build_app(controller, selfcfg=None) -> web.Application:
             model, options = None, _body.get("options")
             if not isinstance(options, dict):
                 raise web.HTTPBadRequest(text="expected an options object")
+        try:
+            info_now = await selfcfg.info()
+            options = keep_secrets(options, info_now.get("options"),
+                                   _secrets(info_now))
+        except Exception:  # noqa: BLE001 - a check never fails for this
+            pass
         notes = []
         problems, unread = await selfconfig.problems_and_ranges(
             options, controller.hass, notes=notes)
@@ -289,7 +312,8 @@ def build_app(controller, selfcfg=None) -> web.Application:
                                        _keys_of(options),
                                        uitext.lang_of(_body.get("lang")))
                 if errors
-                else uipage.anchors(problems, notes, model, _keys_of(options)))
+                else uipage.anchors(problems, notes, model, _keys_of(options),
+                                    uitext.lang_of(_body.get("lang"))))
             payload["steps"] = uipage.step_problems(payload["messages"], model)
         if _body.get("setup"):
             payload["setup"] = [n._asdict() for n in await _setup_checks(options)]
@@ -304,7 +328,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,
@@ -329,9 +353,12 @@ def build_app(controller, selfcfg=None) -> web.Application:
         except ValueError:
             raise web.HTTPBadRequest(text="expected JSON")
         stored_now = None
-        if isinstance(posted, dict) and isinstance(posted.get("model"), dict):
+        secrets = frozenset(price.SECRET_OPTIONS)
+        if isinstance(posted, dict):
             try:
-                stored_now = (await selfcfg.info()).get("options") or {}
+                info_now = await selfcfg.info()
+                stored_now = info_now.get("options") or {}
+                secrets = _secrets(info_now)
             except selfconfig.SupervisorUnavailable as err:
                 _LOG.error("saving options failed: %s", err)
                 return web.json_response({"error": str(err)}, status=502)
@@ -347,6 +374,8 @@ def build_app(controller, selfcfg=None) -> web.Application:
                  "unanchored": [], "messages": messages_,
                  "steps": uipage.step_problems(messages_, model)},
                 status=422)
+        # PRICE-01 F1: a secret the page did not change is the stored one.
+        options = keep_secrets(options, stored_now, secrets)
         expect = str(body.get("fingerprint") or "")
         try:
             result = await selfconfig.save(selfcfg, options, expect,
@@ -364,7 +393,7 @@ def build_app(controller, selfcfg=None) -> web.Application:
                      "moved": refused.moved,
                      "changed_fields": (uipage.fields_of(moved, model)
                                         if model is not None else []),
-                     "stored": stored,
+                     "stored": hide_secrets(stored, secrets),
                      # The page needs the CURRENT token to be able to save
                      # again after the operator has read the difference. That
                      # is not a force door: it takes a second, deliberate press

goodwe_controller/config.yaml

@@ -1,9 +1,9 @@
 name: GoodWe RS485 Controller
-version: "0.17.0"
+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:
@@ -556,6 +556,10 @@ options:
   # naming that consequence on every fetch that uses an override; clearing this
   # option is what restores the full horizon.
   price_feed_url: ""
+  # PRICE-01. The bearer token for the owner's price server
+  # (`price_provider: price_service`). A password field. Empty with any other
+  # source. Never printed: not in the log, the status page or a notification.
+  price_service_token: ""
   price_horizon_h: 48
   price_timeout_s: 10
 
@@ -1085,7 +1089,7 @@ schema:
   # this line offers exactly PROVIDERS + RETIRED_PROVIDERS + 'off' - derived, not
   # typed - and register() refuses to re-register a retired id, so the two
   # cannot both claim one.
-  price_provider: list(off|generic_dayahead|custom_formula|engie_dynamic|totalenergies_dynamic|eneco_eddy|manual_csv)
+  price_provider: list(off|generic_dayahead|price_service|custom_formula|engie_dynamic|totalenergies_dynamic|eneco_eddy|manual_csv)
   price_markup_eur_kwh: float(0,1)
   price_taxes_eur_kwh: float(0,1)
 
@@ -1119,6 +1123,7 @@ schema:
   price_formula: str?
   price_csv_path: str?
   price_feed_url: str?
+  price_service_token: password?
   price_horizon_h: int(1,72)
   price_timeout_s: int(2,60)
   price_now_entity: str?

goodwe_controller/test_arbitrage.py

@@ -81,6 +81,7 @@ from datetime import datetime, timedelta, timezone
 from app import arbitrage as _arb
 from named_absence import first
 from app import main as _main
+from app.price_chain import PriceWatch
 from app import peakguard as _pg
 from app.arbiter import (
     P_ARBITRAGE, P_LOOP, P_MAINT_SHAPE, P_MAINTENANCE, P_PEAK, P_SAFETY, Claim,
@@ -2311,6 +2312,7 @@ class _T12Controller:
         self.tariff_plan = None
         self.tariff_at = None
         self.price_history = NoHistory()
+        self.price_watch = PriceWatch()      # PRICE-01: the refresh passes it on
         self.stop_event = asyncio.Event()
         self.stop_event.set()          # so the inter-refresh wait returns
         self._ticks = 0

goodwe_controller/test_home.py

@@ -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
@@ -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))
+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")

goodwe_controller/test_maint11.py

@@ -0,0 +1,405 @@
+"""MAINT-11: start or stop the maintenance cycle of ONE battery.
+`python3 test_maint11.py`
+
+Graded here, at two and at three batteries: a start on a chosen battery with the
+slot free (and it is that battery, not the one the bare button would pick); a
+start with the slot held, in each moving phase, refused by name; an unknown
+unit; a battery switched off; a battery that refuses to give power; a stop on a
+battery that is not cycling; a stop on the cycling one; a request with no unit
+doing what it always did; the web layer's codes; the words in both languages;
+and a roster of one, whose requests, log and writes are pinned.
+See DECISIONS/MAINT-11-cycle-per-battery.md.
+
+Mutating what this file grades? Read MUTATION.md first (stale bytecode).
+"""
+
+import asyncio
+import json
+import os
+import re
+import socket
+import sys
+from datetime import datetime, timezone
+
+import aiohttp
+from aiohttp import web as aioweb
+
+from app import messages, packmode, web
+from app.main import Controller
+from app.maintenance import CHARGE, DRAIN, HOLD, IDLE, POWER_MOVING
+from app.store import DEFAULTS
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+class MemStore:
+    def __init__(self):
+        self.data = dict(DEFAULTS)
+
+    def set(self, k, v):
+        self.data[k] = v
+
+    def get_time(self, k):
+        raw = self.data.get(k)
+        if not raw:
+            return None
+        if isinstance(raw, datetime):
+            return raw
+        parsed = datetime.fromisoformat(raw)
+        return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
+
+    def set_time(self, k, when):
+        self.data[k] = when.astimezone(timezone.utc).isoformat() if when else None
+
+    def save(self):
+        pass
+
+
+class Hass:
+    session = None
+    token = ""
+
+    def __init__(self, n):
+        self.numbers = {"sensor.grid": 5000.0}
+        self.limits_by = {}
+        for k in range(n):
+            self.numbers[f"sensor.soc_{k}"] = 80.0
+            self.numbers[f"sensor.batt_{k}"] = 0.0
+            self.limits_by[f"number.sp_{k}"] = (-5000.0, 5000.0, 1.0)
+        self.writes = []
+
+    async def number(self, entity, invert=False):
+        v = self.numbers.get(entity)
+        return None if v is None else (-v if invert else v)
+
+    async def limits(self, entity):
+        return self.limits_by.get(entity, (None, None, None))
+
+    async def set_number(self, entity, value):
+        self.writes.append((entity, value))
+        return True
+
+    async def call(self, domain, service, data):
+        return True
+
+
+class Pub:
+    enabled = False
+
+    def publish(self, *a, **k):
+        pass
+
+    def close(self):
+        pass
+
+
+NAMES = ["inverter-a", "inverter-b", "inverter-c"]
+OPTS = dict(meter_source="off", meter_entity="sensor.grid", gain=0.6,
+            slew_w=6000, deadband_w=15, target_grid_w=0, step_w=10,
+            heartbeat_s=10, stale_input_s=15, maintenance_discharge_w=2000,
+            maintenance_charge_w=2000)
+
+
+def controller(n, modes=False):
+    opts = dict(OPTS)
+    opts["inverters"] = [
+        dict(name=NAMES[k], setpoint_entity=f"number.sp_{k}",
+             soc_entity=f"sensor.soc_{k}", batt_entity=f"sensor.batt_{k}",
+             max_w=5000.0) for k in range(n)]
+    if n == 1:
+        del opts["inverters"]
+        opts.update(setpoint_entity="number.sp_0", soc_entity="sensor.soc_0",
+                    batt_entity="sensor.batt_0", max_w=5000.0)
+    if modes:
+        opts["battery_modes_enabled"] = True
+    hass = Hass(n)
+    c = Controller(opts, hass, MemStore(), Pub(), stop=asyncio.Event())
+    for inv in c.inverters:
+        inv.dev_min, inv.dev_max = -inv.max_w, inv.max_w
+    c.auto = True
+    return c, hass
+
+
+def act(c, what, unit=None):
+    if unit is None:
+        return asyncio.run(c.handle_action(what))
+    return asyncio.run(c.handle_action(what, unit=unit))
+
+
+def phases(c):
+    return [m.phase for m in c.maints]
+
+
+def snapshot(c, hass):
+    return (phases(c), list(c.events), list(hass.writes),
+            json.dumps(c.store.data, sort_keys=True, default=str))
+
+
+def settle(c):
+    """Events carry a clock stamp; compare them without it."""
+    return [e.split(" ", 1)[1] for e in c.events]
+
+
+for N in (2, 3):
+    print(f"\n{N} batteries")
+    names = NAMES[:N]
+    last = N - 1
+
+    # --- start with the slot free -------------------------------------------
+    c, hass = controller(N)
+    bare_pick = c._maint_button(datetime.now(timezone.utc))
+    check("with every battery never cycled the bare button picks the first "
+          "(this is the card's case)", bare_pick is c.maints[0])
+    r = act(c, "maint_start", names[last])
+    check(f"start on {names[last]}: its cycle starts, nobody else's",
+          r == {"unit": names[last], "phase": DRAIN}
+          and phases(c) == [IDLE] * last + [DRAIN])
+    check("...and the log says a forced start",
+          any("forced start" in e for e in c.events))
+    check("...and the machine holding the slot is the named one",
+          c.maint_index == last)
+
+    c, hass = controller(N)
+    r = act(c, "maint_start", names[0])
+    check("start on the first battery works the same way",
+          r["unit"] == names[0] and phases(c)[0] == DRAIN
+          and phases(c)[1:] == [IDLE] * last)
+
+    # --- start with the slot held --------------------------------------------
+    for phase in POWER_MOVING:
+        for holder in range(N):
+            c, hass = controller(N)
+            c.maints[holder].store.set("phase", phase)
+            before = snapshot(c, hass)
+            bad = []
+            for k in range(N):
+                r = act(c, "maint_start", names[k])
+                bad.append(not (r.get("code") == "busy"
+                                and r["unit"] == names[holder]
+                                and names[holder] in r["error"]
+                                and "error" in r))
+            check(f"slot held by {names[holder]} in {phase}: a start on any "
+                  f"battery (itself too) is refused, naming {names[holder]}, "
+                  f"and nothing changes", not any(bad)
+                  and snapshot(c, hass) == before)
+
+    # --- unknown unit --------------------------------------------------------
+    c, hass = controller(N)
+    before = snapshot(c, hass)
+    rs = [act(c, w, u) for w in ("maint_start", "maint_abort")
+          for u in ("inverter-z", "", "Inverter-A", 7, ["inverter-a"])]
+    check("an unknown unit (wrong name, empty, wrong case, not a string) is "
+          "refused for start and for stop, and nothing changes",
+          all(r.get("code") == "unit" and r["error"]
+              == messages.maint_refused("unit") for r in rs)
+          and snapshot(c, hass) == before)
+
+    # --- a battery switched off ---------------------------------------------
+    c, hass = controller(N, modes=True)
+    c.inverters[last].store_set(packmode.USE_KEY, False)
+    before = snapshot(c, hass)
+    r = act(c, "maint_start", names[last])
+    check("a battery switched off (battery modes on) is refused by name and "
+          "nothing changes", r.get("code") == "off" and r["unit"] == names[last]
+          and names[last] in r["error"] and snapshot(c, hass) == before)
+    r = act(c, "maint_start", names[0])
+    check("...while a battery that is on still starts", r.get("phase") == DRAIN
+          and phases(c)[0] == DRAIN)
+    c, hass = controller(N)
+    c.inverters[last].store_set(packmode.USE_KEY, False)
+    check("with battery modes off the stored switch is not consulted (it is "
+          "not shown, so it cannot refuse)",
+          act(c, "maint_start", names[last]).get("phase") == DRAIN)
+
+    # --- a battery that refuses to give power ---------------------------------
+    c, hass = controller(N)
+    c.inverters[last].refused = 1
+    r = act(c, "maint_start", names[last])
+    check("a battery that refuses to give power starts like the bare button "
+          "would start it (its drain then waits, as before)",
+          r == {"unit": names[last], "phase": DRAIN})
+
+    # --- stop ---------------------------------------------------------------
+    c, hass = controller(N)
+    before = snapshot(c, hass)
+    r = act(c, "maint_abort", names[0])
+    check("a stop on a battery that is not cycling is refused and nothing "
+          "changes (no 0 W written either)", r.get("code") == "idle"
+          and names[0] in r["error"] and snapshot(c, hass) == before)
+    c.maints[last].store.set("phase", CHARGE)
+    before = snapshot(c, hass)
+    r = act(c, "maint_abort", names[0])
+    check(f"a stop on {names[0]} while {names[last]} cycles is refused, and "
+          f"{names[last]}'s cycle is not touched", r.get("code") == "idle"
+          and phases(c)[last] == CHARGE and snapshot(c, hass) == before)
+
+    for phase in POWER_MOVING:
+        c, hass = controller(N)
+        c.maints[last].store.set("phase", phase)
+        r = act(c, "maint_abort", names[last])
+        check(f"a stop on the cycling battery ({phase}) ends its cycle, "
+              f"logs the abort and sets every inverter to 0 W",
+              r == {"unit": names[last], "phase": IDLE}
+              and phases(c) == [IDLE] * N
+              and any("ABORT (operator)" in e for e in c.events)
+              and {w for w in hass.writes}
+              == {(f"number.sp_{k}", 0.0) for k in range(N)}
+              and all(i.target == 0.0 for i in c.inverters))
+
+    # --- the old request ---------------------------------------------------
+    c, hass = controller(N)
+    r = act(c, "maint_start")
+    check("a start with no unit is the old call: the bare button's pick, and "
+          "the old answer", r == {"phase": DRAIN} and phases(c)[0] == DRAIN
+          and any("forced start" in e for e in c.events))
+    r = act(c, "maint_start")
+    check("...a second bare start re-enters the drain of the cycling battery, "
+          "as it always did", r == {"phase": DRAIN} and phases(c)[0] == DRAIN)
+    c.maints[last].store.set("phase", IDLE)
+    r = act(c, "maint_abort")
+    check("...and a bare stop stops the cycling battery and answers as before",
+          r == {"phase": IDLE} and phases(c) == [IDLE] * N
+          and any("ABORT (operator)" in e for e in c.events))
+    c, hass = controller(N)
+    r = act(c, "maint_abort")
+    check("...a bare stop with nothing cycling is still accepted, as before",
+          r == {"phase": IDLE} and hass.writes
+          and {w[1] for w in hass.writes} == {0.0})
+
+# --- the web layer ----------------------------------------------------------
+print("\nthe web layer")
+
+
+async def serve(c, calls):
+    runner = aioweb.AppRunner(web.build_app(c, object()))
+    await runner.setup()
+    sock = socket.socket()
+    sock.bind(("127.0.0.1", 0))
+    port = sock.getsockname()[1]
+    sock.close()
+    await aioweb.TCPSite(runner, "127.0.0.1", port).start()
+    out = []
+    try:
+        async with aiohttp.ClientSession() as s:
+            for body in calls:
+                async with s.post(f"http://127.0.0.1:{port}/action",
+                                  json=body) as r:
+                    out.append((r.status, await r.json(content_type=None)))
+    finally:
+        await runner.cleanup()
+    return out
+
+
+c, hass = controller(2)
+rs = asyncio.run(serve(c, [
+    {"action": "maint_start", "unit": "inverter-b"},
+    {"action": "maint_start", "unit": "inverter-a"},
+    {"action": "maint_abort", "unit": "inverter-a"},
+    {"action": "maint_start", "unit": "nope"},
+    {"action": "maint_abort", "unit": "inverter-b"},
+    {"action": "maint_start", "unit": None},
+    {"action": "maint_abort"},
+    {"action": "maint_start", "unit": ""},
+]))
+check("start with a unit: 200 and the unit's answer",
+      rs[0] == (200, {"ok": True, "result": {"unit": "inverter-b",
+                                             "phase": DRAIN}}))
+check("start while the slot is held: 409, a code, the cycling battery, the "
+      "plain sentence", rs[1][0] == 409 and rs[1][1] == {
+          "ok": False, "code": "busy", "unit": "inverter-b",
+          "error": messages.maint_refused("busy", "inverter-b")})
+check("stop on a battery that is not cycling: 409 with the sentence",
+      rs[2][0] == 409 and rs[2][1]["code"] == "idle"
+      and rs[2][1]["error"] == messages.maint_refused("idle", "inverter-a"))
+check("unknown unit: 400 with the sentence", rs[3][0] == 400
+      and rs[3][1]["code"] == "unit"
+      and rs[3][1]["error"] == messages.maint_refused("unit"))
+check("stop on the cycling battery: 200", rs[4] == (
+    200, {"ok": True, "result": {"unit": "inverter-b", "phase": IDLE}}))
+check("a null unit is the bare call: 200 and the old answer",
+      rs[5] == (200, {"ok": True, "result": {"phase": DRAIN}}))
+check("a request with no unit: 200 and the old answer", rs[6] == (
+    200, {"ok": True, "result": {"phase": IDLE}}))
+check("an empty unit is refused (400), not taken as the bare call",
+      rs[7][0] == 400 and rs[7][1]["code"] == "unit"
+      and phases(c) == [IDLE, IDLE])
+
+# --- the words --------------------------------------------------------------
+print("\nthe words")
+words = {}
+for lang in ("en", "nl"):
+    with open(os.path.join(HERE, "app", "ui_text", f"{lang}.json"),
+              encoding="utf-8") as f:
+        words[lang] = json.load(f)["home"]["batteries"]["cycle"]
+for code, sentence in messages.MAINT_REFUSED.items():
+    en = words["en"][code]["description"]
+    check(f"'{code}': the page's English is the API's sentence",
+          en == sentence.replace("{unit}", "{name}"))
+    nl = words["nl"][code]["description"]
+    check(f"'{code}': the Dutch has the same placeholders",
+          sorted(re.findall(r"\{\w+\}", nl))
+          == sorted(re.findall(r"\{\w+\}", en)) and nl != en)
+check("both languages carry the same keys",
+      json.dumps(words["en"], sort_keys=True).count('":')
+      == json.dumps(words["nl"], sort_keys=True).count('":')
+      and set(words["en"]) == set(words["nl"]))
+check("every code the server can answer has a page sentence",
+      set(messages.MAINT_REFUSED) <= set(words["en"]))
+
+# --- the page ----------------------------------------------------------------
+print("\nthe page")
+JS = open(os.path.join(HERE, "app", "static", "app.js"),
+          encoding="utf-8").read()
+check("the buttons are drawn only with two or more batteries",
+      "S.batteries.length > 1 ? cycleButtons(b, i) : null" in JS)
+check("both buttons post the battery's name and ask first",
+      'JSON.stringify({ action: what, unit: b.name }) });' in JS and 'ask1("start_dialog", "maint_start")' in JS
+      and 'ask1("abort_dialog", "maint_abort")' in JS)
+check("a refusal is shown in the page's language, by its code",
+      'const own = j.code && t("batteries.cycle." + j.code);' in JS
+      and 'toast(own ? say(own.description' in JS)
+check("Stop is disabled on a battery that is not cycling",
+      'abort: cycling(b) };' in JS and "disabled: !can.abort" in JS)
+check("Start is disabled while any battery cycles",
+      "start: !S.batteries.some(cycling) && " in JS
+      and "disabled: !can.start" in JS)
+check("Start is disabled on a switched-off battery (use false, modes on)",
+      "&& b.use !== false, abort" in JS)
+check("each button carries its own flag, and only that flag",
+      'id: "bcs-" + i, disabled: !can.start, onclick: ask1("start_dialog"' in JS
+      and 'id: "bca-" + i, disabled: !can.abort, onclick: ask1("abort_dialog"' in JS)
+check("a battery counts as cycling when its phase is not idle",
+      'cycling = (x) => x.maintenance !== "idle"' in JS)
+check("the old header buttons still post a bare request",
+      'ask("maint_start", () => simple("maint_start"))' in JS
+      and "body: JSON.stringify({ action: what }) });" in JS)
+
+# --- a roster of one -----------------------------------------------------------
+print("\none battery: the requests, the log and the wire stay as they were")
+c, hass = controller(1)
+r1 = act(c, "maint_start")
+r2 = act(c, "maint_start")
+r3 = act(c, "maint_abort")
+r4 = act(c, "maint_abort")
+check("answers", [r1, r2, r3, r4] == [{"phase": DRAIN}, {"phase": DRAIN},
+                                      {"phase": IDLE}, {"phase": IDLE}])
+check("log lines (stamp removed), newest first", settle(c) == [
+    "maintenance: ABORT (operator)", "maintenance: ABORT (operator)",
+    "maintenance: forced start -> drain",
+    "maintenance: forced start -> drain"][:len(settle(c))]
+    and len(settle(c)) == 4)
+check("wire: two stops, each 0 W", hass.writes == [("number.sp_0", 0.0)] * 2)
+c, hass = controller(1)
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED")
+    sys.exit(1)
+print("all passed")

goodwe_controller/test_maint13.py

@@ -415,7 +415,11 @@ def put_in_charge(c, which, hours_ago, open_min):
 
 
 def notes(h):
-    return [x for x in h.calls if x[0] == "persistent_notification"]
+    # Not the dismiss of PRICE-01's old fixed-tariff card, which every start sends.
+    # Only that dismiss: a `create` with the old id would still be counted.
+    return [x for x in h.calls if x[0] == "persistent_notification"
+            and not (x[1] == "dismiss"
+                     and x[2].get("notification_id") == "goodwe_fixed_tariff_unused")]
 
 
 for cheap in (True, False):

goodwe_controller/test_mqtt.py

@@ -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")]:

goodwe_controller/test_opt20.py

@@ -0,0 +1,267 @@
+"""Runnable check for OPT-20.  `python3 test_opt20.py`
+
+A refusal probe (OPT-15 F3, SAFETY-73) asks the probing battery PROBE_W and
+nothing else. On TEST-23 (OPT-15 g7) the probe made the trade ask 2500 W: B
+was pinned at 200 W and the allocator put the other 2300 W on A, which sat in
+its maintenance charge phase at 0 W, with the grid at 3100 W for 34 s.
+
+1. modetrade: the ask carries PROBE_W for the probing battery, the other
+   chargers' ratings as without the probe, and `size()` adds the probe on top
+   of their share (or asks PROBE_W exactly, or nothing).
+2. main: the ask carries PROBE_W for exactly the pins filed this tick, so the
+   first and the last cycle of a window do not move another battery's share.
+3. The real Controller in the lagged replay, with B refusing and probed while
+   A is (a) in its maintenance charge phase (also with the charge shaped to
+   0 W), (b) idle, (c) a normal charger in the same run, and the OPT-15 rig's
+   g7 sequence: A's command is the same through the window as just before it,
+   B gets PROBE_W, and the commanded charge rises by PROBE_W at most.
+4. Battery modes on with no probe: byte-identical to release/1.0 bf9019e.
+
+Out of scope, and unchanged: a normal (non-probing) trade placed on a battery
+in maintenance charge (OPT-11 P4 F4) and the action-log wording (UX-38).
+Mutations: MUTATION.md says how to run them (purged copies); the 12 of
+OPT-20 are listed in the pull request.
+"""
+
+import dataclasses
+import logging
+import os
+import sys
+from types import SimpleNamespace
+
+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 opt20_scen as sc                                        # noqa: E402
+from app import arbitrage, modetrade, packmode                 # noqa: E402
+from app import control as ctl                                 # noqa: E402
+from app import main                                           # noqa: E402
+from app.arbiter import Claim, P_SAFETY                        # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+PW = ctl.PROBE_W
+A, B = sc.A, sc.B
+
+# ============================================================================ #
+print("1. modetrade: the ask and the size")
+_runs = SimpleNamespace(on=True, cheap=SimpleNamespace(holds=lambda n: True),
+                        charge_useful=lambda: True, give_at=lambda n: None,
+                        sell=None)
+
+
+def _dec(packs, **kw):
+    args = dict(charge_ok=True, sell_ok=True, trade_why=None, price_now=0.1,
+                headroom_w=3000.0, floor_pct=20.0, ceiling_pct=95.0,
+                house_w=800.0)
+    args.update(kw)
+    return modetrade.decide(_runs, sc.UTC0, packs, **args)
+
+
+_pb = modetrade.Pack(B, True, packmode.CHEAP_HOURS, False, 2500.0, 30.0, 10.0,
+                     refused=-1, probing=True)
+_pa = modetrade.Pack(A, True, packmode.CHEAP_HOURS, False, 2500.0, 50.0, 10.0)
+_pm = dataclasses.replace(_pa, mode=packmode.SOLAR_FIRST, idle=False)
+_pi = dataclasses.replace(_pa, mode=packmode.SOLAR_FIRST)
+
+_t_alone = _dec([_pb, _pm])
+check("a probe beside a battery in maintenance asks PROBE_W and no more",
+      _t_alone.action == modetrade.CHARGE and _t_alone.ask_w == -PW
+      and _t_alone.probe_w == PW)
+check("...beside an idle battery that cannot charge from the grid too",
+      _dec([_pb, _pi]).ask_w == -PW and _dec([_pb, _pi]).probe_w == PW)
+_t_two = _dec([_pb, _pa])
+check("...beside a normal charger the ask is that charger's rating plus "
+      "PROBE_W", _t_two.ask_w == -2500.0 - PW and _t_two.probe_w == PW)
+_t_np = _dec([dataclasses.replace(_pb, probing=False), _pa])
+check("no probe: the ask is the chargers' ratings, probe_w is 0 (as before)",
+      _t_np.ask_w == -2500.0 and _t_np.probe_w == 0.0
+      and _dec([_pa, _pm]).ask_w == -2500.0
+      and modetrade.Tick({}, {}, None, 0.0, None).probe_w == 0.0)
+
+
+def sz(ask, probe_w, lo, room, action=modetrade.CHARGE):
+    t = modetrade.Tick({}, {}, action, ask, None, probe_w)
+    return modetrade.size(t, (lo, 2500.0), room)
+
+
+check("size, a probe alone: PROBE_W, whatever the headroom above it",
+      sz(-PW, PW, -(PW), 3000.0) == -PW and sz(-PW, PW, -2700.0, 9000.0) == -PW)
+check("...exactly PROBE_W or nothing: a headroom or a bound under it files "
+      "no trade (a smaller ask voids the pin and the allocator would place "
+      "it elsewhere)",
+      sz(-PW, PW, -2700.0, PW - 1) == 0.0 and sz(-PW, PW, -(PW - 1), 3000.0)
+      == 0.0 and sz(-PW, PW, -2700.0, 0.0) == 0.0
+      and sz(-PW, PW, -2700.0, PW) == -PW)
+check("size with another charger: its share is sized as without the probe, "
+      "the probe's PROBE_W is added on top",
+      sz(-2700.0, PW, -2700.0, 3000.0) == -2700.0
+      and sz(-2700.0, PW, -2700.0, 1000.0) == -1200.0
+      and sz(-2700.0, PW, -1700.0, 3000.0) == -1700.0
+      and sz(-2700.0, PW, -2700.0, 0.0) == 0.0)
+check("size with no probe is what it was (ask, bound, headroom)",
+      sz(-2500.0, 0.0, -2700.0, 3000.0) == -2500.0
+      and sz(-2500.0, 0.0, -2700.0, 1000.0) == -1000.0
+      and sz(-2500.0, 0.0, -1800.0, 3000.0) == -1800.0
+      and sz(-2500.0, 0.0, -2700.0, None) == 0.0
+      and modetrade.size(modetrade.Tick({}, {}, None, 0.0, None),
+                         (-5.0, 5.0), 3000.0) == 0.0)
+
+# ============================================================================ #
+print("\n2. main: the ask carries the pins filed this tick")
+
+
+def trade(tick, pins, bound=(-2700.0, 2500.0), room=3000.0):
+    """The trade `_mode_trade()` files: (claims, size or None)."""
+    claims = [Claim.set("refused", P_SAFETY, -PW * 1.0, ctl.PROBING,
+                        actuator="x") for _ in range(pins)]
+    me = SimpleNamespace(
+        mode_tick=tick, loop_bound=lambda cl: bound, arb_headroom_w=room,
+        mode_runs=SimpleNamespace(
+            cheap=SimpleNamespace(start=sc.UTC0, end=sc.UTC0,
+                                  mean_eur_kwh=0.1),
+            sell=None, level_eur_kwh=0.1),
+        arb=None, _arb_action=None, log_event=lambda *a, **k: None)
+    filed = main.Controller._mode_trade(me, claims, sc.UTC0)
+    t = [c for c in claims if c.source == arbitrage.SOURCE]
+    return filed, (t[0].value if t else None), me.mode_tick
+
+
+_t0 = modetrade.Tick({}, {A: modetrade.CHARGE}, modetrade.CHARGE, -2500.0,
+                     None, 0.0)
+check("the pin is filed but decide() ran before it (the window's first "
+      "cycle): the charger keeps its whole ask and the pin is added",
+      trade(_t0, 1)[1] == -2700.0 and trade(_t0, 1)[2].probe_w == PW)
+check("the window closed after decide() (its last cycle): the probe's PROBE_W "
+      "leaves the ask, so no battery is handed it",
+      trade(_t_two, 0)[1] == -2500.0
+      and trade(_t_alone, 0) == (False, None, trade(_t_alone, 0)[2])
+      and trade(_t_alone, 0)[2].action is None)
+check("pin and ask agree: nothing changes",
+      trade(_t_two, 1)[1] == -2700.0 and trade(_t_alone, 1)[1] == -PW
+      and trade(_t0, 0)[1] == -2500.0)
+
+# ============================================================================ #
+print("\n3. the real Controller: B refuses and is probed")
+
+
+def charge(r):
+    return -sum(min(0.0, v) for v in r["shares"].values())
+
+
+def window_checks(rows, label):
+    """Per probe window: A as just before, B at PROBE_W (or 0 when nothing is
+    traded), the charge up by at most PROBE_W."""
+    win = sc.windows(rows)
+    ok_a = ok_b = ok_sum = ok_grid = True
+    for i, j in win:
+        pre = rows[i - 1]
+        lo, hi = max(0, i - 3), min(len(rows) - 1, j + 3)
+        ext = rows[lo:hi + 1]
+        base_sum = sum(min(0.0, v) for v in pre["shares"].values())
+        ok_a &= all(abs(r["shares"].get(A, 0.0) - pre["shares"].get(A, 0.0))
+                    < 1e-6 for r in ext)
+        bs = [r["shares"].get(B, 0.0) for r in ext]
+        if any(r["action"] for r in rows[i:j + 1]):
+            ok_b &= set(bs) <= {0.0, -PW} and bs.count(-PW) >= 20
+        else:       # a drain comes first: the window trades nothing
+            ok_b &= set(bs) == {0.0}
+        ok_sum &= all(charge(r) <= charge(pre) + PW + 1e-6 for r in ext)
+        ok_grid &= max(r["grid"] for r in ext) <= pre["grid"] + PW + 50.0
+    n_ch = sum(1 for r in rows if r["probing"] and r["action"])
+    print(f"    {label}: {len(win)} window(s), {n_ch} probing cycles with a "
+          f"trade, highest grid "
+          f"{max(r['grid'] for r in rows):.0f} W")
+    return win, ok_a, ok_b, ok_sum, ok_grid
+
+
+SCEN = {
+    "(a) A in its maintenance charge phase": (
+        sc.day(sc.SF_CH, a_maint=sc.MAINT_CHARGE), "same"),
+    "(a') ...with the charge shaped to 0 W": (
+        sc.day(sc.SF_CH, a_maint=sc.MAINT_CHARGE, shaped=True), "same"),
+    "(b) A idle at 0 W (Solar first, the sun covers the house)": (
+        sc.day(sc.SF_CH, house_w=-10.0), "same"),
+    "(c) A a normal charger in the same run": (sc.day(sc.CH_CH), "same"),
+    "(g7) the OPT-15 rig: drain, then maintenance charge at 0 W": (
+        sc.g7(), "same"),
+    # Not the fix's: A gives the house, and a charge ask means no other
+    # battery gives (OPT-11 owner answer 3), so A rests, as on bf9019e.
+    "(b2) A gives 800 W to the house": (sc.day(sc.SF_CH), "rests"),
+}
+for _name, (_rows, _kind) in SCEN.items():
+    win, ok_a, ok_b, ok_sum, ok_grid = window_checks(_rows, _name)
+    check(f"{_name}: a probe happens (non-vacuous)", len(win) >= 1)
+    if _kind == "same":
+        check(f"{_name}: A's command is the same through each window, first "
+              "and last cycle included", ok_a)
+        check(f"{_name}: the grid rises by PROBE_W at most (plus 50 W of "
+              "noise)", ok_grid)
+    else:
+        check(f"{_name}: A stops giving for the window (the one-sign rule, "
+              "as on bf9019e), charges nothing and gives back after it",
+              all(r["shares"].get(A, 0.0) == 0.0 for i, j in win
+                  for r in _rows[i + 1:j]) and all(
+                  _rows[j + 4]["shares"].get(A, 0.0) > 0.0 for i, j in win))
+    check(f"{_name}: B gets PROBE_W and nothing else", ok_b)
+    check(f"{_name}: the commanded charge rises by PROBE_W at most", ok_sum)
+
+# The g7 sequence in detail: the probe after the drain.
+_g7 = SCEN["(g7) the OPT-15 rig: drain, then maintenance charge at 0 W"][0]
+_w7 = sc.windows(_g7)
+_after = [w for w in _w7 if _g7[w[0]]["now"] > sc.at(18.3, sc.GUTC0)]
+_peak7 = max(r["grid"] for r in _g7 if r["now"] > sc.at(18.3, sc.GUTC0))
+print(f"    g7: probes after the drain at "
+      f"{[_g7[w[0]]['now'].astimezone(sc.L).strftime('%H:%M:%S') for w in _after]}"
+      f", grid after the drain at most {_peak7:.0f} W (TEST-23: 3100 W)")
+check("g7: the probe after A's drain asks B for 200 W with A at 0 W "
+      "(TEST-23: -2300 W on A, the grid at 3100 W)",
+      _after and all(
+          abs(r["shares"].get(A, 0.0)) < 1e-6 for i, j in _after
+          for r in _g7[i:j + 4]) and _peak7 <= 800.0 + PW + 50.0)
+check("g7: during the drain no probe trades (a drain comes first)",
+      all(r["action"] is None for r in _g7
+          if sc.at(18.0, sc.GUTC0) <= r["now"] < sc.at(18.28, sc.GUTC0)))
+_acts = [r["reason"] for i, j in _after for r in _g7[i:j + 1]
+         if r["action"]]
+check("g7: the action log's trade line names the probe's watts, 200 W",
+      _acts and all(f"{PW:.0f} W on {B}" in a for a in _acts))
+check("no opposite-direction split on any of these cycles",
+      not [r for _r, _ in SCEN.values() for r in _r
+           if any(v > 0 for k, v in r["shares"].items() if r["action"])
+           and any(v < 0 for v in r["shares"].values())])
+
+# ============================================================================ #
+print("\n4. battery modes on, no probe: byte-identical to release/1.0 bf9019e")
+# Printed by tools/opt20_scen.py on release/1.0 bf9019e (2026-10-15),
+# goodwe-addon-checks:1.
+AT_BASE = {
+    "sf_ch": "422d6578a7decf1ae3749edd1898ff3cd0541d904c95f636cdd9b1de8c1a07c9",
+    "ch_ch": "15fc25dd34186e56d34b752d37c9e8613295ba737938c92454acca08c83080fb",
+    "ch_ch_maint":
+        "e46e3c666dd63ab33b56e83c0a560c07cec7774a9a70560f55c62a6ae6f55920",
+}
+_got = sc.no_probe_digests()
+for _k in AT_BASE:
+    print(f"    {_k} {'same' if _got[_k] == AT_BASE[_k] else 'DIFFERS'} "
+          f"{_got[_k][:16]}")
+check("with no refusal every share, grid, trade sentence, role and plant "
+      "power of a scripted cheap run equals bf9019e's (A Solar first, A "
+      "charging, A in maintenance charge)", _got == AT_BASE)
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print(f"  - {f}")
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_price.py

@@ -534,11 +534,15 @@ FIXTURES = {
                          [v / 1000 for v in EPEX_EUR_MWH]),
     "custom_formula": (columnar_feed(EPEX_EUR_MWH), FORMULA_EUR_KWH),
     "manual_csv": (None, [0.1834, -0.0210, 0.3115]),
+    # PRICE-01: the owner's price server answers the same columnar layout.
+    "price_service": (columnar_feed(EPEX_EUR_MWH),
+                      [v / 1000 for v in EPEX_EUR_MWH]),
 }
 
 check(f"the plugins that ship after TARIFF-07 and TARIFF-15 are registered "
       f"{sorted(PROVIDERS)}",
-      set(PROVIDERS) == {"generic_dayahead", "custom_formula", "manual_csv"})
+      set(PROVIDERS) == {"generic_dayahead", "custom_formula", "manual_csv",
+                         "price_service"})
 check(f"...and the three withdrawn ids resolve to NOTHING "
       f"{sorted(RETIRED_PROVIDERS)}",
       set(RETIRED_PROVIDERS) == {"engie_dynamic", "totalenergies_dynamic",
@@ -571,7 +575,7 @@ def canned(body):
     """A transport that serves recorded bytes and records that it was used."""
     calls = []
 
-    async def t(url, timeout_s):
+    async def t(url, timeout_s, headers=None):
         calls.append((url, timeout_s))
         return body
     t.calls = calls
@@ -603,6 +607,9 @@ def load_any(pid):
         # is exactly what section 3 grades.
         return load(pid, {"price_formula": json.dumps(ENECO_CARD)},
                     transport=canned(body))
+    if pid == "price_service":
+        return load(pid, {"price_service_token": "test-token-1234"},
+                    transport=canned(body))
     return load(pid, transport=canned(body))
 
 
@@ -898,7 +905,16 @@ _networked = sorted(pid for pid, cls in PROVIDERS.items()
 # SAME CAPTURED BYTES (section 13c), because it reads the same endpoint with
 # the same parser. A networked plugin with no capture is what this line exists
 # to forbid.
-_replayed = ["custom_formula", "generic_dayahead"]
+#
+# ⚠️ PRICE-01 PUT A THIRD ON IT, AND ITS CAPTURE IS A RESHAPE, SAID PLAINLY. The
+# price server answers only to a token this session does not hold, so no real
+# answer of its own exists to replay. Its answer is the energy-charts layout
+# (design, API section), so test_price_service.py replays the REAL energy-charts
+# two-day capture with the three extra keys the design lists (`covers`,
+# `source`, `fetched_at`). The prices and instants are real; the wrapper is the
+# design's. The first answer captured from the live server on the rig test
+# replaces it - that is the open item, and it is in the PRICE-01 report.
+_replayed = ["custom_formula", "generic_dayahead", "price_service"]
 check(f"the networked plugins are {_networked}, and EVERY one of them is "
       f"replayed from a captured real body ({_replayed}) - no shipped plugin "
       f"reaches a network this file has never seen answer (TARIFF-07)",
@@ -1252,7 +1268,7 @@ check(f"a negative day-ahead price passes through, all-in {_neg}",
 # (TARIFF-15): it reads the SAME columnar document, which has no per-point
 # flag, and applies arithmetic to it - arithmetic cannot invent a provenance
 # the document never carried.
-_SETTLED_FEED = {"generic_dayahead", "custom_formula"}
+_SETTLED_FEED = {"generic_dayahead", "custom_formula", "price_service"}
 for pid in sorted(set(READS) - _SETTLED_FEED):
     read = READS[pid]
     flags = derived(lambda r=read: [p.provisional for p in r.points])

goodwe_controller/test_price_forecast.py

@@ -1133,6 +1133,11 @@ _T17_KEYS = ["price_taxes_profile"]
 # `export_price_eur_kwh` is untouched, every site on the scalar is unaffected,
 # and it lives in this dict and in config.yaml and nowhere else.
 _T16_KEYS = ["price_export_formula"]
+# PRICE-01 added the eighth: `price_service_token`, the bearer token of the
+# owner's price server. An ADDITION, like the three above: nothing was renamed,
+# every other provider ignores it, and it lives in this dict and in config.yaml
+# (as a password field) and nowhere else.
+_P01_KEYS = ["price_service_token"]
 check(f"the in-code mirror holds exactly TARIFF-02's, TARIFF-03's, OPT-04's, "
       f"TARIFF-15's, TARIFF-17's and TARIFF-16's keys - FCST-03 still added "
       f"none of its own {_defaults}",
@@ -1142,7 +1147,7 @@ check(f"the in-code mirror holds exactly TARIFF-02's, TARIFF-03's, OPT-04's, "
                            "price_horizon_h", "price_timeout_s",
                            "static_profile"]
                           + _OPT04_KEYS + _T15_KEYS + _T17_KEYS
-                          + _T16_KEYS))
+                          + _T16_KEYS + _P01_KEYS))
 # ...and the later keys are genuinely NEW, not a rename of something that was
 # already there, or the line above would pass while the mirror silently lost a
 # key.
@@ -1151,7 +1156,7 @@ check("...and OPT-04's four, TARIFF-15's one, TARIFF-17's one and TARIFF-16's "
       "are all still present",
       isinstance(_defaults, list)
       and len(set(_defaults) - set(_OPT04_KEYS) - set(_T15_KEYS)
-              - set(_T17_KEYS) - set(_T16_KEYS)) == 9)
+              - set(_T17_KEYS) - set(_T16_KEYS) - set(_P01_KEYS)) == 9)
 # ⚠️ AND THE ONE TARIFF-17 IS THE HOUR-VARYING TWIN OF IS STILL THERE, BY NAME.
 # The line above counts nine, and a rename of `price_taxes_eur_kwh` to
 # `price_taxes_profile` would also count nine. The scalar path being unchanged

goodwe_controller/test_price_secret.py

@@ -0,0 +1,412 @@
+"""PRICE-01 round 2 (F1): a `password` option never reaches a page.
+`python3 test_price_secret.py`
+
+The real web app (`web.build_app`) runs over a fake Supervisor that holds a
+site on `price_service` with a token. The token string must be absent from
+`/config`, `/config/model` (`options`, `running`, `ui`), `/config/validate`,
+a good save's answer and every refused save's answer. A save that sends the
+placeholder, an empty field or no key keeps the stored token; a new value
+replaces it. The same holds for any option the schema calls a password, not
+only this one name.
+
+⚠️ MUTATING A MODULE THIS FILE GRADES? Purge `__pycache__` first, or use
+`tools/mutation_run.sh`. See MUTATION.md.
+"""
+
+import asyncio
+import copy
+import json
+import logging
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+from aiohttp import ClientSession, web as aioweb          # noqa: E402
+
+import translations_lint as TL                            # noqa: E402
+import ux13_demo as D                                     # noqa: E402
+from app import configui, price, web                      # noqa: E402
+from app.configui import SECRET_SHOWN                     # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+TOKEN = "tk-SECRET-0123456789-abcdef"
+NEW_TOKEN = "tk-REPLACED-9876543210-zyxw"
+SCHEMA = D.schema_ui(D.CONFIG)
+TRANSLATIONS = {"en": TL.parse_translation_file(
+    os.path.join(HERE, "translations", "en.yaml"))}
+SITE = dict(D.defaults(D.CONFIG), setpoint_entity="number.goodwe_setpoint",
+            soc_entity="sensor.soc", batt_entity="sensor.batt",
+            price_provider="price_service", price_service_token=TOKEN)
+
+
+class Sup:
+    def __init__(self, options, schema=SCHEMA):
+        self.options, self.schema, self.writes = copy.deepcopy(options), schema, []
+
+    async def info(self):
+        return {"options": copy.deepcopy(self.options), "schema": self.schema,
+                "translations": TRANSLATIONS}
+
+    async def write_options(self, o):
+        self.writes.append(copy.deepcopy(o))
+        self.options = copy.deepcopy(o)
+
+    async def restart(self, c):
+        raise AssertionError
+
+
+class Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def states(self):
+        return []
+
+
+class Ctl:
+    def __init__(self, o):
+        self.o, self.hass, self.inverters = dict(o), Hass(), []
+
+    def log_event(self, *a, **k):
+        pass
+
+    def status_payload(self):
+        return {"banner": "", "level": "ok", "rows": [], "checks": []}
+
+
+async def serve(sup, ctl_options=None):
+    runner = aioweb.AppRunner(web.build_app(Ctl(ctl_options or sup.options), sup))
+    await runner.setup()
+    site = aioweb.TCPSite(runner, "127.0.0.1", 0)
+    await site.start()
+    port = site._server.sockets[0].getsockname()[1]
+    return runner, f"http://127.0.0.1:{port}/"
+
+
+async def scenario():
+    out = {}
+    sup = Sup(SITE)
+    runner, root = await serve(sup)
+    seen = []                                  # every answer body, as text
+    try:
+        async with ClientSession() as s:
+            async def get(path):
+                async with s.get(root + path) as r:
+                    t = await r.text()
+                    seen.append(t)
+                    return r.status, t
+
+            async def post(path, body):
+                async with s.post(root + path, json=body) as r:
+                    t = await r.text()
+                    seen.append(t)
+                    return r.status, t
+
+            _, page = await get("config")
+            out["page"] = page
+            _, raw = await get("config/model?lang=en")
+            m = json.loads(raw)
+            out["model"] = m
+            out["raw_model"] = raw
+            out["field"] = [f for g in m["groups"] for f in g["fields"]
+                            if f["key"] == "price_service_token"]
+
+            # a model of a site with NO token: shown empty, not as 'set'
+            sup0 = Sup(dict(SITE, price_service_token=""))
+            r0, root0 = await serve(sup0)
+            try:
+                async with s.get(root0 + "config/model?lang=en") as r:
+                    out["model_unset"] = await r.json()
+            finally:
+                await r0.cleanup()
+
+            # --- classic page save: the page posts `options`, placeholder in
+            opts = copy.deepcopy(m["options"])
+            opts["peak_cap_w"] = 4100
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m["fingerprint"]})
+            out["classic_placeholder"] = (st, sup.options["price_service_token"],
+                                          sup.options["peak_cap_w"], body)
+            # --- classic save with the field emptied
+            _, raw2 = await get("config/model?lang=en")
+            m2 = json.loads(raw2)
+            opts = copy.deepcopy(m2["options"])
+            opts["price_service_token"] = ""
+            opts["peak_cap_w"] = 4200
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m2["fingerprint"]})
+            out["classic_empty"] = (st, sup.options["price_service_token"],
+                                    sup.options["peak_cap_w"])
+            # --- classic save with the key left out
+            _, raw2 = await get("config/model?lang=en")
+            m2 = json.loads(raw2)
+            opts = copy.deepcopy(m2["options"])
+            del opts["price_service_token"]
+            opts["peak_cap_w"] = 4250
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m2["fingerprint"]})
+            out["classic_absent"] = (st, sup.options["price_service_token"])
+            # --- the new settings page: model in, with and without base
+            _, raw3 = await get("config/model?lang=en")
+            m3 = json.loads(raw3)
+            ui = copy.deepcopy(m3["ui"])
+            ui["peak_cap_w"] = 4300
+            st, body = await post("config/save", {
+                "model": ui, "base": copy.deepcopy(m3["ui"]),
+                "fingerprint": m3["fingerprint"]})
+            out["ui_base"] = (st, sup.options["price_service_token"])
+            _, raw3 = await get("config/model?lang=en")
+            m3 = json.loads(raw3)
+            ui = copy.deepcopy(m3["ui"])
+            ui["peak_cap_w"] = 4400
+            st, body = await post("config/save",
+                                  {"model": ui, "fingerprint": m3["fingerprint"]})
+            out["ui_nobase"] = (st, sup.options["price_service_token"])
+            # --- validate with the placeholder in: no 'too short', no echo
+            _, raw4 = await get("config/model?lang=en")
+            m4 = json.loads(raw4)
+            st, body = await post("config/validate", {"options": m4["options"]})
+            out["validate_placeholder"] = (st, json.loads(body)["problems"])
+            st, body = await post("config/validate", {"model": m4["ui"]})
+            out["validate_ui_placeholder"] = (st, json.loads(body)["problems"])
+            # --- a refused save (token too short) and a stale one
+            opts = copy.deepcopy(m4["options"])
+            opts["price_service_token"] = "short"
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m4["fingerprint"]})
+            out["refused"] = (st, json.loads(body), sup.options["price_service_token"])
+            opts = copy.deepcopy(m4["options"])
+            opts["peak_cap_w"] = 4500
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": "not-current"})
+            out["stale"] = (st, json.loads(body))
+            # --- a refusal that is not about the token
+            opts = copy.deepcopy(m4["options"])
+            opts["max_w"] = -5
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m4["fingerprint"]})
+            out["refused_other"] = (st, sup.options["price_service_token"],
+                                    sup.options["max_w"])
+            # --- a new value replaces
+            _, raw5 = await get("config/model?lang=en")
+            m5 = json.loads(raw5)
+            opts = copy.deepcopy(m5["options"])
+            opts["price_service_token"] = NEW_TOKEN
+            st, body = await post("config/save",
+                                  {"options": opts, "fingerprint": m5["fingerprint"]})
+            out["replaced"] = (st, sup.options["price_service_token"], body)
+            out["writes"] = len(sup.writes)
+    finally:
+        await runner.cleanup()
+    out["seen"] = seen
+    return out
+
+
+S = asyncio.run(scenario())
+
+print("1. the token is in no page and no JSON answer")
+check("GET /config (the classic page) has no token",
+      TOKEN not in S["page"] and NEW_TOKEN not in S["page"])
+check("GET /config/model has no token anywhere in its JSON",
+      TOKEN not in S["raw_model"])
+for key in ("options", "running", "ui"):
+    check(f"...and {key} shows the placeholder, not the token",
+          json.dumps(S["model"][key]).count(SECRET_SHOWN) >= 1
+          and TOKEN not in json.dumps(S["model"][key]))
+check("...the placeholder stands in the token's own place",
+      S["model"]["options"]["price_service_token"] == SECRET_SHOWN
+      and S["model"]["running"]["price_service_token"] == SECRET_SHOWN
+      and S["model"]["ui"]["price_service_token"] == SECRET_SHOWN)
+check("a site with no token shows it empty, so the page can say 'not set'",
+      S["model_unset"]["options"]["price_service_token"] == ""
+      and S["model_unset"]["ui"]["price_service_token"] == "")
+check("no answer the app gave in the whole run (page, model, validate, saves, "
+      "refusals, the stale one) holds the stored token",
+      not [t for t in S["seen"] if TOKEN in t])
+check("...nor the new token, after it was saved",
+      not [t for t in S["seen"] if NEW_TOKEN in t])
+
+print("\n2. the classic page draws it as a password field")
+check("the field model types it as a password",
+      [f["type"] for f in S["field"]] == ["password"])
+check("the classic page's script makes a password input for that type",
+      "'password'" in S["page"] and "input.type = 'password'" in S["page"])
+
+print("\n3. saves keep the stored token unless given a new one")
+st, tok, cap, body = S["classic_placeholder"]
+check("a classic save with the placeholder keeps the token and saves the "
+      "other edit", st == 200 and tok == TOKEN and cap == 4100)
+st, tok, cap = S["classic_empty"]
+check("a classic save with the field emptied keeps the token",
+      st == 200 and tok == TOKEN and cap == 4200)
+check("a classic save without the key keeps the token",
+      S["classic_absent"] == (200, TOKEN))
+check("a save from the new settings page keeps it (with a base)",
+      S["ui_base"] == (200, TOKEN))
+check("...and without a base", S["ui_nobase"] == (200, TOKEN))
+st, tok, body = S["replaced"]
+check("a new value replaces the token", st == 200 and tok == NEW_TOKEN)
+check("...and the answer to that save does not echo it",
+      NEW_TOKEN not in body)
+st, probs = S["validate_placeholder"]
+check("validate with the placeholder in sees the stored token: nothing about "
+      "the token is refused", st == 200 and not [p for p in probs if "token" in p])
+st, probs = S["validate_ui_placeholder"]
+check("...also from the new page's model",
+      st == 200 and not [p for p in probs if "token" in p])
+st, body, tok = S["refused"]
+check("a refused save (token too short) is 422, says why in short plain "
+      "words, and writes nothing",
+      st == 422 and tok == TOKEN
+      and any("too short" in p for p in body["problems"]))
+st, body = S["stale"]
+check("a stale refusal is 409 and its `stored` shows the placeholder",
+      st == 409 and body["stored"]["price_service_token"] == SECRET_SHOWN)
+check("a refusal about something else (422) writes nothing, so the token and "
+      "the rating stay",
+      S["refused_other"][0] == 422 and S["refused_other"][1] == TOKEN
+      and S["refused_other"][2] != -5)
+
+print("\n4. every password option, not only this name")
+other = [{"name": "mqtt_secret", "type": "string", "format": "password"},
+         {"name": "other_pw", "type": "password"},
+         {"name": "plain", "type": "string"}]
+keys = configui.secret_keys(other)
+check("a schema password is found in both spellings, a plain string is not",
+      keys == {"mqtt_secret", "other_pw"})
+check("the price token is counted by name too, in case a schema is missing",
+      configui.secret_keys([], price.SECRET_OPTIONS)
+      == frozenset(price.SECRET_OPTIONS) and "price_service_token" in
+      price.SECRET_OPTIONS)
+blob = {"mqtt_secret": "hunter2hunter2", "other_pw": "", "plain": "x",
+        "nested": [{"mqtt_secret": "deep-secret-value"}]}
+shown = configui.hide_secrets(blob, keys)
+check("hide_secrets: set -> placeholder, empty -> empty, other keys alone, "
+      "at any depth",
+      shown == {"mqtt_secret": SECRET_SHOWN, "other_pw": "", "plain": "x",
+                "nested": [{"mqtt_secret": SECRET_SHOWN}]}
+      and blob["mqtt_secret"] == "hunter2hunter2")
+back = configui.keep_secrets({"mqtt_secret": SECRET_SHOWN, "other_pw": "new",
+                              "plain": "y"}, blob, keys)
+check("keep_secrets: the placeholder gives the stored value, a new value "
+      "stays",
+      back["mqtt_secret"] == "hunter2hunter2" and back["other_pw"] == "new"
+      and back["plain"] == "y")
+check("keep_secrets: a placeholder with nothing stored is never saved as "
+      "the placeholder",
+      configui.keep_secrets({"mqtt_secret": SECRET_SHOWN}, {}, keys)
+      ["mqtt_secret"] == "")
+
+
+async def other_option_scenario():
+    """A second password option, found from the schema, is hidden and kept."""
+    schema = SCHEMA + [{"name": "extra_secret", "type": "string",
+                        "format": "password", "required": False,
+                        "optional": True}]
+    sup = Sup(dict(SITE, extra_secret="extra-secret-value-12345"), schema)
+    runner, root = await serve(sup)
+    try:
+        async with ClientSession() as s:
+            async with s.get(root + "config/model?lang=en") as r:
+                raw = await r.text()
+            m = json.loads(raw)
+            opts = copy.deepcopy(m["options"])
+            opts["peak_cap_w"] = 4100
+            async with s.post(root + "config/save", json={
+                    "options": opts, "fingerprint": m["fingerprint"]}) as r:
+                st = r.status
+            return raw, st, sup.options.get("extra_secret")
+    finally:
+        await runner.cleanup()
+
+
+_raw, _st, _kept = asyncio.run(other_option_scenario())
+check("a password option the add-on has no name for is hidden from the model",
+      "extra-secret-value-12345" not in _raw)
+check("...and kept by a save that sends the placeholder",
+      _st == 200 and _kept == "extra-secret-value-12345")
+
+async def named_scenario():
+    """A schema that does not call the token a password (a Supervisor that
+    spells it another way): the add-on still hides it, by name."""
+    schema = [dict(n, format=None) if n["name"] == "price_service_token" else n
+              for n in SCHEMA]
+    sup = Sup(SITE, schema)
+    runner, root = await serve(sup)
+    try:
+        async with ClientSession() as s:
+            async with s.get(root + "config/model?lang=en") as r:
+                return await r.text()
+    finally:
+        await runner.cleanup()
+
+
+check("the price token is hidden by name even when the schema does not mark "
+      "it as a password", TOKEN not in asyncio.run(named_scenario()))
+
+print("\n5. PRICE-01 round 3: the fixed-tariff note on the real validate route")
+_PROFILE = json.dumps({"periods": [
+    {"name": "all", "days": "all", "from": "00:00", "to": "24:00",
+     "eur_per_kwh": 0.25}]})
+_NOTE = {"en": ("With the price service, the fixed tariff is only used if no "
+                "prices are available."),
+         "nl": ("Met de prijsdienst wordt het vaste tarief alleen gebruikt als "
+                "er geen prijzen zijn.")}
+
+
+async def note_scenario(site):
+    runner, root = await serve(Sup(site))
+    out = {}
+    try:
+        async with ClientSession() as s:
+            for lang in ("en", "nl"):
+                async with s.get(root + f"config/model?lang={lang}") as r:
+                    m = await r.json()
+                async with s.post(root + "config/validate",
+                                  json={"model": m["ui"], "lang": lang}) as r:
+                    b = await r.json()
+                out[lang] = [x for x in b.get("messages", [])
+                             if x["text"] in _NOTE.values()]
+    finally:
+        await runner.cleanup()
+    return out
+
+
+_with = asyncio.run(note_scenario(dict(SITE, static_profile=_PROFILE)))
+check("an English page gets the note in English, as info, beside a field",
+      [(x["text"], x["tier"]) for x in _with["en"]] == [(_NOTE["en"], "info")]
+      and _with["en"][0]["field"])
+check("...and a Dutch page gets it in Dutch, beside the same field",
+      [(x["text"], x["tier"]) for x in _with["nl"]] == [(_NOTE["nl"], "info")]
+      and _with["nl"][0]["field"] == _with["en"][0]["field"])
+_blank = asyncio.run(note_scenario(dict(SITE, static_profile="   ")))
+check("a spaces-only fixed tariff: no note on either page",
+      _blank == {"en": [], "nl": []})
+
+print("\n6. the shipped config.yaml")
+cfg = open(os.path.join(HERE, "config.yaml"), encoding="utf-8").read()
+schema_text = cfg[cfg.index("\nschema:"):]
+pw = {line.split(":")[0].strip() for line in schema_text.splitlines()
+      if line.split(":", 1)[-1].strip().rstrip("?") == "password"}
+check(f"every password option of config.yaml is counted as a secret ({sorted(pw)})",
+      pw and pw <= configui.secret_keys(SCHEMA, price.SECRET_OPTIONS))
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED: " + "; ".join(fails))
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_safety118.py

@@ -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)

goodwe_controller/test_safety119.py

@@ -0,0 +1,667 @@
+"""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. Round 3: across all
+hand-backs the bound is hidden on at most ROLLING_BUDGET[cycle length] cycles
+(10 up to a 3.5 s cycle, 8 up to 11 s, 6 up to 16 s, 4 beyond) in any
+ROLLING_S seconds, so a bound that stays warns when the guard and the charge
+keep taking turns. DECISIONS/SAFETY-119-bound-after-hand-back.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 (every quarter at 2, 5 and 10 s, every other
+   quarter at least at 15 s); the quarter-edge case stays silent at 2, 5, 10
+   and 15 s, including the 2 s seed where a fixed budget of 8 warns; a start
+   or a blind cycle is not a hand-back; a slow meter delays by cycles.
+5. The rule at its boundaries (`Controller._settling`): the settle, and the
+   rolling budget.
+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 = 10                       # the budget at a 1 s cycle
+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):
+    rig.TICK = tick
+    try:
+        f = lambda: run(house(1, step=(300.0, hw)), n=2)
+        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)]
+
+
+_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 s and 5 s meters: it warns in every quarter after the first",
+      all(per_quarter(_nv[t][1])[q] >= 1 for q in range(1, 8)
+          for t in (2.0, 5.0)))
+check("⭐ 10 s meter: it warns in every quarter after the first (round 2 "
+      "gave none)",
+      all(per_quarter(_nv[10.0][1])[q] >= 1 for q in range(1, 8)))
+check("⭐ 15 s meter: it warns at least every other quarter after the first "
+      "(round 2 gave none)",
+      not any(a == 0 and b == 0 for a, b in zip(
+          per_quarter(_nv[15.0][1])[1:], per_quarter(_nv[15.0][1])[2:])))
+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)
+
+# 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 = {}
+# Seeds 1 to 3 are the brief's fixed set; 2 s seed 25 is the one where the
+# sweep's fixed budget of 8 warned (DECISIONS), kept here so that stays seen.
+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)) + (
+            ((25, 2),) if _t == 2.0 else ()):
+        _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 "
+      "and (2 s) 25: 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)))
+rig.TICK = 2.0
+_q25_8 = patched(app_main, "ROLLING_BUDGET", ((math.inf, 8),))(
+    lambda: run(house(25), delay=2))
+rig.TICK = 1.0
+print(f"    2 s meter, seed 25, a fixed budget of 8: notifications "
+      f"{notes(_q25_8[1])}")
+check("...2 s seed 25 is the sweep's known case: a fixed budget of 8 warns "
+      "there (why the budget follows the cycle length)",
+      len(notes(_q25_8[1])) >= 1)
+check("the budget is the one the sweep chose. Changing it means re-running "
+      "the sweep in DECISIONS/SAFETY-119-bound-after-hand-back.md",
+      app_main.ROLLING_BUDGET == ((3.5, 10), (11.0, 8), (16.0, 6),
+                                  (math.inf, 4))
+      and app_main.ROLLING_BOUND_CYCLES == 8 and app_main.ROLLING_S == 900.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]))
+
+# The budget is cycles, not seconds (R4): at a 5 s meter the loop at its
+# rail after a hand-back warns 8 cycles (40 s) later, not 8 s.
+MB = 8                        # the budget at a 5 s cycle
+rig.TICK = 5.0
+_sl = run(house(1, step=(600.0, -6000.0)), dur=900.0,
+          extra={"peak_cap_w": 20000})
+rig.TICK = 1.0
+_sl1 = [t for t in notes(_sl[1]) if t >= 600.0][:1]
+print(f"    5 s meter, hand-back to a loop at its rail at 600 s: first "
+      f"notification {_sl1}")
+check(f"⭐ at a 5 s meter the budget is cycles, not seconds: the first "
+      f"warning comes {MB} cycles ({MB * 5} s) after the hand-back",
+      _sl1 and 600.0 + MB * 5.0 <= _sl1[0] <= 600.0 + MB * 5.0 + 10.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._settle_t, self._settle_dt = None, 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
+
+
+N, SPAN = app_main.SHORT_CYCLES, app_main.SHORT_SPAN_S
+M, ROLL = 8, 900.0           # the chosen budget, 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, N + 3)])
+check(f"after another owner: settling for {N - 1} owned cycles, then not "
+      f"(12 cycles at 2 s span {SPAN:.0f} s)",
+      _out == [False] + [True] * (N - 1) + [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]))
+_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)] * (N + 1))
+      == [False] + [True] * (N - 1) + [False] * 2)
+
+# The rolling budget: the loop's bound is hidden on at most M cycles in any
+# ROLL seconds, across all hand-backs. T = the loop's bound that cycle.
+assert M < N - 1, "the budget is meant to run out inside one settle"
+
+
+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
+
+
+_c = _C()
+_o = seq(_c, [(False, 0.0)] + [(True, 5.0 * i, True) for i in range(1, N)])
+check(f"one hand-back at 5 s, the bound on every cycle: {M} are hidden, "
+      f"then it counts for the rest of the settle ({N - 1} cycles)",
+      _o == [False] + [True] * M + [False] * (N - 1 - M))
+_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(N):                              # 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(N + 1)]
+_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 follows the cycle length: bound cycles hidden before the first
+# one counts, one hand-back per turn.
+_bud = {}
+for _tick in (1.0, 2.0, 3.0, 5.0, 10.0, 15.0, 20.0, 30.0, 60.0):
+    _c = _C()
+    _o, _ = turns(_c, _tick, 1, min(14, int(880.0 // (2 * _tick))))
+    _bud[_tick] = sum(1 for _t2, h in _o if h)
+print(f"    hidden before the first counts, by cycle length: {_bud}")
+check("the budget by cycle length: 10 at 1-3 s, 8 at 5-10 s, 6 at 15 s, 4 "
+      "at 20-60 s",
+      _bud == {1.0: 10, 2.0: 10, 3.0: 10, 5.0: 8, 10.0: 8, 15.0: 6,
+               20.0: 4, 30.0: 4, 60.0: 4})
+_c = _C()
+_o, _t = turns(_c, 2.0, 3, 8)
+_o2, _ = turns(_c, 121.0, 1, 3, first=_t + 119.0)
+check("a gap over two minutes is not a cycle length: the 2 s budget (10) "
+      "stays",
+      [h for _t2, h in _o + _o2] == [True] * 10 + [False])
+
+# 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("no monotonic clock, repeated hand-backs: the budget holds (8 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)
+
+_ctl._wire_lost, _ctl._handback = True, (1.0, 3)
+_ctl._loop_decision = None                    # stopped or blind
+_ctl._loop_alarm_input(_Res())
+check("a stop clears it: the next start is not a hand-back, and the stop "
+      "is not a cycle length",
+      (_ctl._wire_lost, _ctl._handback, _ctl._settle_t)
+      == (False, None, None))
+
+# ============================================================================ #
+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")

goodwe_controller/test_safety84.py

@@ -472,19 +472,22 @@ 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).
 PINNED = {
     "n1_charge":
-        "0ed25c856456b97acb07a39299a8cb7b1a762c4d0005b88a0823c03057a80be5",
+        "19781f90b9751b10994dedeaafb38e42d48ad2551640792e601336b7f9b5bb4f",
     "n1_charge_dear":
-        "c25340b56060d4581f7204e200b07e7c8618711be2baca3b1667b7ebeb600dc3",
+        "eeeb0fa19a6fdc04d44a0838bb2bb911f506a936b0f93d8a6f4d87159053ec74",
     "n1_charge_banked":
-        "2619acdd06b04e56c000b168d64e1d044346c6ba3f929c94258d6ad8189ec609",
+        "a51f125a8c1c98fdbb009fce72b6781d20d384bdf0f5ce7bbfe367d86e5477db",
     "n2_charge":
-        "b16d692128f14bcce3d87b142d290e0d6b13724289680e44a05215c9eaa24a7c",
+        "e37e98390baa5dad9128991fabf8b170894395fe026d8a33c8a51de7ed0789cc",
     "n2_charge_dear":
-        "00a197d89a5dd1e8b3ae6a5d1af66329a4dc4850476569c5931c125fa4d9eaee",
+        "7727372de423f62d77b4426a7226eae31a30f3bb89a3cf70272cc7c1823d7263",
     "n2_charge_banked":
-        "a6973faea916e4c88ca1770047f94478346eeb1efa4889b154fad0747f91267f",
+        "c77e26006c026b953e9c3dcc9a02f3993589f885cb52c7cbceac6bd59b600551",
 }
 _now = s84.digests()
 for k in PINNED:
@@ -492,7 +495,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-119), 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")))

goodwe_controller/test_safety87.py

@@ -518,17 +518,21 @@ 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).
 PINNED = {   # tools/safety87_identity.py on b8ddfd7
     "n1_under":
         "d2395ef8d74fb23607ad864d5a4bf62c03044bbd9367e873675d7ad10e8c169f",
     "n1_crossing":
-        "97f7321017d9d34ee17a40dfd4abf73d915f25b9faef086a483d2b5cd124b198",
+        "20f8e542c1ee3eb3a58c8fd6ba3b3e5b6b1486800cd63b675abc68bc222a172b",
     "n1_above":
-        "45726a285aa84f40542d56482652397c3c1e212ba4fe2009f6cc52f537ccad52",
+        "3a79f1394b2b49fa88f3c054da1d9da450153ad5f0d2a2c2f960d02a7abe2208",
     "n1_under_banked":
         "a2876c7cc873bc4c974d2b4bd98e23bba2d007b84545587d2fe0b713b0a6249b",
     "n1_charge_low":
-        "91336e3c0314985a3b00f314c79b5ffb5a740d218de3ad44f88a4db6e4235b32",
+        "2e1ee6db0d4f9f18836c4cbbe406fddd496656b54b97f329da513a1591f0ce6c",
     "n1_hold":
         "0a1df347754c69166b20d04c15ee878bbcefb02abb824b9b452334f68f03e46d",
 }
@@ -536,8 +540,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-119), under, "
+      "crossing and above the reserve, in a charge and a HOLD, and under a "
+      "banked peak",
       _now == PINNED)
 
 # ============================================================================ #

goodwe_controller/test_setup_only.py

@@ -454,7 +454,11 @@ check("the saved blob passes the normal gate: no refusal, not setup-only",
 
 print("\n    after the restart, on the saved settings:")
 rc, ev, err, files = run_child("after", SAVED or {}, SAVED_STATE)
-services = [e for e in ev if e[0] == "SERVICE"]
+# Not the dismiss of PRICE-01's old fixed-tariff card, sent at every start.
+# Only that dismiss: a `create` with the old id would still be counted.
+services = [e for e in ev if e[0] == "SERVICE"
+            and not (e[1:3] == ["persistent_notification", "dismiss"]
+                     and e[3].get("notification_id") == "goodwe_fixed_tariff_unused")]
 writes = [e[3].get("value") for e in services
           if e[1:3] == ["number", "set_value"]]
 print(f"    after: exit {rc}, {len(services)} service calls, set_value "

goodwe_controller/test_ui_text.py

@@ -286,6 +286,22 @@ check("app/uitext.py falls back to English per key and reads nl-BE as nl",
       and uitext._merge({"a": {"b": 1, "c": 2}}, {"a": {"b": 3}})
       == {"a": {"b": 3, "c": 2}})
 
+# ============================================================================ #
+print("\n7. the dynamic contract choice says 15 minutes, never hourly (UX-44)")
+# Belgian day-ahead prices are per 15 minutes since 2025-10-01.
+HOURLY = re.compile(r"hourly|per hour|\bhour\b|per uur|\buur\b|uurprijs",
+                    re.I)
+_dyn = {"en": EN["choices"]["contract"]["dynamic"],
+        "nl": NL["choices"]["contract"]["dynamic"]}
+check(f"the label reads 'Dynamic, every 15 minutes' / 'Dynamisch, per "
+      f"kwartier' ({_dyn})",
+      _dyn == {"en": "Dynamic, every 15 minutes",
+               "nl": "Dynamisch, per kwartier"})
+check("neither language calls the dynamic contract hourly",
+      not any(HOURLY.search(t) for t in _dyn.values()))
+check("mutation: the old labels are caught",
+      all(HOURLY.search(t) for t in ("Dynamic, hourly", "Dynamisch, per uur")))
+
 print()
 if fails:
     print(f"{len(fails)} FAILED")

goodwe_controller/test_uimodel.py

@@ -327,6 +327,66 @@ check("days the editor has no choice for stay in the Configuration tab, and "
       ["ui.periods"] is None and edit(dict(SITE, static_profile=_raw), gain=0.5)
       ["static_profile"] == _raw)
 
+print("\n8. UX-43: tariff prices take five decimals")
+from app import uilayout as _L                                  # noqa: E402
+_PX = 0.34512
+_TARIFF = ("ui.fixed_price", "ui.day_price", "ui.night_price", "ui.periods")
+_steps = {k: _L.field(k).step for k in _TARIFF}
+check("the four tariff price fields step 0.00001 EUR/kWh",
+      sorted(_steps) == sorted(_TARIFF)
+      and all(v == 0.00001 for v in _steps.values()))
+_f5 = edit(DEFAULTS, ui__contract="fixed", ui__fixed_price=_PX)
+check("fixed price 0.34512 is saved exactly and read back exactly",
+      '"eur_per_kwh": 0.34512}' in _f5["static_profile"]
+      and U.options_to_ui(_f5)["ui.fixed_price"] == _PX
+      and trip(_f5) == _f5)
+_d5 = edit(SITE, ui__contract="daynight", ui__day_price=_PX,
+           ui__night_price=0.26789)
+check("day price 0.34512 and night price 0.26789 are saved and read back exactly",
+      '"eur_per_kwh": 0.34512' in _d5["static_profile"]
+      and '"eur_per_kwh": 0.26789' in _d5["static_profile"]
+      and U.options_to_ui(_d5)["ui.day_price"] == _PX
+      and U.options_to_ui(_d5)["ui.night_price"] == 0.26789
+      and not validate_startup_config(_d5))
+_n5 = edit(SITE, ui__contract="daynight", ui__day_price=0.3, ui__night_price=_PX)
+check("night price 0.34512 alone is saved and read back exactly",
+      U.options_to_ui(_n5)["ui.night_price"] == _PX)
+_r3 = rows(("00:00", "07:00", "mon-sun", 0.12345), ("07:00", "22:00", "mon-sun", _PX),
+           ("22:00", "24:00", "mon-sun", 0.05001))
+_p3 = periods(_r3)
+check("three windows with five-decimal prices save and read back exactly",
+      [p.eur_per_kwh for p in parse_static_profile(_p3["static_profile"]).periods]
+      == [0.12345, _PX, 0.05001]
+      and [r["price"] for r in U.options_to_ui(_p3)["ui.periods"]]
+      == [0.12345, _PX, 0.05001] and trip(_p3) == _p3
+      and "e-" not in _p3["static_profile"])
+check("a two-decimal price still works", U.options_to_ui(
+    edit(DEFAULTS, ui__contract="fixed", ui__fixed_price=0.31))
+    ["ui.fixed_price"] == 0.31)
+_old = dict(SITE, price_provider="off", static_profile=json.dumps({"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "mon-fri",
+     "eur_per_kwh": 0.34},
+    {"name": "night", "from": "22:00", "to": "07:00", "days": "mon-fri",
+     "eur_per_kwh": 0.26},
+    {"name": "night", "from": "00:00", "to": "24:00", "days": "sat,sun",
+     "eur_per_kwh": 0.26}]}))
+check("a stored profile with two-decimal prices is unchanged by load and save",
+      trip(_old) == _old)
+_js = open(os.path.join(HERE, "app", "static", "settings.js"),
+           encoding="utf-8").read()
+check("the window editor's price input takes its step from the field, not a "
+      "hard-coded 0.01", 'step: "0.01"' not in _js
+      and "step: String(f.step || 0.01)" in _js)
+for _lang in ("en", "nl"):
+    with open(os.path.join(HERE, "app", "ui_text", f"{_lang}.json"),
+              encoding="utf-8") as _fh:
+        _flds = json.load(_fh)["fields"]
+    _hint = "34.512" if _lang == "en" else "34,512"
+    _eq = "0.34512" if _lang == "en" else "0,34512"
+    check(f"[{_lang}] the c€/kWh hint sits on all four tariff price fields",
+          all(_hint in _flds[k]["description"] and _eq in _flds[k]["description"]
+              for k in ("fixed_price", "day_price", "night_price", "periods")))
+
 print()
 if fails:
     print(f"{len(fails)} FAILED")

goodwe_controller/test_watchdog.py

@@ -1111,8 +1111,17 @@ check("...carrying the reason with it, so the operator who has to decide "
 check("...and it is still commanding 0 W on the far side of the restart",
       _b.target == 0.0 and "circulation" in _b.reason)
 
-_notes1 = [c for c in _h1.calls if c[0] == "persistent_notification"]
-_notes2 = [c for c in _h2.calls if c[0] == "persistent_notification"]
+# Not the dismiss of PRICE-01's old fixed-tariff card, sent at every start.
+# Only that dismiss: a `create` with the old id would still be counted.
+def _not_old_dismiss(c):
+    return not (c[1] == "dismiss"
+                and c[2].get("notification_id") == "goodwe_fixed_tariff_unused")
+
+
+_notes1 = [c for c in _h1.calls if c[0] == "persistent_notification"
+           and _not_old_dismiss(c)]
+_notes2 = [c for c in _h2.calls if c[0] == "persistent_notification"
+           and _not_old_dismiss(c)]
 print(f"       notifications raised: {len(_notes1)} before the restart, "
       f"{len(_notes2)} after it")
 check("the alarm was raised in the first process", len(_notes1) >= 1)

goodwe_controller/tools/opt11_identity.py

@@ -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

goodwe_controller/tools/opt20_scen.py

@@ -0,0 +1,160 @@
+"""OPT-20: the refusal-probe scenarios, on the REAL Controller in the lagged
+replay (tools/opt11p3_replay.py). Uses only the API bf9019e has, so the same
+file runs on both trees (test_opt20.py pins the digests printed on bf9019e).
+
+Battery B is Cheap hours and refuses to charge; it is probed every 15 minutes
+inside the cheap run (OPT-15). A is, per scenario, in its maintenance charge
+phase, idle (Solar first), or a normal charger in the same run.
+"""
+
+import hashlib
+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.dirname(HERE))
+logging.disable(logging.WARNING)
+
+import opt11p3_replay as rp                                    # noqa: E402
+from app import packmode                                       # noqa: E402
+from app.maintenance import CHARGE, DRAIN, MaintResult         # noqa: E402
+
+L = timezone(timedelta(hours=2))
+A, B = "inverter-a", "inverter-b"
+LAG = rp.Lag(tau_s=0.05, ramp_w_s=1e9)
+SF_CH = {"a": (True, packmode.SOLAR_FIRST, False),
+         "b": (True, packmode.CHEAP_HOURS, False)}
+CH_CH = {"a": (True, packmode.CHEAP_HOURS, False),
+         "b": (True, packmode.CHEAP_HOURS, False)}
+
+# A day of the owner's kind: cheap 02:00-04:00 local, flat otherwise.
+D0 = datetime(2026, 9, 9, 0, 0, tzinfo=L)
+UTC0 = D0.astimezone(timezone.utc)
+_PR = [0.30] * 192
+for _i in range(8, 16):
+    _PR[_i] = 0.10
+WPTS = [(UTC0 + timedelta(minutes=15 * i), 900, p) for i, p in enumerate(_PR)]
+
+# OPT-15 rig g7: prices 0 from 17:45 to 18:45 local, flat 0.06 otherwise.
+G0 = datetime(2026, 10, 13, 0, 0, tzinfo=L)
+GUTC0 = G0.astimezone(timezone.utc)
+_GP = [0.06] * 192
+for _i in range(71, 75):
+    _GP[_i] = 0.0
+for _i in range(76, 78):
+    _GP[_i] = 0.5
+G7PTS = [(GUTC0 + timedelta(minutes=15 * i), 900, p)
+         for i, p in enumerate(_GP)]
+
+
+def at(h, base=UTC0):
+    return base + timedelta(hours=h)
+
+
+def _rows(rows):
+    def cb(c, h, now, pr):
+        sh = dict(c.allocation.shares) if c.allocation is not None \
+            and c.allocation.shares else {}
+        rows.append(dict(
+            now=now, grid=h.grid(), shares=sh,
+            action=getattr(c.arb, "action", None),
+            reason=getattr(c.arb, "reason", None) or "",
+            probing=c.inverters[1].probe_from is not None,
+            roles=dict(c.mode_tick.roles) if c.mode_tick else {},
+            p={u: p.p for u, p in h.plants.items()}))
+    return cb
+
+
+def day(choice, *, a_maint=None, shaped=False, refuse=("b",), hours=0.5,
+        house_w=800.0):
+    """02:00..: a cheap run, `house_w` house. `a_maint` is A's forced maintenance
+    result from 5 minutes in (B's refusal stands by then); `shaped` closes the
+    maintenance charge's own watts (charge-only shaping, hi = 0)."""
+    rows = []
+
+    def patch(c):
+        if shaped:
+            c._charge_headroom = lambda floor, claims: 0.0
+        if a_maint is None:
+            return
+        m, real = c.maints[0], c.maints[0].tick
+
+        def tick(now, soc, blocked_by=None, gate_open=True):
+            if now >= at(1.9 + 5 / 60):
+                return a_maint
+            return real(now, soc, blocked_by=blocked_by, gate_open=gate_open)
+        m.tick = tick
+    rp.run("p3_ch_sell", [(UTC0.timestamp() - 10, house_w)], WPTS, at(1.9),
+           3600 * hours, check=_rows(rows), lag=LAG, n=2,
+           soc0={"a": 50.0, "b": 30.0}, choice=choice, refuse=refuse,
+           patch=patch, extra={"cycle_cost_threshold_eur": 0.10})
+    return rows
+
+
+def g7():
+    """The OPT-15 rig's g7: B refuses from the start of the cheap run, A
+    drains 18:00 to 18:17:04 and then sits in its maintenance charge phase
+    (charge-only) at 0 W. The probe after the drain used to put the trade's
+    2500 W on A."""
+    rows = []
+    t_end = at(18 + 17 / 60 + 4 / 3600, GUTC0)
+
+    def patch(c):
+        m, real = c.maints[0], c.maints[0].tick
+
+        def tick(now, soc, blocked_by=None, gate_open=True):
+            if at(18.0, GUTC0) <= now < t_end:
+                return MaintResult(DRAIN, True, 2000.0, False, [])
+            if now >= t_end:
+                return MaintResult(CHARGE, False, None, True, [])
+            return real(now, soc, blocked_by=blocked_by, gate_open=gate_open)
+        m.tick = tick
+    rp.run("p3_ch_sell", [(GUTC0.timestamp() - 10, 800.0)], G7PTS,
+           at(17.6, GUTC0), 3600 * 1.1, check=_rows(rows), lag=LAG, n=2,
+           soc0={"a": 17.0, "b": 73.0}, choice=SF_CH, refuse=("b",),
+           patch=patch, extra={"cycle_cost_threshold_eur": 0.10})
+    return rows
+
+
+MAINT_CHARGE = MaintResult(CHARGE, False, None, True, [])
+
+
+def windows(rows):
+    """[(first, last)] row indexes of each probe window."""
+    out, i = [], 0
+    while i < len(rows):
+        if rows[i]["probing"]:
+            j = i
+            while j + 1 < len(rows) and rows[j + 1]["probing"]:
+                j += 1
+            out.append((i, j))
+            i = j + 1
+        else:
+            i += 1
+    return out
+
+
+def digest(rows) -> str:
+    keep = [(r["now"].isoformat(), sorted(r["shares"].items()),
+             round(r["grid"], 3), r["action"], r["reason"],
+             sorted(r["roles"].items()), sorted(r["p"].items()))
+            for r in rows]
+    return hashlib.sha256(repr(keep).encode()).hexdigest()
+
+
+def no_probe_digests() -> dict:
+    """Battery modes on, no refusal, so no probe: a scripted cheap run."""
+    return {
+        "sf_ch": digest(day(SF_CH, refuse=(), hours=1.2)),
+        "ch_ch": digest(day(CH_CH, refuse=(), hours=1.2)),
+        "ch_ch_maint": digest(day(CH_CH, a_maint=MAINT_CHARGE, refuse=(),
+                                  hours=1.2)),
+    }
+
+
+if __name__ == "__main__":
+    for k, v in no_probe_digests().items():
+        print(k, v)

goodwe_controller/tools/ux13_demo.py

@@ -141,6 +141,8 @@ def _node(name, spec):
                    lengthMin=float(m.group(2)), lengthMax=float(m.group(3)))
     elif spec.startswith("list("):
         out.update(type="select", options=spec[5:-1].split("|"))
+    elif spec == "password":
+        out.update(type="string", format="password")
     elif spec in ("bool",):
         out["type"] = "boolean"
     elif spec in ("int", "float"):

goodwe_controller/translations/en.yaml

@@ -165,7 +165,7 @@ configuration:
     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."
+    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."
@@ -199,6 +199,9 @@ configuration:
   price_feed_url:
     name: "Tariff · Price feed URL override"
     description: "Leave it empty to use the source's own feed. An override is sent exactly as typed and often returns only one day."
+  price_service_token:
+    name: "Tariff · Price service token"
+    description: "For the price service only. The token you were given for it. Leave it empty with any other price source."
   price_horizon_h:
     name: "Tariff · Price look-ahead (hours)"
     description: "How many hours of prices to ask the source for."

goodwe_controller/translations/nl.yaml

@@ -146,7 +146,7 @@ configuration:
     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."
+    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."
@@ -180,6 +180,9 @@ configuration:
   price_feed_url:
     name: "Tarief · Afwijkende URL voor de prijsfeed"
     description: "Laat leeg om de eigen feed van de bron te gebruiken. Een afwijkende URL wordt letterlijk verstuurd en geeft vaak maar één dag terug."
+  price_service_token:
+    name: "Tarief · Token van de prijsdienst"
+    description: "Alleen voor de prijsdienst. Het token dat u ervoor kreeg. Laat leeg bij een andere prijsbron."
   price_horizon_h:
     name: "Tarief · Prijzen vooruit (uren)"
     description: "Hoeveel uur aan prijzen de add-on bij de bron opvraagt."