OPT-27 round 2: a kept tomorrow figure is bounded on both sides

Hold.stand_in(): day0 <= now < day0 + 3 h. A tomorrow sensor is asked with
day0 = the next midnight, so the upper bound alone was true all day and a
figure stood in at any hour. test_opt27.py covers daytime tomorrow outages.

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

goodwe_controller/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.19.1
+
+**A patch bump: two fixes for battery modes, and no option changes.**
+No option was added, removed or renamed, and no default changed (86 options).
+**Existing installs need no option change:** options that start 0.19.0 also
+start 0.19.1. The changes below apply with one inverter or two.
+
+**Battery modes now see a day/night or fixed tariff.** With battery modes on, a day/night or fixed tariff and no price service, the batteries never got the prices: "Cheap hours" never charged from the grid at the cheap rate, and the Batteries screen said "No prices". They get them now, with no price service and no internet call added.
+
+**A solar forecast now counts for the price gap.** With battery modes on and a solar forecast read, a price mode needs a gap of at least *Battery cycle cost*, not 1.5 times that. Without a forecast it is still 1.5 times. A day/night gap of 0.08 now works at a cycle cost of 0.07 or less.
+
+Contents of this release, in merge order since 0.19.0 (`793a676`):
+
+| | |
+|---|---|
+| `TARIFF-24` | With battery modes on, the add-on now also resolves the tariff when no price service and no price trading are set, so a day/night or fixed tariff gives the batteries their price runs ([[TARIFF-24]]). With battery modes on and a solar forecast read, the price gap a mode needs is *Battery cycle cost* (widened only for a real-time feed), not 1.5 times that; Home and the Batteries screen use the same rule ([[AUDIT-02]] F1). |
+
+### Known issues
+
+The list under `## 0.19.0` below still applies.
+
+### If you are crossing from a version older than 0.10.0
+
+`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
+withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
+`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
+bare options (`jq '.data.options'`) first.
+
 ## 0.19.0
 
 **A minor bump: price trading behaves differently, plus a fix for a false warning, the Home price chart in 15-minute bars, more Dutch text and EMS-port wording, and no option changes.**

goodwe_controller/DECISIONS/OPT-27-last-fresh-forecast-for-the-night.md

@@ -0,0 +1,43 @@
+# OPT-27 - the night plan keeps the last fresh forecast
+
+**Status: done on `release/1.0`, not released.** Tests: `test_opt27.py`.
+
+**The defect.** A today sensor is stale after 3 h (`FRESH_S`) or when it is from
+before local midnight. Forecast.Solar stops updating in the evening, so at night
+every Forecast.Solar site had no forecast: a price mode's night cheap run needed
+1.5x the cycle cost (TARIFF-24 round 2) and Leftover solar planned nothing.
+Separately, one missed poll (`unavailable`) dropped the forecast at once.
+
+**Where: `solarfc`, not the plan.** The last fresh reading of each sensor is
+kept in `solarfc.Hold` and `read_sum()` uses it when a sensor has none. A hold
+at the plan (`_wx_track`/`weather_held`) can only keep the 1.5x gap off. The
+day plan, Leftover solar's levels, Home and the Forecast tab all read
+`Controller.solar_fc`, so one kept forecast makes control and every screen agree
+(UX-53) with no second rule to keep in step. `weather_held()` is unchanged: it
+still keeps a run under way when a read is lost.
+
+**The rule** (`Hold.stand_in()`). A kept reading is for one day. It covers a
+sensor that is missing or stale, never one with a bad value or unit, and:
+- for up to `FRESH_S` when the sensor is missing: a short outage, any time of day;
+- from the end of the bell (20:00 local, `BELL_TO_H`) until local midnight + 3 h
+  (`KEPT_UNTIL_H`), however old;
+- the day it is for: a today figure only on that day, a tomorrow figure as
+  tomorrow until midnight and, if the today sensors are still stale, as today's
+  until midnight + 3 h (all sensors of the sum are needed, as for any sum);
+- until the next fresh reading, which replaces it at once.
+
+So a figure is never used for another day and never older than one night.
+Daytime is as before: a sensor that stopped is stale after 3 h, and no forecast
+all day is still no forecast (the night run still needs 1.5x).
+
+**Where it is stored.** The controller's store, key `solar_fc_hold`, so an
+evening restart keeps it. It is written when a reading's figure changes or
+every 15 min (`SAVE_EVERY_S`), not on every poll. A damaged entry is dropped.
+
+**The screens.** `Forecast.kept` is true when a reading older than `FRESH_S` is
+in use; the forecast line then reads "Solar forecast read 17:05, used for
+tonight's plan." (`home_words.solar.kept`, EN and NL). The event log says
+"read, kept from 17:05".
+
+**Not changed.** Modes off (nothing reads the sensors). A forecast that stays
+fresh. The hold does not look at the weather, only at the clock and the day.

goodwe_controller/DECISIONS/TARIFF-24-modes-need-the-tariff-task.md

@@ -0,0 +1,66 @@
+# TARIFF-24 - battery modes need the tariff task
+
+**Status: FIXED in 0.19.1 (hotfix from 0.19.0, owner go 2026-10-28).**
+Follows TARIFF-10 (fetching is not trading). Tests: `test_tariff24.py`.
+
+**The defect.** The control cycle gets prices only from
+`Controller.tariff_plan`, which only `run_tariff_refresh()` stores. `amain()`
+starts that task when `tariff_refresh_wanted(opts)`, which was
+`provider_configured(opts) or arbitrage.enabled(opts)`. Battery modes read the
+plan but were not a term. With battery modes on, a day/night or fixed
+`static_profile`, `price_provider: off` and `arbitrage_enabled: false` (the
+site trade switch is not read with modes on) no task ran. Then
+`fresh_tariff_plan()` was None, `_price_runs()` was None and `mode_runs` was
+None, so Leftover solar and Cheap hours never charged from the grid. The
+Batteries screen said "No prices, so it follows the house" while Home priced
+the day from `static_plan()` itself (`homeview.build_plan()`).
+
+**The fix** (`main.py`, `tariff_refresh_wanted()`). `packmode.enabled(opts)`
+is a third term. The gate stays a widening: nothing that started the task
+before stops. No HTTPS call is added: with `price_provider: off`,
+`resolve_tariff()` is the pure `static_plan()`.
+
+**Not changed.** Modes off, arbitrage off, no feed still starts no task. The
+control law, the price runs and every message are untouched.
+
+**One rule, not two.** Gating on "modes on and a static profile" was
+considered. It saves one arithmetic pass every 30 min on a site with modes on
+and no prices at all, and it adds a second condition that has to track what
+`resolve_tariff()` accepts. With no profile and no feed the plan is `no_data`,
+exactly what the cycle sees without the task.
+
+**UX-55.** Home said "no prices have arrived" (`mode_runs` None) with every
+battery on Solar first. The same cause, and this fix clears it for a site with
+a static profile (`test_tariff24.py` part 5). A site with no profile and no
+feed still has no prices, and Home still says so.
+
+## Round 2 (AUDIT-02 F1): the forecast replaces the "no weather" doubt
+
+**Decided 2026-10-28 (owner), in the same hotfix.** The price gap a mode needs
+was `cycle_cost_threshold_eur` x 1.5 (`Uncertainty.NO_WEATHER`) whether or not
+a solar forecast was read. At the shipped cost 0.10 that is 0.15, so a
+day/night gap (0.08) and many dynamic days never traded, and the screens said
+only "Prices differ too little".
+
+**Why the doubt goes with a forecast.** The widening stands in for not knowing
+the weather. The forecast is that knowledge, and the day plan already trusts it
+for how much to charge. Trusting it for the plan but doubting it for the gap
+was one input judged twice.
+
+**The rule** (`arbitrage.weather_uncertainty()`). With battery modes on and a
+usable forecast (`solar_fc` not None, the day plan's own test) the doubt is
+not added: the gap needed is the cycle cost, widened by the price product only.
+No forecast, or a stale or unusable one: 1.5 x, as before. It is read in three
+places that must agree: the run plan (`_price_runs()`), the charge gate
+(`_mode_roles()`) and Home's mirror (`homeview.trade_verdict()`). The forecast
+is read at most every 60 s and the plan key already holds "forecast or not", so
+the gap follows in the cycle the read changes, both ways, with one exception:
+a run planned with a forecast that is under way keeps that gap to its end
+(`Controller.weather_held()`), so a sensor that goes unavailable does not stop
+or restart a charge. The wider gap applies from the next run.
+
+**Not changed.** Modes off (the site trade) keeps the doubt always. The
+shipped cost 0.10 still needs a gap of 0.10 even with a forecast: a 0.08
+day/night site must set *Battery cycle cost* to 0.08 or less. Showing the two
+numbers on the screens (AUDIT-02 F1 option b) is a separate card.
+

goodwe_controller/DECISIONS/UX-54-forecast-tab.md

@@ -0,0 +1,146 @@
+# UX-54 - a Forecast tab: the sun, the house and each battery's level, per hour
+
+**Status: DONE 2026-10-26 (owner go 2026-10-26: "Day curve", "New tab").**
+
+## Decision
+
+A tab beside Home and Batteries shows today and tomorrow, per hour: the solar
+forecast, the solar measured so far, the house's expected use and each
+battery's expected level with its blocks. It follows the add-on, as Home does
+(UX-53), and decides nothing.
+
+- **Blocks are Home's.** Today's are the `runs` of the same plan Home draws
+  (grid, give, monthly cycle). Tomorrow's come from the same builders
+  (`homeview.runs_for()`). The words are the plan lines'. A block is on the tab
+  exactly where Home has one, so the UX-53 gate is followed too.
+- **Tomorrow is read ahead.** Home sizes a block from the battery's level now
+  and draws none when there is no room or energy (`room()` and `plan_need()`
+  in `homeview.mode_runs()`, the leg sizing in `trade_runs()`). For a day that
+  has not started that level says nothing, so tomorrow's blocks are built with
+  `ahead` (Home never passes it): `mode_runs()` reads each block at the level
+  the curve has when it starts, with its own filter and `MIN_KWH`, so there is
+  no give block where the battery is at the floor and no grid block where it
+  is at its planned level. Where the curve has no level yet, a charge is read
+  from the floor and a give from the ceiling. The blocks and the curve follow
+  each other and are taken to a fixed point. The gate (`mode_gate`, UX-53) is
+  not bypassed.
+- **Modes off has no curve** (no forecast is read, no house profile kept), so
+  `trade_runs(ahead=f)` reads each leg at Home's own count
+  (`dayview._counted()`): the level now, plus what the blocks before it put in,
+  less what they take out. No sun is read and the house only takes, so no give
+  block where the emptiest battery is at the floor by that count, and control
+  does not give there. A charge is read from the floor: a full battery covers
+  the house before the cheap hour, and control charges it back then. Walked
+  every 15 minutes on a cloudy day, the packs moved by control and a 400 W
+  house (`test_ux54.py` part 7, cases A-D, one price quarter per leg),
+  control charges and gives in exactly the quarters the tab has a block.
+- **A block lasts as long as control acts.** A cheap run is sized for all the
+  batteries charging together, so a slower one is still below
+  `modetrade.charge_to()` when it ends, and control plans the next cheap slots
+  (`Controller._price_runs()`). `dayview._levels()` asks the same functions,
+  `modetrade.energy()` and `priceruns.plan()`, with the packs at the curve's
+  level, and draws the grid block to where control stops. Each battery's block
+  then ends where the curve has it at its own level, and a give block where
+  it reaches the floor: the curve puts a point at both (`daycurve.curve()`
+  cuts the step there), and the block ends at the first point where the level
+  the tab shows (0.1 %) is there. What is proven: control walked every 15
+  minutes through tomorrow with its own model of the packs, not the curve's
+  levels (`_mode_roles()` each quarter; the house from the profile, the sun
+  at 100 % trust, a GIVE role counted only where control's own discharge
+  envelope `packshare.envelope()` is open, the cut-out at the floor), charges
+  and gives in exactly the quarters the tab has a block in 13 cases
+  (`test_ux54.py` part 7, `own_walk()`), e.g. 25/45 % with the peak guard:
+  control gives 17:00-20:15, the block is 17:00-20:06; 30/80 % with a 7 kW
+  evening house, B held to its rating: control 17:00-19:45, the block
+  17:00-19:32. The floor point is placed in one cut, where the battery runs
+  out at the rate it gives (`_floor_cut()`, checked to the second against
+  times worked out by hand), so a build stays small: at most 14 floor cuts
+  and 28 level points per battery and day in those cases. With a cut-out under
+  the floor, or a house or sun that differs from the forecast and profile,
+  control differs (Limits).
+- **The sun** is what `solarfc` reads. An hourly split (Solcast
+  `detailedForecast`, Open-Meteo `wh_period`) is used as given. A daily total
+  (Forecast.Solar, and any other state-only sensor, the owner's three "today
+  remaining" and three "tomorrow") is spread over the 06:00-20:00 bell, and the
+  tab says so.
+- **The house** is `HouseProfile.estimator()`, never below the night median, as
+  the plan reads it.
+- **The level did not exist** (the plan holds targets and run blocks only), so
+  `daycurve.curve()` derives it: each battery has the role `modetrade.decide()`
+  gives (follow the house, hold, give, charge from the grid, rest), spare solar
+  goes to Solar first batteries first, a shortfall is met by those that may
+  give, shared as control shares it (by what each holds above the floor,
+  `packshare.weights()`, each at most its rating, the rest passed on), both
+  at `dayplan.EFF`, inside the plan's floor and ceiling, from the
+  level now. Spare solar is `trust x max(0, sun - house)` and what is stored
+  loses `EFF`, the plan's own `trust x EFF x max(0, sun - house)` (10 kWh of
+  sun, 2 kWh of house, 70 %: 5.32 kWh stored). A shortfall is not scaled by
+  trust. The tab says it counts on `solar_trust_pct`. Grid charging goes to
+  `modetrade.charge_to()`. It is an estimate.
+- **Measured solar** is kept per local hour in memory (`SolarToday`), from the
+  reading the control cycle already takes; nothing is read back.
+- **On request.** `GET forecast` builds the tab (`Controller.forecast_payload()`
+  reads `/status`' plan first, so today's blocks are the very ones Home has). No
+  Home Assistant call, nothing cached, nothing in the cycle but one in-memory
+  add. The page asks every 30 s while the tab shows.
+- **Not known yet is a note, not an empty chart:** modes off, no forecast set,
+  forecast missing or old, learning, no tomorrow forecast, a monthly cycle, no
+  level reading, control stopped, shadow.
+
+## What does not change
+
+No decision, command, timing or option key. The one write in the control path
+is `SolarToday.add()` after the solar read, in a `try`, in memory.
+
+## Limits
+
+- Prices are planned about a day ahead (`priceruns.HORIZON`), so a block of
+  tomorrow later than 24 h from now, or one that needs prices not yet
+  published, appears as the day comes near. The tab says so.
+- Today's blocks are Home's, and are not extended or shortened: control may
+  plan more once they end, and Home draws it then. The curve stops charging
+  at its level (`charge_to()`) and giving at the floor.
+- Today, a give run in the plan on a battery that is empty now has no block on
+  Home (no energy to give). The tab equals Home, and says so: "The add-on plans
+  to give power. No block shows while a battery has no energy to give." The
+  curve gives in that run if the sun fills the battery first.
+- With no forecast for tomorrow the curve stops at the first hour of the sun,
+  `solarfc.BELL_FROM_H` (06:00): `Forecast.between()` has no answer past it. The
+  note names that hour from the constant.
+- Tomorrow shows price blocks only. A monthly cycle is drawn today, where the
+  curve then stops for that battery.
+- The curve uses the arbitrage floor and ceiling, as the plan does, not the
+  battery's own cut-out level. Control stops a pack at its cut-out, so with a
+  cut-out under the floor a battery in a give run covers the house below the
+  floor; Home draws no block there either. The house profile is a median per
+  hour, net of the solar the house used.
+- Modes off: the count knows no sun and no house. A battery at the floor that
+  the sun fills before a give gets no block until then (the tab says "The
+  add-on plans to give power. No block shows while a battery has no energy to
+  give."), and a small charge may be used by the house before the give. The
+  other way round, a charge is drawn even when the sun fills the batteries
+  before it: at the ceiling control then takes none (a cheap quarter at 13:00
+  on a sunny day: the tab draws the charge, control charges nothing at 95 %
+  or 100 %).
+  A leg is the verdict's as it stands now, one price period, as on Home; with
+  several equal prices in a row control takes the next one as each passes.
+- Measured solar starts when the add-on starts; the tab says from when.
+- Clock changes: the tab walks local hours with `dayplan._hour_slices()`,
+  which steps in UTC (SAFETY-123), and keys measured solar by the start of
+  the local hour taken back from the UTC instant, so the spring day has 23
+  hours, the autumn day 25 (two of them 02:00), and a request always returns
+  (`test_ux54_dst.py`, every quarter of both change days, with and without
+  tzdata). The solar bell is spread over hours from local midnight, so on
+  those two days it is an hour off the clock (SAFETY-123, not changed here).
+
+## Found, not changed
+
+`dayplan.plan()` reads the forecast hour by hour with `Forecast.between(s, e)`.
+For a state-only forecast `between()` takes its start as the moment the "left
+today" figure was read, so each later hour is spread over what is left of the
+bell from that hour: on the owner's shape 14.4 kWh left gives 57 kWh over the
+hours to midnight (`test_ux54.py` part 1). The plan's sun is overcounted for
+those sites. It does not show on a site whose batteries are all Solar first
+(no level is planned for them). The tab measures both ends from now
+(`dayview.sun_kwh()`), which keeps the total and gives the same hours for an
+hourly split. A card should fix the plan.

goodwe_controller/DOCS.md

@@ -538,7 +538,7 @@ With battery modes on, these choices replace the *Charging and selling on price*
 
 **Cheap and expensive hours.** They come from the published day-ahead prices, as runs of consecutive 15-minute periods, not a single period.
 - The cheap run is the cheapest stretch long enough to fill the batteries that may charge, at their power.
-- An expensive hour costs at least *Battery cycle cost* (`cycle_cost_threshold_eur`, widened as for trading) more than the cheap run. The batteries hold their power until then.
+- An expensive hour costs more than the cheap run by at least *Battery cycle cost* (`cycle_cost_threshold_eur`) when a solar forecast is read, and by 1.5 times that when none is (a real-time price feed widens it further). The batteries hold their power until then.
 - The sale uses the most expensive stretch inside those hours, and never a period below 0.
 - A carried (not yet published) price is never used. A run that has started runs to its end.
 - With no prices, or too small a gap, every battery follows the house.
@@ -555,6 +555,7 @@ With battery modes on, these choices replace the *Charging and selling on price*
 - The plan is checked every 15 minutes. A planned level moves only by 1 kWh or 10 %, so a wobbling forecast does not flip it.
 - No forecast, one older than 3 hours or from before midnight, or no house use yet: *Leftover solar* takes solar only and *Cheap hours only* fills to the top level. The Batteries screen says so.
 - A battery needs its capacity (`inverters.capacity_kwh`) for a plan.
+- **At night.** Some forecasts stop updating in the evening (Forecast.Solar does). The add-on keeps the last reading of each sensor and uses it for that night's plan: from 20:00 until 03:00, or until a newer reading comes. A sensor that is missing for up to 3 hours is covered the same way. A figure is never used for another day, and never older than that night. The Batteries screen says "Solar forecast read 17:05, used for tonight's plan." With no reading all day, the night run still needs the wider gap.
 
 **What always comes first.**
 - The peak limit, the safety stops and the monthly cycle come before a battery's mode.
@@ -3530,6 +3531,21 @@ the peak limit, the batteries' switches and modes, and shadow mode, each
 marked "Applies right away" or "Applies after a restart". **Installer** shows
 every setting.
 
+### The Forecast screen
+
+The **Forecast** tab shows today and tomorrow, hour by hour: the solar forecast,
+the solar measured so far today, the house's expected use, and each battery's
+expected level. Under each battery's chart are its planned blocks, in the same
+words as Home. A block is there only where the add-on plans one.
+
+The level is an estimate. It counts on `solar_trust_pct` of the forecast, as the
+plan does, and stays between the battery's low and high levels. A forecast that
+gives one total for the day (Forecast.Solar) is spread over the hours, and the
+screen says so. Where a part is not known yet (battery modes off, no forecast,
+still learning your house, no forecast for tomorrow) the screen says that
+instead of drawing an empty chart. It changes nothing in control, and it asks
+Home Assistant for nothing: it is built when you open it.
+
 ### Setup, for a new install
 
 The **Setup** tab walks an installer through six steps: the meter, the

goodwe_controller/app/arbitrage.py

@@ -147,7 +147,7 @@ from dataclasses import dataclass
 from datetime import datetime
 
 from .arbiter import ACTUATOR_SITE, P_ARBITRAGE, Claim
-from .price import Absence, price_option
+from .price import Absence, Uncertainty, price_option
 
 _LOG = logging.getLogger("goodwe.arbitrage")
 
@@ -267,6 +267,21 @@ def threshold_eur_kwh(opts: dict) -> float:
     return v
 
 
+def weather_uncertainty(modes_on: bool, solar_fc, held: bool = False) -> frozenset:
+    """The "no weather" doubt (x1.5) a trade must clear. TARIFF-24.
+
+    Battery modes read a solar forecast; with one read (`solar_fc` not None) the
+    doubt is gone, and `held` (a run planned with a forecast is under way, see
+    `Controller.weather_held()`) keeps it gone until that run ends. Everything
+    else, and the modes without a forecast, keep it. One rule for the run plan,
+    the charge gate and Home's mirror. See
+    DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
+    """
+    if modes_on and (solar_fc is not None or held):
+        return frozenset()
+    return frozenset({Uncertainty.NO_WEATHER})
+
+
 def soc_bounds(opts: dict) -> tuple:
     """(floor, ceiling) in percent. The reserve arbitrage may not spend."""
     return (float(price_option(opts, "arbitrage_soc_floor")),

goodwe_controller/app/daycurve.py

@@ -0,0 +1,293 @@
+"""UX-54: the expected battery level through the day, for the Forecast tab.
+
+Pure: batteries, the sun and the house's use in; a level per battery over
+time out. Display only: nothing here is read by control, and it never
+decides a block. The blocks are the plan's (`homeview.mode_runs()`); this
+only says where the level goes, hour by hour, if the add-on does what the
+plan says.
+
+Each step gives every battery a role, as `modetrade.decide()` does (the
+names are modetrade's): in a grid block it charges (CHARGE) and the others
+rest (REST, no charge); else it follows the house (HOUSE) if it is Solar
+first or no price plan is on; inside a give run it covers the house (GIVE);
+else it holds (HOLD, may charge from spare solar, gives nothing). Spare
+solar (sun less the house's use) goes to Solar first batteries first, then
+the rest, by room. A shortfall comes from the batteries that may give,
+those in a give run first, by what they hold above the floor, each at most
+its rating, the rest passed on (as control shares it, `packshare.weights()`
+and the allocator's fill). A battery that empties inside a step gets a
+point there (`_floor_cut()`), as one that reaches its grid level does.
+Charging and giving lose `dayplan.EFF`, as the plan counts. A level stays
+inside the floor and ceiling the plan uses, and a battery already outside
+them does not move further out.
+
+`SolarToday` keeps the site's measured solar per hour, in memory, from the
+reading the control cycle already has. It is shown and never read back
+(TEL-11 keeps site solar out of control).
+"""
+
+import math
+from datetime import datetime, timedelta, timezone
+from dataclasses import dataclass
+
+from .dayplan import EFF, _hour_slices, _local
+from .modetrade import CHARGE, GIVE, HOLD, HOUSE, REST
+
+EPS = 1e-9
+MIN_CUT = timedelta(seconds=1)      # no step is cut closer to its ends
+MAX_FLOOR_CUTS = 400        # a bound on the floor cuts of one curve
+GAP_S = 60.0                # a longer gap between readings is not counted
+MIN_COVER = 0.5             # share of the elapsed hour a reading must cover
+
+
+@dataclass(frozen=True)
+class Batt:
+    """One battery that is on, with a level and a capacity."""
+    name: str
+    capacity_kwh: float
+    rating_kw: float
+    soc: float                  # % now
+    solar_first: bool           # Solar first: follows the house all day
+    priced: bool                # a price plan is on and its mode is a price mode
+    grid: tuple = ()            # ((start, end, to_pct), ...) grid blocks
+    give: tuple = ()            # ((start, end), ...) give runs
+    stop_at: datetime | None = None    # a monthly cycle starts: no level after
+
+
+def _role(b, t, charging, own):
+    """The battery's role at instant `t`; `own`: it charges from the grid;
+    `charging`: some battery does. Returns `(role, may_charge, may_give)`."""
+    in_give = any(s <= t < e for s, e in b.give)
+    if own:
+        return CHARGE, False, False
+    if charging:
+        return REST, False, b.solar_first or not b.priced or in_give
+    if b.solar_first or not b.priced:
+        return HOUSE, True, True
+    if in_give:
+        return GIVE, True, True
+    return HOLD, True, False
+
+
+def _spread(amount, caps, weights):
+    """Split `amount` over the keys of `caps` by `weights`, none over its
+    cap. Returns `(taken, left)`: what each took and what no one could."""
+    got = {k: 0.0 for k in caps}
+    left = float(amount)
+    live = {k for k, c in caps.items() if c > EPS and weights.get(k, 0.0) > 0}
+    while left > EPS and live:
+        total = sum(weights[k] for k in live)
+        used, full = 0.0, set()
+        for k in live:
+            part = left * weights[k] / total
+            room = caps[k] - got[k]
+            if part >= room - EPS:
+                part = room
+                full.add(k)
+            got[k] += part
+            used += part
+        left -= used
+        if not full:
+            break
+        live -= full
+    return got, max(0.0, left)
+
+
+def _give_caps(roles, level, by, floor, hrs):
+    """`(first, rest, held)`: what each battery that may give can give in a
+    step of `hrs` hours (its rating, or what it holds above the floor), those
+    in a give run first, and what each holds above the floor (as given)."""
+    held = {n: max(0.0, level[n] - floor) / 100.0 * by[n].capacity_kwh * EFF
+            for n, r in roles.items() if r[2]}
+    caps = {n: min(by[n].rating_kw * hrs, h) for n, h in held.items()}
+    first = {n: c for n, c in caps.items() if roles[n][0] == GIVE}
+    return first, {n: c for n, c in caps.items() if n not in first}, held
+
+
+def _floor_cut(a, z, net, roles, level, by, floor, hrs):
+    """Where in the step `[a, z)` the first battery that gives reaches the
+    floor, or None. The shortfall comes at a steady rate, `-net / hrs` kW.
+    It is shared as control shares it (`packshare.weights()`: by the energy
+    each holds above its cut-out, here the floor), each at most its rating,
+    what one cannot take passed to the others, those in a give run first.
+    A battery giving `v` kW that holds `h` kWh is empty at `h / v` hours; a
+    cut there makes the step come out exact. A battery already at the floor
+    holds nothing, gives nothing and never sets a cut."""
+    rate, cut = -net / hrs, None
+    *groups, held = _give_caps(roles, level, by, floor, hrs)
+    for grp in groups:
+        rates, rate = _spread(rate, {n: by[n].rating_kw for n in grp},
+                              {n: held[n] for n in grp})
+        for n, v in rates.items():
+            if held[n] > EPS and v > EPS:
+                t = a + timedelta(hours=held[n] / v)
+                if a + MIN_CUT < t < z - MIN_CUT and (cut is None
+                                                      or t < cut):
+                    cut = t
+    return cut
+
+
+def curve(batts, start, end, sun_kwh, use_kwh, *, floor_pct, ceiling_pct,
+          trust=1.0, stats=None):
+    """`{name: [(t, pct), ...]}` from `start` (each battery's level now) to
+    `end`, a point at every hour edge, every block edge and where a battery
+    reaches its grid level or, giving, the floor. A battery's list
+    stops where `sun_kwh(a, b)` is None (the sun is not known) or its
+    `stop_at` comes. `sun_kwh` and `use_kwh` give kWh for the span `[a, b)`.
+    Spare solar is `trust x max(0, sun - use)`, and what is stored loses
+    `EFF`: `dayplan.plan()`'s own `trust x EFF x max(0, sun - house)`. A
+    shortfall is the house's use less the whole sun. `stats`, a dict or
+    None: gets `floor_cuts` (the floor points placed) and `capped` (True when
+    `MAX_FLOOR_CUTS` stopped one)."""
+    floor, ceil = float(floor_pct), float(ceiling_pct)
+    cuts = {end}
+    for a, _b, _h in _hour_slices(start, end):
+        cuts.add(a)
+    for b in batts:
+        for s, e, *_ in b.grid + b.give:
+            cuts.update(x for x in (s, e) if start < x < end)
+    cuts.add(start)
+    ts = sorted(cuts)
+    level = {b.name: float(b.soc) for b in batts}
+    out = {b.name: [(start, level[b.name])] for b in batts}
+    alive = {b.name for b in batts}
+    floor_cuts, capped = 0, False
+    i = 0
+    while i < len(ts) - 1:
+        a, z = ts[i], ts[i + 1]
+        if not alive:
+            break
+        sun = sun_kwh(a, z)
+        if sun is None:
+            break
+        for b in batts:
+            if b.name in alive and b.stop_at is not None and a >= b.stop_at:
+                alive.discard(b.name)
+        net = sun - use_kwh(a, z)
+        if net > 0.0:
+            net *= trust
+        hrs = (z - a).total_seconds() / 3600.0
+        want = {}                                # name -> grid target %
+        for b in batts:
+            if b.name in alive:
+                for s, e, to in b.grid:
+                    if s <= a < e and level[b.name] < to - EPS:
+                        want[b.name] = float(to)
+        by = {b.name: b for b in batts}
+        # A battery that reaches its level inside the step gets a point
+        # there: the step is cut and read again, so the line is exact.
+        cut = None
+        for n, to in want.items():
+            b = by[n]
+            room = (to - level[n]) / 100.0 * b.capacity_kwh
+            rate = b.rating_kw * hrs * EFF
+            if EPS < room < rate * (1.0 - 1e-9):
+                t_r = a + (z - a) * (room / rate)
+                if a < t_r < z and (cut is None or t_r < cut):
+                    cut = t_r
+        if cut is not None:
+            ts.insert(i + 1, cut)
+            continue
+        roles = {b.name: _role(b, a, bool(want), b.name in want)
+                 for b in batts if b.name in alive}
+        # A battery that gives all it holds inside the step gets a point
+        # where it reaches the floor, the same way.
+        cut = _floor_cut(a, z, net, roles, level, by, floor, hrs) \
+            if net < -EPS else None
+        if cut is not None and floor_cuts >= MAX_FLOOR_CUTS:
+            capped, cut = True, None
+        if cut is not None:
+            floor_cuts += 1
+            ts.insert(i + 1, cut)
+            continue
+        for n, to in want.items():              # charging from the grid
+            b = by[n]
+            room = (to - level[n]) / 100.0 * b.capacity_kwh
+            level[n] += min(b.rating_kw * hrs * EFF, room) \
+                / b.capacity_kwh * 100.0
+        if net > EPS:
+            caps = {n: min(by[n].rating_kw * hrs,
+                           max(0.0, ceil - level[n]) / 100.0
+                           * by[n].capacity_kwh / EFF)
+                    for n, r in roles.items() if r[1]}
+            first = {n: c for n, c in caps.items() if by[n].solar_first}
+            rest = {n: c for n, c in caps.items() if n not in first}
+            left = net
+            for grp in (first, rest):
+                got, left = _spread(left, grp, dict(grp))
+                for n, v in got.items():
+                    level[n] += v * EFF / by[n].capacity_kwh * 100.0
+        elif net < -EPS:
+            first, rest, held = _give_caps(roles, level, by, floor, hrs)
+            left = -net
+            for grp in (first, rest):
+                got, left = _spread(left, grp, {n: held[n] for n in grp})
+                for n, v in got.items():
+                    level[n] -= v / EFF / by[n].capacity_kwh * 100.0
+        for b in batts:
+            if b.name in alive:
+                out[b.name].append((z, level[b.name]))
+        i += 1
+    if stats is not None:
+        stats["floor_cuts"] = stats.get("floor_cuts", 0) + floor_cuts
+        stats["capped"] = stats.get("capped", False) or capped
+    return out
+
+
+# --------------------------------------------------------------------------- #
+# Measured solar, per local hour
+# --------------------------------------------------------------------------- #
+class SolarToday:
+    """The site's solar power, averaged per local hour of one local day. In
+    memory only: a restart starts it again, and `first` says from when it
+    has counted. Display only."""
+
+    def __init__(self):
+        self.day = None
+        self.first = None
+        self._hours = {}            # hour start (UTC) -> [W x s, seconds]
+        self._last = None           # (time, W)
+
+    def add(self, now: datetime, w) -> None:
+        """One reading (`None`: no reading, which ends the interval)."""
+        day = _local(now).date()
+        if day != self.day:
+            self.day, self.first, self._hours, self._last = day, None, {}, None
+        try:
+            ok = w is not None and math.isfinite(float(w))
+        except (TypeError, ValueError):
+            ok = False
+        if not ok:
+            self._last = None
+            return
+        w = max(0.0, float(w))
+        if self.first is None:
+            self.first = now
+        if self._last is not None and now > self._last[0]:
+            dt = min(GAP_S, (now - self._last[0]).total_seconds())
+            key = _hour_start(self._last[0])
+            row = self._hours.setdefault(key, [0.0, 0.0])
+            row[0] += (self._last[1] + w) / 2.0 * dt
+            row[1] += dt
+        self._last = (now, w)
+
+    def kwh(self, start: datetime, end: datetime, now: datetime):
+        """kWh for the hour `[start, end)` up to `now`: the mean power it was
+        read at over the part of the hour that has passed, or None when the
+        readings cover under half of that part (or none has passed)."""
+        if self.day != _local(now).date():
+            return None
+        over = (min(end, now) - start).total_seconds()
+        row = self._hours.get(start)
+        if over <= 0 or row is None or row[1] < MIN_COVER * over:
+            return None
+        return row[0] / row[1] * over / 3.6e6
+
+
+def _hour_start(t: datetime) -> datetime:
+    """The start of `t`'s local hour, in UTC. Taken back from the UTC instant,
+    never from the wall clock, so each of the two 02:00 hours of the autumn
+    change has its own (`dayplan._hour_slices()`, SAFETY-123)."""
+    lt = _local(t)
+    return t.astimezone(timezone.utc) - timedelta(
+        minutes=lt.minute, seconds=lt.second, microseconds=lt.microsecond)

goodwe_controller/app/dayview.py

@@ -0,0 +1,449 @@
+"""UX-54: the Forecast tab, built on request (`GET forecast`). Reads only.
+
+Two days, today and tomorrow, per local hour: the solar forecast, the solar
+measured so far, the house's expected use, and each battery's expected level
+with its blocks.
+
+It follows the add-on, as Home does (UX-53), and decides nothing:
+* the blocks are Home's own: today's are the `runs` of `/status`'s plan, and
+  tomorrow's come from the same builders (`homeview.runs_for()`), so a block
+  is on the tab exactly where the plan has one, with the plan's words;
+* the sun is `solarfc.Forecast.between()` and the house's use is
+  `dayplan.HouseProfile.estimator()` read as `dayplan.plan()` reads it;
+* the level is `daycurve.curve()`, fed the blocks, the give runs, the packs
+  and the plan's levels (`modetrade.charge_to()`), floor and ceiling.
+A part that is not known yet is a plain note (`home_words.day`), never an
+empty chart. DECISIONS/UX-54-forecast-tab.md has the record.
+"""
+
+import dataclasses
+from datetime import datetime, timedelta
+
+from . import arbitrage, dayplan, homeview as hv, modetrade, priceruns
+from . import solarfc
+from .daycurve import Batt, curve
+from .packmode import SOLAR_FIRST
+from .price import Uncertainty, brussels, required_spread, uncertainty_of
+
+BLOCKS = ("grid", "give", "cycle")      # the kinds a battery's blocks carry
+LEVEL_DP = 1                            # the tab shows a level to 0.1 %
+
+
+def _hours_between(a, b) -> float:
+    return (b - a).total_seconds() / 3600.0
+
+
+def build(c, status: dict, now: datetime, lang: str = "en") -> dict:
+    """The tab's JSON. `status` is the `/status` payload just built, whose
+    plan holds today's blocks."""
+    with hv.in_lang(lang):
+        return _build(c, status, now)
+
+
+def sun_kwh(fc, now, a, b):
+    """kWh the forecast gives in `[a, b)`, `a` at or after `now`, or None.
+    Both ends are measured from `now`: `Forecast.between()` reads its start
+    as the moment the "left today" figure was taken, so a span that starts
+    later would be spread over what is left of the bell, not over its own
+    hours (state-only forecasts, DECISIONS/UX-54-forecast-tab.md)."""
+    hi, lo = fc.between(now, b), fc.between(now, a)
+    return None if hi is None or lo is None else max(0.0, hi - lo)
+
+
+def _times(run):
+    return (datetime.fromisoformat(run["start"]),
+            datetime.fromisoformat(run["end"]))
+
+
+def _build(c, status, now):
+    plan, rows = status.get("plan"), status.get("batteries")
+    if not plan or rows is None:
+        return {"ok": False}
+    d0, d1 = hv.local_day(now)
+    n0, n1 = hv.local_day(d1 + timedelta(hours=2))
+    shadow = bool(c.shadow)
+    key = plan.get("verdict_key")
+    running = key not in ("held", "stopped")
+    modes_on = bool(getattr(c, "modes_on", False))
+    floor, ceil = arbitrage.soc_bounds(c.o)
+    fc = getattr(c, "solar_fc", None)
+    hp = getattr(c, "house_profile", None)
+    est = hp.estimator() if hp is not None and fc is not None else None
+    trust = max(0.0, min(1.0, float(getattr(c, "solar_trust_pct", 70))
+                         / 100.0))
+
+    # Why a part is not known (None: nothing is missing).
+    missing = ("modes_off" if not modes_on
+               else "not_set" if c.fc_entity is None
+               else "no_forecast" if fc is None
+               else "learning" if est is None else None)
+
+    # The blocks of each day: today's from Home, tomorrow's by its builders.
+    # Tomorrow has not started, so the level now says nothing about it: the
+    # builders read each block at the level it starts at (`ahead`), with
+    # their own room and energy filter. With modes on that level is the
+    # curve's (`_levels()`); with modes off there is no curve, and it is
+    # Home's own count (`_counted()`).
+    runs = [plan["runs"], []]
+    if running and not modes_on:
+        runs[1] = _off_tomorrow(c, runs[0], now, shadow, n0, n1)
+    elif running:
+        runs[1] = hv.runs_for(c, n0, n1, now, shadow, ahead=True)
+
+    # The level curve of every battery that is on and known. It also makes
+    # tomorrow's blocks again at the level each has when its run starts, and
+    # draws a grid block as long as control keeps charging (`_levels()`).
+    notes_b = {}
+    levels = {}
+    if running and missing is None:
+        levels, runs = _levels(c, est, fc, trust, now, n1, runs, floor, ceil,
+                               notes_b, shadow, n0, n1)
+    blocks = [[[r for r in rs if r["battery"] == i and r["kind"] in BLOCKS]
+               for i in range(len(c.inverters))] for rs in runs]
+    # Prices are planned about a day ahead (`priceruns.HORIZON`), so tomorrow's
+    # blocks may be missing now and appear later.
+    priced = bool(plan.get("has_prices")) and (
+        any(c.pack_mode(i).use and c.pack_mode(i).mode in hv.PRICE_MODES
+            for i in c.inverters) if modes_on else arbitrage.enabled(c.o))
+    days = []
+    for k, (a, z) in enumerate(((d0, d1), (n0, n1))):
+        days.append(_day(c, k, a, z, now, fc, est, trust, levels, blocks[k],
+                         rows, shadow, running, key, missing, notes_b, status,
+                         priced))
+    return {"ok": True, "running": running, "shadow": shadow,
+            "now_h": round(_hours_between(d0, now), 3),
+            "updated": None if fc is None else hv.hhmm(fc.at),
+            "days": days}
+
+
+def _levels(c, est, fc, trust, now, end, runs, floor, ceil, notes_b, shadow,
+            n0, n1):
+    """`({name: [(t, pct), ...]}, runs)`: `daycurve.curve()` for the batteries
+    that are on, have a level and are not in their monthly cycle, and `runs`
+    with tomorrow's blocks made as control will meet them.
+
+    Tomorrow's blocks are `homeview.mode_runs()`'s, read at the level the
+    curve has when each block starts (its `ahead` function), so its own room
+    and energy filter and `MIN_KWH` decide: no give block where the battery
+    is at the floor when the run starts, no grid block where it is at its
+    planned level. The curve in turn follows the blocks, so the two are taken
+    to a fixed point.
+
+    A cheap run is sized for all the batteries charging together, so a slower
+    one is still below `modetrade.charge_to()` when it ends, and control then
+    plans the next cheap slots (`Controller._price_runs()`). That is asked of
+    the same functions, `modetrade.energy()` and `priceruns.plan()`, with the
+    packs at the curve's level, and the block is drawn to where control
+    stops charging. Today's blocks are Home's, as they are."""
+    packs = {p.name: p for p in c._mode_packs()}
+    targets = c.plan_targets()
+    rp = getattr(c, "mode_runs", None)
+    plan_on = rp is not None and rp.on
+    house_w, base_w = est
+
+    def make(rs):
+        batts = []
+        for i, inv in enumerate(c.inverters):
+            pm = c.pack_mode(inv)
+            if not pm.use:
+                continue
+            if inv.soc is None or not inv.capacity_kwh:
+                notes_b[inv.name] = hv.day_note("no_level", name=inv.name)
+                continue
+            mine = [r for day in rs for r in day
+                    if r["battery"] == i and r["kind"] in BLOCKS]
+            cyc = [_times(r)[0] for r in mine if r["kind"] == "cycle"]
+            if cyc and min(cyc) <= now:
+                notes_b[inv.name] = hv.day_note("cycle", name=inv.name)
+                continue
+            if cyc:
+                notes_b[inv.name] = hv.day_note("cycle", name=inv.name)
+            to = modetrade.charge_to(packs[inv.name], ceil, targets)
+            grid = tuple((*_times(r), to) for r in mine
+                         if r["kind"] == "grid" and to is not None)
+            priced = plan_on and pm.mode != SOLAR_FIRST
+            give = tuple((g.start, g.end) for g in rp.give) if priced else ()
+            batts.append(Batt(inv.name, float(inv.capacity_kwh),
+                              inv.max_w / 1000.0, float(inv.soc),
+                              pm.mode == SOLAR_FIRST, priced, grid, give,
+                              min(cyc) if cyc else None))
+        return batts
+
+    def sun(a, z):
+        return sun_kwh(fc, now, a, z)
+
+    def use(a, z):
+        return sum(max(house_w(h), base_w) * _hours_between(s, e) / 1000.0
+                   for s, e, h in dayplan._hour_slices(a, z))
+
+    def run(rs):
+        batts = make(rs)
+        return curve(batts, now, end, sun, use, floor_pct=floor,
+                     ceiling_pct=ceil, trust=trust) if batts else {}
+
+    def settle(ext, lv):
+        """Tomorrow's blocks read at the levels of `lv`, and the curve they
+        make, again until the blocks stop changing."""
+        seen = None
+        for _ in range(4):
+            def at(name, _kind, start, lv=lv):
+                return _level_at(lv.get(name, ()), start)
+            rt = hv.runs_for(c, n0, n1, now, shadow, ahead=at, rp=ext)
+            lv = run([runs[0], rt])
+            sig = [(r["battery"], r["kind"], r["start"], r["end"])
+                   for r in rt]
+            if sig == seen:
+                break
+            seen = sig
+        return rt, lv
+
+    lv0 = run([runs[0], []])
+    ext = rp
+    plan = c.fresh_tariff_plan(now)
+    cheap = None if rp is None else rp.cheap
+    end_t = None
+    if plan_on and cheap is not None and rp.charge_useful() \
+            and n0 <= cheap.start < n1 and plan is not None:
+        required = required_spread(
+            arbitrage.threshold_eur_kwh(c.o),
+            uncertainty_of(plan.read.product) | {Uncertainty.NO_WEATHER})
+        end_t = cheap.end
+        for _ in range(24):
+            ext = dataclasses.replace(rp, cheap=priceruns.Run(
+                cheap.start, end_t, cheap.mean_eur_kwh))
+            rt, lv = settle(ext, lv0)
+            at_end = [dataclasses.replace(packs[n], soc=v)
+                      for n, v in ((n, _level_at(lv.get(n, ()), end_t))
+                                   for n in lv) if v is not None]
+            e = modetrade.energy(at_end, floor, ceil, targets=targets)
+            if e[0] <= 1e-6:
+                break
+            new = priceruns.plan(
+                plan.read.points, end_t, required_eur_kwh=required,
+                charge_kwh=e[0], charge_kw=e[1], sell_kwh=0.0, sell_kw=0.0)
+            nxt = new.cheap
+            if nxt is None or not new.charge_useful() or nxt.start > end_t \
+                    or nxt.end <= end_t:
+                break
+            end_t = nxt.end
+        ext = dataclasses.replace(rp, cheap=priceruns.Run(
+            cheap.start, end_t, cheap.mean_eur_kwh))
+    rt, lv = settle(ext, lv0)
+    # A run is for all the batteries charging together; each stops when it is
+    # at its own level (control's `chargers()`), so its block ends there.
+    names = [inv.name for inv in c.inverters]
+    rt = [_stops(r, names, lv, packs, targets, floor, ceil, n0) for r in rt]
+    return lv, [runs[0], rt]
+
+
+def _off_tomorrow(c, today, now, shadow, n0, n1):
+    """Modes off: tomorrow's blocks by `homeview.trade_runs()`, each read at
+    the level `_counted()` gives when it starts. A charge may come before a
+    give, so this repeats until the blocks stop changing."""
+    sig, rt = None, []
+    for _ in range(4):
+        rt = hv.runs_for(c, n0, n1, now, shadow,
+                         ahead=_counted(c, [today, rt]))
+        new = [(r["battery"], r["kind"], r["start"], r["end"]) for r in rt]
+        if new == sig:
+            break
+        sig = new
+    return rt
+
+
+def _counted(c, rs):
+    """Modes off reads no forecast and keeps no house profile, so there is no
+    curve. A give is read at Home's own count (`trade_runs()`): the level now,
+    plus what the blocks in `rs` that start before it put in, less what they
+    take out. The house can only take from that and no sun is read, so a
+    battery at the floor by the count is at the floor then. A charge is read
+    from the floor (None): the house uses some of a full battery before the
+    cheap hour, and control charges it back then."""
+    _floor, ceil = arbitrage.soc_bounds(c.o)
+
+    def at(name, kind, start):
+        i = next(k for k, inv in enumerate(c.inverters) if inv.name == name)
+        inv = c.inverters[i]
+        if kind == "grid" or inv.soc is None or not inv.capacity_kwh:
+            return None
+        v = float(inv.soc)
+        mine = sorted((r for day in rs for r in day if r["battery"] == i
+                       and r["kind"] in ("grid", "give")
+                       and r.get("kwh") is not None
+                       and _times(r)[0] < start),
+                      key=lambda r: _times(r)[0])
+        for r in mine:
+            d = float(r["kwh"]) / float(inv.capacity_kwh) * 100.0
+            v = min(max(v, ceil), v + d) if r["kind"] == "grid" else v - d
+        return v
+    return at
+
+
+def _stops(r, names, lv, packs, targets, floor, ceil, day0):
+    """`r` ended where its battery stops, if that is before the run ends: a
+    grid block where the curve has it at the level `modetrade.charge_to()`
+    allows (the curve has a point there), a give block at the first point
+    where the level the tab shows (`LEVEL_DP`) is at the floor. A run is for
+    all the batteries together; each leaves it on its own."""
+    if r["kind"] not in ("grid", "give"):
+        return r
+    name = names[r["battery"]]
+    start, end = _times(r)
+    if r["kind"] == "grid":
+        to = modetrade.charge_to(packs[name], ceil, targets)
+        if to is None:
+            return r
+        hit = lambda v: v >= to - 1e-6                  # noqa: E731
+    else:
+        hit = lambda v: round(v, LEVEL_DP) <= floor     # noqa: E731
+    done = next((t for t, v in lv.get(name, ()) if start < t <= end
+                 and hit(v)), None)
+    if done is None or done >= end:
+        return r
+    return dict(r, end=done.isoformat(), to=hv.hhmm(done),
+                end_h=round(_hours_between(day0, done), 3))
+
+
+def _level_at(pts, t):
+    """The curve's level at `t` (between two points, straight), or None when
+    the curve does not reach `t`."""
+    for (t0, v0), (t1, v1) in zip(pts, pts[1:]):
+        if t0 <= t <= t1:
+            span = (t1 - t0).total_seconds()
+            return v0 if span <= 0 else v0 + (v1 - v0) * (
+                (t - t0).total_seconds() / span)
+    return None
+
+
+def _day(c, k, d0, d1, now, fc, house, trust, levels, blocks, rows, shadow,
+         running, key, missing, notes_b, status, priced):
+    day = (fc.today, fc.tomorrow)[k] if fc is not None else None
+    solar = getattr(c, "solar_today", None)
+    names = [inv.name for inv in c.inverters]
+    hours = []
+    for s, e, h in dayplan._hour_slices(d0, d1):
+        f = None
+        if fc is not None and e > now and (k == 0 or fc.tomorrow is not None):
+            f = sun_kwh(fc, now, max(s, now), e)
+        got = solar.kwh(s, e, now) if k == 0 and solar is not None \
+            and s < now else None
+        use = None if house is None else max(house[0](h), house[1]) \
+            * _hours_between(s, e) / 1000.0
+        row = {"start_h": round(_hours_between(d0, s), 3),
+               "end_h": round(_hours_between(d0, e), 3), "label": hv.hhmm(s),
+               "forecast_kwh": None if f is None else round(f, 3),
+               "measured_kwh": None if got is None else round(got, 3),
+               "house_kwh": None if use is None else round(use, 3),
+               "levels": []}
+        hours.append((s, row))
+    batts = []
+    for i, inv in enumerate(c.inverters):
+        row = rows[i] if i < len(rows) else {}
+        pts = [(t, v) for t, v in levels.get(inv.name, ()) if d0 <= t <= d1]
+        mine = blocks[i]
+        batts.append({
+            "name": inv.name, "capacity_kwh": inv.capacity_kwh,
+            "off": row.get("use") is False,
+            "levels": [[round(_hours_between(d0, t), 3), round(v, LEVEL_DP)]
+                       for t, v in pts],
+            "blocks": [{x: r[x] for x in ("kind", "from", "to", "start_h",
+                                          "end_h", "what", "why", "amount")}
+                       for r in mine],
+            "line": _line(c, inv, row, mine, running, key, shadow, d0, d1,
+                          now)})
+        at = {t: v for t, v in pts}
+        for s, hr in hours:
+            hr["levels"].append(None if s not in at
+                                 else round(at[s], LEVEL_DP))
+    has_levels = any(b["levels"] for b in batts)
+    fcs = [h["forecast_kwh"] for _s, h in hours]
+    notes = []
+    if missing is not None:
+        notes.append(hv.day_note(missing))
+    if not running:
+        notes.append(hv.why_words(key))
+    if shadow:
+        notes.append(hv.why_words("shadow"))
+    line = ""
+    if fc is not None:
+        if k == 0:
+            line = hv.line_solar(fc.today.kwh, fc.today.kwh * trust,
+                                 hv.hhmm(fc.at),
+                                 kept=getattr(fc, "kept", False))
+        elif fc.tomorrow is not None:
+            line = hv.day_note("tomorrow_total",
+                               kwh=hv._kwh(fc.tomorrow.kwh),
+                               count=hv._kwh(fc.tomorrow.kwh * trust))
+        if day is not None and not day.periods:
+            notes.append(hv.day_note("estimate"))
+        if k == 1 and fc.tomorrow is None:
+            notes.append(hv.day_note("no_tomorrow", at=_sun_from()))
+    if k == 0 and solar is not None and solar.first is not None \
+            and solar.day == brussels(now).date() \
+            and _hours_between(d0, solar.first) > 0.5:
+        notes.append(hv.day_note("measured_from", at=hv.hhmm(solar.first)))
+    if has_levels:
+        notes.append(hv.day_note("trust", pct=round(trust * 100)))
+    if k == 1 and _tomorrow_line(status):
+        notes.append(_tomorrow_line(status))
+    if k == 1 and running and priced:
+        notes.append(hv.day_note("ahead"))
+    notes += [notes_b[n] for n in names if n in notes_b]
+    return {"key": ("today", "tomorrow")[k], "date": brussels(d0).date()
+            .isoformat(),
+            "length_h": int(round(_hours_between(d0, d1))),
+            "line": line, "notes": list(dict.fromkeys(notes)),
+            "sun": {"forecast": any(x is not None for x in fcs),
+                    "estimate": day is not None and not day.periods,
+                    "measured": any(h["measured_kwh"] is not None
+                                    for _s, h in hours),
+                    "house": house is not None},
+            "hours": [h for _s, h in hours], "batteries": batts}
+
+
+def _sun_from() -> str:
+    """When the sun of a day starts for `solarfc` (its bell's first hour):
+    with no forecast for tomorrow the sun is unknown from then, and so the
+    curve stops there (`Forecast.between()` answers None past it)."""
+    return f"{int(solarfc.BELL_FROM_H):02d}:00"
+
+
+def _tomorrow_line(status) -> str:
+    """Home's own line about tomorrow's prices, for the tomorrow tab."""
+    return (status.get("plan") or {}).get("tomorrow_line") or ""
+
+
+def _give_planned(c, d0, d1, now) -> bool:
+    """Does the add-on plan a give in `[d0, d1)` not yet over? Modes on: a
+    give run of the run plan. Modes off: a give leg of the verdict that the
+    gate takes (`homeview.trade_legs()`), at a price that is not negative."""
+    if not getattr(c, "modes_on", False):
+        plan = c.fresh_tariff_plan(now)
+        verdict, _why = hv.trade_verdict(c, plan, now)
+        return verdict is not None and any(
+            k == "give" and pt.eur_per_kwh >= 0 and pt.start < d1
+            and hv._point_end(plan, pt) > max(now, d0)
+            for k, pt in hv.trade_legs(c, plan, verdict, now))
+    rp = getattr(c, "mode_runs", None)
+    return rp is not None and rp.on and any(
+        g.end > max(now, d0) and g.start < d1 for g in rp.give)
+
+
+def _line(c, inv, row, mine, running, key, shadow, d0, d1, now) -> str:
+    """What to say for a battery with no block: the plan's own words. Home
+    draws no give block for a battery with no energy to give, so a give that
+    the add-on plans with no block gets its own sentence."""
+    if not running:
+        return hv.why_words(key)
+    if row.get("use") is False:
+        return hv.why_words("off")
+    modes_on = getattr(c, "modes_on", False)
+    gives = not modes_on or row.get("mode_choice") in hv.PRICE_MODES
+    if gives and not any(r["kind"] == "give" for r in mine) \
+            and _give_planned(c, d0, d1, now):
+        return hv.day_note("give_later")
+    if mine:
+        return ""
+    if modes_on and gives:
+        return hv.day_note("no_blocks")
+    return hv.run_house_what(shadow) + " " + hv.run_house_why(shadow)

goodwe_controller/app/homeview.py

@@ -16,13 +16,14 @@ them, so nothing here invents a plan. Every sentence is in the words
 section at the bottom and is held to STYLE.md by test_messages.py.
 """
 
+import contextlib
 from datetime import datetime, timedelta, timezone
 
 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, _cover_table
+from .price import Absence, brussels, _cover_table
 from .static_tariff import static_plan
 from .tariff import BILLING_TZ
 from .uimodel import REGION_PRESETS, options_to_ui
@@ -278,7 +279,11 @@ def trade_verdict(c, plan, now):
         return None, "no_prices"
     verdict = plan.arbitrage(peak_guard_active=guard,
                              min_spread_eur_kwh=arbitrage.threshold_eur_kwh(c.o),
-                             uncertainty=frozenset({Uncertainty.NO_WEATHER}),
+                             uncertainty=arbitrage.weather_uncertainty(
+                                 bool(getattr(c, "modes_on", False)),
+                                 getattr(c, "solar_fc", None),
+                                 bool(getattr(c, "weather_held",
+                                              lambda _n: False)(now))),
                              now=now)
     return verdict.match(
         allowed=lambda v: (v, "allowed"),
@@ -332,18 +337,30 @@ def trade_legs(c, plan, verdict, now):
 MIN_KWH = 0.05
 
 
-def trade_runs(c, plan, verdict, day0, day1, now, shadow):
+def trade_runs(c, plan, verdict, day0, day1, now, shadow, ahead=False):
     """A charge block and a give block on each battery, where the verdict put
     them. The site trades as one; each battery's share is capped by its own
     rating and by the room its level leaves (arbitrage's own floor/ceiling).
     Only what `arbitrage.decide()` would still do is drawn: no block on a
     battery with no room, no sale at a negative price, and no sale while the
     emptiest battery is at the floor (the cycle's `soc` is the emptiest).
-    With a level unknown the cycle does not trade, so nothing is drawn."""
+    With a level unknown the cycle does not trade, so nothing is drawn.
+    UX-54 `ahead`: the window has not started, so the level now says nothing
+    about it. The same rules then read each battery at the level a leg starts
+    at: `ahead(name, kind, start)`, a level in % or None, as in `mode_runs()`;
+    for None (and for `ahead=True`) a charge is read from the floor and a give
+    from the ceiling (the most it could be). The leg itself is still the
+    gate's (`trade_legs()`). Home never passes it."""
     floor, ceiling = arbitrage.soc_bounds(c.o)
-    if any(inv.soc is None for inv in c.inverters):
+    if not ahead and any(inv.soc is None for inv in c.inverters):
         return [], [], "no_level"
-    level = [float(inv.soc) for inv in c.inverters]
+    level = [] if ahead else [float(inv.soc) for inv in c.inverters]
+
+    def start_pct(kind, start):
+        got = [ahead(inv.name, kind, start) if callable(ahead) else None
+               for inv in c.inverters]
+        return [(floor if kind == "grid" else ceiling) if v is None
+                else float(v) for v in got]
     runs, later = [], []
     for kind, pt in trade_legs(c, plan, verdict, now):
         end = _point_end(plan, pt)
@@ -352,6 +369,8 @@ def trade_runs(c, plan, verdict, day0, day1, now, shadow):
         if not (day0 <= pt.start < day1):
             later.append((kind, pt))
             continue
+        if ahead:
+            level = start_pct(kind, pt.start)
         if kind == "give" and (pt.eur_per_kwh < 0 or min(level) <= floor):
             continue
         hrs = (end - pt.start).total_seconds() / 3600.0
@@ -366,7 +385,8 @@ def trade_runs(c, plan, verdict, day0, day1, now, shadow):
                 kwh = min(kwh, max(0.0, room) / 100.0 * cap)
                 # A later give may use what this charge put in: an upper
                 # bound, like every amount here ("up to").
-                level[i] += (kwh if kind == "grid" else -kwh) / cap * 100.0
+                if not ahead:
+                    level[i] += (kwh if kind == "grid" else -kwh) / cap * 100.0
             if kwh < MIN_KWH:
                 continue
             eur = kwh * pt.eur_per_kwh
@@ -386,15 +406,22 @@ def trade_runs(c, plan, verdict, day0, day1, now, shadow):
 PRICE_MODES = (LEFTOVER_SOLAR, CHEAP_HOURS)
 
 
-def mode_runs(c, day0, day1, now, shadow):
+def mode_runs(c, day0, day1, now, shadow, ahead=False, rp=None):
     """OPT-11 P3: each battery's price runs today, as the control cycle keeps
     them (`c.mode_runs`): the cheap run on the batteries that may charge
     from the grid, the give runs on Leftover solar and Cheap hours, and the
     sell run on those with selling on. Amounts are upper bounds ("up to"),
     from the battery's own room, rating and the run's length. UX-53: no grid
     charge is drawn while the trade gate refuses one (`c.mode_gate`, what the
-    control cycle found). Returns `(runs, no_trade_key)`."""
-    rp = getattr(c, "mode_runs", None)
+    control cycle found). Returns `(runs, no_trade_key)`.
+    UX-54 `ahead`: the window has not started, so the level now says nothing
+    about it. The room and energy filter (`room()` and `plan_need()` below)
+    then reads the level a block starts at: `ahead(name, kind, start)`, a
+    function giving the expected level in % or None, or for None (and for
+    `ahead=True`) a charge from the floor and a give from the ceiling. The
+    same filter, the same `MIN_KWH`. `rp`: a run plan to read instead of
+    `c.mode_runs`. Home never passes either."""
+    rp = rp if rp is not None else getattr(c, "mode_runs", None)
     if getattr(c, "mode_tick", None) is None:
         return [], None             # no cycle yet: nothing is known
     if rp is None:
@@ -410,15 +437,23 @@ def mode_runs(c, day0, day1, now, shadow):
             continue
         soc, cap = inv.soc, inv.capacity_kwh
 
-        def room(kind, hrs):
+        def start_pct(kind, start):
+            """The level a block of `kind` is read at when `ahead`."""
+            got = ahead(inv.name, kind, start) if callable(ahead) else None
+            return got if got is not None else (
+                floor if kind == "grid" else ceiling)
+
+        def room(kind, hrs, start):
             kwh = inv.max_w / 1000.0 * hrs
-            if cap and soc is not None:
-                kwh = min(kwh, max(0.0, (ceiling - soc) if kind == "grid"
-                                   else (soc - floor)) / 100.0 * cap)
+            lvl = start_pct(kind, start) if ahead else soc
+            if cap and lvl is not None:
+                kwh = min(kwh, max(0.0, (ceiling - lvl) if kind == "grid"
+                                   else (lvl - floor)) / 100.0 * cap)
             return kwh
         blocks = []
         # P4: with a day plan, the grid block is the planned shortfall.
-        need = plan_need(c, inv.name)
+        need = plan_need(c, inv.name, start_pct("grid", rp.cheap.start)
+                         if ahead and rp.cheap is not None else None)
         if gate is None and rp.charge_useful() and (
                 need > 0.0 if need is not None
                 else pm.mode in GRID_CHARGE_MODES):
@@ -433,7 +468,7 @@ def mode_runs(c, day0, day1, now, shadow):
             if run.end <= now or not (run.start < day1 and run.end > day0):
                 continue
             hrs = (run.end - run.start).total_seconds() / 3600.0
-            kwh = room(kind, hrs)
+            kwh = room(kind, hrs, run.start)
             if kind == "grid" and need is not None:
                 kwh = min(kwh, need)
             if kwh < MIN_KWH:
@@ -460,16 +495,18 @@ def mode_runs(c, day0, day1, now, shadow):
     return out, None
 
 
-def plan_need(c, name):
+def plan_need(c, name, soc=None):
     """P4: kWh this battery buys from the grid by the day plan, or None when
-    there is no plan for it (then P3 option A applies)."""
+    there is no plan for it (then P3 option A applies). `soc`: UX-54, a level
+    to read it from instead of the one now (`mode_runs(ahead=True)`)."""
     targets = c.plan_targets() if hasattr(c, "plan_targets") else None
     if not targets or name not in targets:
         return None
     inv = next((i for i in c.inverters if i.name == name), None)
-    if inv is None or inv.soc is None or not inv.capacity_kwh:
+    at = None if inv is None else (inv.soc if soc is None else soc)
+    if inv is None or at is None or not inv.capacity_kwh:
         return None
-    return max(0.0, targets[name] - float(inv.soc)) / 100.0 * float(
+    return max(0.0, targets[name] - float(at)) / 100.0 * float(
         inv.capacity_kwh)
 
 
@@ -506,7 +543,8 @@ def solar_block(c, now):
         out["line"] = _t("solar." + st)
     elif fc is not None:
         out["line"] = line_solar(fc.today.kwh, out["count_kwh"],
-                                 out["updated"])
+                                 out["updated"],
+                                 kept=getattr(fc, "kept", False))
     return out
 
 
@@ -612,6 +650,20 @@ def region_of(opts):
             if rid in REGION_PRESETS else None}
 
 
+def runs_for(c, day0, day1, now, shadow, ahead=False, rp=None):
+    """UX-54: the price blocks of the window `[day0, day1)`, by the same
+    builders `build_plan()` uses for today: the batteries' price runs with
+    modes on, the verdict's legs with them off. Nothing is decided here.
+    `ahead`: see `mode_runs()`; for a day that has not started."""
+    if getattr(c, "modes_on", False):
+        return mode_runs(c, day0, day1, now, shadow, ahead, rp)[0]
+    fresh = c.fresh_tariff_plan(now)
+    verdict, _why = trade_verdict(c, fresh, now)
+    if verdict is None:
+        return []
+    return trade_runs(c, fresh, verdict, day0, day1, now, shadow, ahead)[0]
+
+
 def build_plan(c, now, shadow, running, held=False, settled=True):
     day0, day1 = local_day(now)
     fresh = c.fresh_tariff_plan(now)
@@ -1001,6 +1053,16 @@ def state_of(c, level, shadow, waiting=False):
     return "running"
 
 
+@contextlib.contextmanager
+def in_lang(lang):
+    """UX-54: build sentences in `lang` for the length of a `with` block."""
+    _LANG[0] = uitext.lang_of(lang)
+    try:
+        yield
+    finally:
+        _LANG[0] = "en"
+
+
 def build(c, *, level: str, checks: list, now: datetime | None = None,
           lang: str = "en", held: bool | None = None,
           waiting: bool = False) -> dict:
@@ -1329,7 +1391,16 @@ def run_house_amount() -> str:
     return _t("run.house_amount")
 
 
-def line_solar(fc_kwh, count_kwh, at) -> str:
+def day_note(key, **values) -> str:
+    """UX-54: one sentence of the Forecast tab (`home_words.day`)."""
+    return _t("day." + key, **values)
+
+
+def line_solar(fc_kwh, count_kwh, at, kept=False) -> str:
+    """The forecast line. OPT-27: a reading kept past three hours (the
+    evening's, used at night) says so instead of "Updated"."""
+    if kept:
+        return _t("solar.kept", at=at)
     return _t("solar.line", kwh=_kwh(fc_kwh), count=_kwh(count_kwh), at=at)
 
 
@@ -1502,6 +1573,9 @@ def _samples() -> list:
     out += [("plan", today_words(k)) for k in words["today"]]
     out += [("plan", line_solar(9.2, 6.4, "10:15")),
             ("plan", _t("solar.no_forecast")), ("plan", _t("solar.learning"))]
+    out += [("plan", day_note(k, pct=70, name="Battery A", at="08:15",
+                              kwh="9.2 kWh", count="6.4 kWh"))
+            for k in words["day"]]
     out += [("plan", line_no_trade(k)) for k in
             ("not_covered", "no_prices", "peak", "not_firm", "not_worth",
              "no_level")]

goodwe_controller/app/main.py

@@ -64,7 +64,8 @@ from .clamp import (
     shortfall_note, write_clamp_note,
 )
 from . import freshness
-from . import homeview
+from . import dayview, homeview
+from .daycurve import SolarToday
 from . import messages
 from .freeze import (
     FreezeWatchdog, FreezeWatchdogConfig, looks_frozen, rail_unreachable, rail_w,
@@ -174,57 +175,17 @@ TARIFF_MAX_AGE_S = 3 * TARIFF_REFRESH_S
 
 
 def tariff_refresh_wanted(opts: dict) -> bool:
-    """TARIFF-10. Does this install need the background tariff refresh at all?
+    """Does this install need the background tariff refresh? (TARIFF-10, TARIFF-24)
 
-    THE DEFECT THIS PREVENTS, and it shipped: the gate below used to be
-    `arbitrage.enabled(opts)` alone. That option defaults to `false`, and
-    `run_tariff_refresh` is the only caller of `resolve_tariff()`, which is the
-    only caller of `price_history.carry()` - so on a shipped install with a
-    provider configured NOTHING was ever fetched, no plan was ever resolved,
-    `/data/price_history.json` was never created, the *Price history* row read
-    `empty` forever, and TARIFF-09's short-horizon warning could not fire
-    because there was no fetch to warn about. Measured over a 40 h soak of two
-    instances side by side: zero feed requests and `present: false` across all
-    802 samples on the shipped default, against a resolved plan from the same
-    feed on the instance with arbitrage armed. ⚠️ AND `DOCS.md` HAS
-    DESCRIBED THE BEHAVIOUR BELOW SINCE THE COMMIT THAT WROTE THE GATE:
-    OPT-04 (bdd7f18) added the refresh task, the `arbitrage.enabled()` guard on
-    it, and the sentence saying a configured provider still fetches, all in one
-    change. config.yaml has said it since TARIFF-02 (852fc7c).
-
-    Two terms, and they answer two different questions:
-
-      provider_configured(opts) -> "the operator asked for a price feed", so
-                                   fetch it, validate it and record the day
-                                   (§8.3). This is the term TARIFF-10 ADDS.
-      arbitrage.enabled(opts)   -> "the operator armed trading". This term is
-                                   what the gate USED to be, kept verbatim.
-
-    ⚠️ IT IS AN `or`, SO THE GATE IS A STRICT WIDENING. Every configuration
-    that started this task before still starts it; none that did not start it
-    stops anything. That matters because the second term is not redundant:
-    `price_provider: off` + a `static_profile` + `arbitrage_enabled: true` is a
-    configuration validate.py explicitly ACCEPTS, and it trades - measured, at
-    `cycle_cost_threshold_eur: 0.05` on a 0.20/0.284 day/night profile,
-    `ARBITRAGE_CHARGE -5000 W`. Dropping that term to make the gate read
-    `provider_configured(opts)` alone would leave `self.tariff_plan` at None on
-    that site forever and `decide()` would answer "no tariff plan has been
-    resolved yet" on every cycle - silently disarming a strategy the UI says is
-    running, which is the exact failure validate.py's OPT-04 rules exist to
-    refuse.
-
-    ⚠️ AND NO CONFIGURATION ACQUIRES A PERIODIC HTTPS CALL FROM THIS TICKET.
-    With `price_provider` off, `resolve_tariff()` returns `static_plan()` - pure
-    arithmetic, no socket - so the second term starts a task that fetches
-    nothing. The true shipped default (no provider, no arbitrage) starts no
-    task at all. What is fetched is decided by the FIRST term only.
-
-    ⚠️ THIS IS NOT A TRADING SWITCH. It decides whether prices are LOOKED UP.
-    Whether they move energy is `arbitrage.enabled()` at the one call site in
-    `cycle()`, and TARIFF-10 did not touch it: `arbitrage_enabled: false` still
-    means no trade, ever, on any configuration.
+    Yes with a price feed, with trading on price armed, or with battery modes
+    on: the modes read `self.tariff_plan` for their price runs. With
+    `price_provider` off the refresh is pure arithmetic on `static_profile`, so
+    no term here adds an HTTPS call. It decides whether prices are looked up,
+    never whether energy moves. See DECISIONS/TARIFF-10-fetching-is-not-trading.md
+    and DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
     """
-    return provider_configured(opts) or arbitrage.enabled(opts)
+    return (provider_configured(opts) or arbitrage.enabled(opts)
+            or packmode.enabled(opts))
 
 
 def load_options() -> dict:
@@ -247,6 +208,9 @@ EDGE_HOLD_S = _ctl.PLANT_SETTLE_S
 # OPT-11 P4: the store key of the house profile (dayplan.HouseProfile), and
 # how often the forecast sensors are read (they change hourly at most).
 HOUSE_PROFILE_KEY = "house_profile"
+# OPT-27: the forecast sensors' last fresh readings (`solarfc.Hold`), so an
+# evening restart keeps the figure the night plan uses.
+FC_HOLD_KEY = "solar_fc_hold"
 FORECAST_READ_S = 60.0
 
 
@@ -1000,6 +964,9 @@ class Controller:
         # and whether last tick filed a mode trade (a run edge reseeds).
         self.mode_runs = None
         self._runs_key = None
+        # TARIFF-24: the end of the run that was under way while a forecast
+        # was read; until then losing the forecast does not widen the gap.
+        self._wx_free_to = None
         self.mode_tick = None
         # UX-53: why the trade gate refused a grid charge this tick (`peak`,
         # `not_worth`, `not_covered`), or None when it allowed one. Home reads
@@ -1031,6 +998,8 @@ class Controller:
         self.solar_fc_why = (solarfc.NOT_SET if self.fc_entity is None
                              else solarfc.MISSING)
         self._fc_read_mono = None
+        self.fc_hold = solarfc.Hold(
+            (getattr(store, "data", None) or {}).get(FC_HOLD_KEY))
         self.day_plan = None
         self._plan_targets = None
         self.house_profile = None
@@ -1261,6 +1230,9 @@ class Controller:
         # UX-13 P1: today's prices as the Home chart has seen them. Display
         # only; nothing reads it back into a decision.
         self.home_prices = homeview.DayPrices()
+        # UX-54: the site's measured solar per hour, for the Forecast tab.
+        # In memory, display only; nothing reads it back into a decision.
+        self.solar_today = SolarToday()
         # TARIFF-11. When the most recent cycle() STARTED. `arb_at < cycle_at`
         # is the exact, derived statement of "the latest cycle did not get as
         # far as the arbitrage step", which is the fact the *Arbitrage* row
@@ -2270,6 +2242,28 @@ class Controller:
                 probing=probing))
         return out
 
+    def _wx_track(self, now) -> None:
+        """TARIFF-24, once per cycle, before the plan: with a forecast read,
+        remember when the run now under way (cheap, give or sell) ends."""
+        if self.solar_fc is None:
+            return
+        rp = self.mode_runs
+        ends = []
+        if rp is not None and rp.on:
+            ends = [r.end for r in (rp.cheap, rp.sell)
+                    if r is not None and r.holds(now)]
+            g = rp.give_at(now)
+            if g is not None:
+                ends.append(g.end)
+        self._wx_free_to = max(ends) if ends else None
+
+    def weather_held(self, now) -> bool:
+        """TARIFF-24: no forecast now, but a run planned with one is under
+        way: it keeps its gap to its end. The wider gap applies from the next
+        run. Pure; Home asks the same (`homeview.trade_verdict()`)."""
+        return (self.solar_fc is None and self._wx_free_to is not None
+                and now < self._wx_free_to)
+
     def _price_runs(self, now, packs, floor_pct, ceiling_pct):
         """The kept run plan, rebuilt at most once per price slot (15 min) or
         when the prices or a battery's choice change; a run under way is
@@ -2283,9 +2277,11 @@ class Controller:
         slot = int(now.timestamp() // 900)
         key = (id(plan), slot, tuple((p.name, p.use, p.mode, p.sell)
                                      for p in packs))
+        held = self.weather_held(now)
         if self.fc_entity is not None:
-            # P4: a forecast arriving or going rebuilds the plan at once.
-            key += (self.solar_fc is None,)
+            # P4: a forecast arriving or going rebuilds the plan at once (and
+            # so does the end of a run that held the gap, TARIFF-24).
+            key += (self.solar_fc is None, held)
         if key != self._runs_key:
             done_c = self._run_done.get("charge", (None, set()))[1]
             done_s = self._run_done.get("sell", (None, set()))[1]
@@ -2294,7 +2290,7 @@ class Controller:
             required = price_required_spread(
                 arbitrage.threshold_eur_kwh(self.o),
                 price_uncertainty_of(plan.read.product)
-                | {Uncertainty.NO_WEATHER})
+                | arbitrage.weather_uncertainty(True, self.solar_fc, held))
             ref = self._ref_cheap
             if ref is not None and now - ref.end > REF_CHEAP_KEEP:
                 ref = self._ref_cheap = None
@@ -2363,6 +2359,7 @@ class Controller:
         quarter), exactly the gate `arbitrage.decide()` has."""
         floor_pct, ceiling_pct = arbitrage.soc_bounds(self.o)
         packs = self._mode_packs(maint_results)
+        self._wx_track(now)
         runs = self._price_runs(now, packs, floor_pct, ceiling_pct)
         guard = arbitrage.guard_state(self.peak_guard)
         plan = self.fresh_tariff_plan(now)
@@ -2373,7 +2370,8 @@ class Controller:
             return plan.arbitrage(
                 peak_guard_active=active,
                 min_spread_eur_kwh=arbitrage.threshold_eur_kwh(self.o),
-                uncertainty=frozenset({Uncertainty.NO_WEATHER}),
+                uncertainty=arbitrage.weather_uncertainty(
+                    True, self.solar_fc, self.weather_held(now)),
                 now=now).match(
                     allowed=lambda _v: True, refused=lambda _v: False)
         if guard is not None and plan is not None and runs is not None:
@@ -3381,6 +3379,11 @@ class Controller:
             *(self.hass.state(entity) for entity in roster))
         self.pv_w, self.pv_why, self.pv_parts = pv_read.total(
             list(zip(roster, states)), pv_read.inverted(self.o))
+        # UX-54: kept for the Forecast tab only. It must never cost a cycle.
+        try:
+            self.solar_today.add(datetime.now(timezone.utc), self.pv_w)
+        except Exception:                               # noqa: BLE001
+            _LOG.debug("measured solar not kept", exc_info=True)
 
     def _peak_fc_unit_log(self, fault) -> None:
         """SAFETY-118. One WARNING when the peak forecast's unit cannot be read
@@ -3408,17 +3411,25 @@ class Controller:
         now = datetime.now(timezone.utc)
         fc, why, gaps = solarfc.read_sum(
             list(zip(self.fc_entities, states[:n])),
-            list(zip(self.fc_tomorrow_entities, states[n:])), now)
+            list(zip(self.fc_tomorrow_entities, states[n:])), now,
+            hold=self.fc_hold)
+        if self.fc_hold.changed:
+            self.fc_hold.changed = False
+            self.store.set(FC_HOLD_KEY, self.fc_hold.dump())
         # A member is named only in a sum of several; one entity reads as
         # before. Logged once per episode: on a change, never every read.
         gaps = tuple(g for g in gaps if len(
             self.fc_entities if g[0] == "today"
             else self.fc_tomorrow_entities) > 1)
+        was_kept = bool(self.solar_fc is not None and self.solar_fc.kept)
         if (fc is None) != (self.solar_fc is None) \
-                or why != self.solar_fc_why or gaps != self.solar_fc_gaps:
+                or why != self.solar_fc_why or gaps != self.solar_fc_gaps \
+                or bool(fc is not None and fc.kept) != was_kept:
             self.log_event(
-                "solar forecast: " + ("read" if fc is not None else
-                                      f"none ({why})")
+                "solar forecast: " + (
+                    "none (" + str(why) + ")" if fc is None else
+                    f"read, kept from {brussels(fc.at):%H:%M}" if fc.kept
+                    else "read")
                 + "".join(f", {d} {e} not usable ({w})"
                           for d, _i, e, w in gaps),
                 hint=messages.hint(
@@ -7635,6 +7646,21 @@ class Controller:
             out["home_error"] = True
         return out
 
+    def forecast_payload(self, lang: str = "en") -> dict:
+        """UX-54: the Forecast tab's data. Built on request, from what the
+        control cycle already holds; no Home Assistant call. Today's blocks are
+        Home's own, so `status_payload()` is built first and read."""
+        try:
+            return dayview.build(self, self.status_payload(lang=lang),
+                                 datetime.now(timezone.utc), lang)
+        except Exception:                               # noqa: BLE001
+            if not getattr(self, "_forecast_failed", False):
+                self._forecast_failed = True
+                _LOG.exception("The Forecast tab could not be built")
+            else:
+                _LOG.debug("The Forecast tab failed again", exc_info=True)
+            return {"ok": False}
+
     async def handle_action(self, what: str, *, unit=None, value=None):
         now = datetime.now(timezone.utc)
         if what in ("pack_use", "pack_mode", "pack_sell"):
@@ -8056,11 +8082,9 @@ async def amain() -> None:
         # ESP32 heartbeat. A fetch on that path is a supplier's TLS timeout able
         # to push this add-on towards layer 1's 30 s veto. See TARIFF_REFRESH_S.
         #
-        # ⚠️ STARTED WHEN A PROVIDER IS CONFIGURED, *OR* WHEN TRADING IS ARMED
-        # - TARIFF-10, and it used to be the second term alone. `arbitrage_
-        # enabled` ships `false`, so a site that had selected a price feed
-        # fetched nothing at all; the whole argument, the measurement and what
-        # the `or` is protecting are in `tariff_refresh_wanted()` above.
+        # ⚠️ STARTED FOR A PROVIDER, FOR ARMED TRADING OR FOR BATTERY MODES:
+        # see `tariff_refresh_wanted()` above and DECISIONS/TARIFF-10 and
+        # TARIFF-24 for why each term is there.
         #
         # ⚠️ IT DOES NOT ARM ANYTHING. Fetching a price and trading on one are
         # two decisions; this is the first, and `cycle()`'s

goodwe_controller/app/solarfc.py

@@ -28,6 +28,17 @@ A reading older than `FRESH_S`, or from before local midnight, is stale,
 and a stale or missing forecast is no forecast: the day plan is off and
 every mode acts as in P3 option A.
 
+OPT-27: but the last fresh reading of each sensor is kept (`Hold`), so the
+night plan is not made blind. Forecast.Solar's sensors stop changing in the
+evening and api.forecast.solar is sometimes out for a poll. A kept reading
+stands in for its sensor (a) for up to `FRESH_S` when the sensor is missing
+or unavailable, as a sensor that merely stopped updating is already
+tolerated, and (b) from the end of the bell (`BELL_TO_H`) until local
+midnight + `KEPT_UNTIL_H` however old it is. Never beyond that, and never
+for another day: a today figure is only today's, a tomorrow figure is
+tomorrow's until midnight and then, until midnight + 3 h, today's.
+DECISIONS/OPT-27-last-fresh-forecast-for-the-night.md.
+
 OPT-17: each day may instead name a list (`pv_forecast_entities`,
 `pv_forecast_tomorrow_entities`), summed by `read_sum()`. One member that is
 not usable makes that day's sum unusable, never a partial sum.
@@ -50,6 +61,11 @@ FRESH_S = 3 * 3600.0
 # The bell a state-only forecast is spread over, in local hours.
 BELL_FROM_H, BELL_TO_H = 6.0, 20.0
 
+# OPT-27: a kept reading serves the night plan from the end of the bell until
+# this many hours after local midnight (the card: "local midnight + 3 h").
+KEPT_UNTIL_H = 3.0
+SAVE_EVERY_S = 900.0
+
 # Why there is no forecast (the page words are in ui_text `home_words`).
 NOT_SET, MISSING, UNIT, STALE, BAD = (
     "not_set", "missing", "unit", "stale", "bad")
@@ -75,6 +91,10 @@ class Forecast:
     today: Day
     tomorrow: Day | None
     at: datetime                # when the sensor last reported
+    # OPT-27: a reading kept past `FRESH_S` is in it (the evening's figure at
+    # night). The screens say so. Last, so `Forecast(today, tomorrow, at)` is
+    # as before.
+    kept: bool = False
 
     def between(self, t0: datetime, t1: datetime) -> float | None:
         """kWh the sun should give between `t0` (now or later) and `t1`.
@@ -234,6 +254,108 @@ def _reported(state):
     return max(ts) if ts else None
 
 
+class Hold:
+    """OPT-27: the last fresh reading of each forecast sensor, per day it is
+    for. `read_sum()` remembers every fresh reading here and, when a sensor
+    has none now, asks it (`stand_in()`).
+
+    Keyed `(kind, entity, day0)`: `kind` is "today" (energy still to come on
+    `day0`) or "tomorrow" (all of `day0`), and `day0` is the day the figure is
+    FOR. A today figure therefore never answers for another day, and a
+    tomorrow figure answers for its own day only: tomorrow until midnight,
+    then today until midnight + `KEPT_UNTIL_H`. Only the newest reading of a
+    key is kept, so the next fresh reading ends the hold at once.
+
+    `dump()` / `load()` are what the controller keeps in its store, so an
+    evening restart does not lose it (`load()` drops what is bad).
+    `changed` is set when `dump()` would differ."""
+
+    def __init__(self, data=None):
+        self._r = {}
+        self._saved = {}        # key -> the `at` last flagged for saving
+        self.changed = False
+        if isinstance(data, dict):
+            self.load(data)
+
+    def remember(self, kind, entity, day: "Day", at: datetime) -> None:
+        key = (kind, entity, day.day0)
+        old = self._r.get(key)
+        if old is not None and at <= old[1]:
+            return
+        self._r[key] = (day, at)
+        # A sensor that reports every minute with the same figure must not
+        # rewrite the store every minute: the saved age may lag by
+        # `SAVE_EVERY_S` (the bounds are hours).
+        mark = self._saved.get(key)
+        if old is None or old[0].kwh != day.kwh or mark is None \
+                or (at - mark).total_seconds() >= SAVE_EVERY_S:
+            self._saved[key] = at
+            self.changed = True
+
+    def forget_before(self, day0: datetime) -> None:
+        """Drop what is for a day before `day0` (the local midnight now)."""
+        gone = [k for k in self._r if k[2] < day0]
+        for k in gone:
+            del self._r[k]
+            self._saved.pop(k, None)
+        if gone:
+            self.changed = True
+
+    def stand_in(self, kind, entity, day0, now, *, as_today=False):
+        """`(Day, at, kept)` for a sensor that has no fresh reading, or None.
+
+        The kept reading must be for `day0`, and either (a) at most `FRESH_S`
+        old, or (b) used at night: from the end of the bell to local midnight,
+        or within `KEPT_UNTIL_H` after it. `kept` is true when (b) was needed,
+        or `as_today` (a tomorrow figure standing in for today, after
+        midnight)."""
+        rec = self._r.get((kind, entity, day0))
+        if rec is None:
+            return None
+        day, at = rec
+        if (now - at).total_seconds() <= FRESH_S and not as_today:
+            return day, at, False
+        # Both sides: a tomorrow sensor is asked with day0 = the next
+        # midnight, which is in the future all day (round 2).
+        after_midnight = day0 <= now < day0 + timedelta(hours=KEPT_UNTIL_H)
+        evening = _local_hour(now) >= BELL_TO_H and now < day0 + timedelta(
+            days=1)
+        if as_today:
+            return (day, at, True) if after_midnight else None
+        return (day, at, True) if (evening or after_midnight) else None
+
+    def dump(self) -> dict:
+        return {"v": 1, "r": [
+            [kind, ent, d.day0.isoformat(), d.kwh, at.isoformat(),
+             [[s.isoformat(), e.isoformat(), k] for s, e, k in d.periods]]
+            for (kind, ent, _d0), (d, at) in sorted(
+                self._r.items(), key=lambda kv: (kv[0][0], kv[0][1],
+                                                 kv[0][2]))]}
+
+    def load(self, data: dict) -> None:
+        rows = data.get("r") if isinstance(data, dict) else None
+        if not isinstance(rows, list):
+            return
+        for row in rows:
+            try:
+                kind, ent, d0, kwh, at, per = row
+                day0, at = _parse_time(d0), _parse_time(at)
+                kwh = float(kwh)
+                periods = tuple((_parse_time(s), _parse_time(e), float(k))
+                                for s, e, k in per)
+                ok = (kind in ("today", "tomorrow") and isinstance(ent, str)
+                      and day0 is not None and at is not None
+                      and math.isfinite(kwh) and kwh >= 0
+                      and all(s is not None and e is not None and e > s
+                              and math.isfinite(k) and k >= 0
+                              for s, e, k in periods))
+            except (TypeError, ValueError):
+                continue
+            if ok:
+                self._r[(kind, ent, day0)] = (Day(day0, kwh, periods), at)
+                self._saved[(kind, ent, day0)] = at
+
+
 def entities(opts: dict, *, tomorrow=False) -> tuple:
     """The forecast entities one day names, in configured order: the list
     if it has any entry, else the single key, else (). A repeated id is
@@ -270,14 +392,14 @@ def _today(state, day0, now):
 
 
 def _tomorrow(state, day0, day1, now):
-    """`(Day, None)` or `(None, why)` for one tomorrow sensor."""
+    """`(Day, at, None)` or `(None, None, why)` for one tomorrow sensor."""
     t, why = _day(state, day1, now, today=False)
     if t is None:
-        return None, why
+        return None, None, why
     t_at = _reported(state)
     if t_at is None or t_at < day0 or (now - t_at).total_seconds() > FRESH_S:
-        return None, STALE
-    return t, None
+        return None, None, STALE
+    return t, t_at, None
 
 
 def read(today_state, tomorrow_state, now: datetime, *,
@@ -293,7 +415,7 @@ def read(today_state, tomorrow_state, now: datetime, *,
         return None, why
     tomorrow = None
     if tomorrow_state is not None:
-        tomorrow, _w = _tomorrow(tomorrow_state, day0, day1, now)
+        tomorrow, _at, _w = _tomorrow(tomorrow_state, day0, day1, now)
     return Forecast(today, tomorrow, at), None
 
 
@@ -309,7 +431,12 @@ def _sum(days):
     return Day(days[0].day0, sum(d.kwh for d in days), periods)
 
 
-def read_sum(today, tomorrow, now: datetime):
+# Why a sensor may be covered by a kept reading: it has none now, or it is
+# too old. A bad value or a wrong unit is a set-up fault and is never covered.
+_COVERABLE = (MISSING, STALE)
+
+
+def read_sum(today, tomorrow, now: datetime, hold: Hold | None = None):
     """OPT-17: `(Forecast or None, why, gaps)` over lists of
     `(entity, state)`, one per configured member, in configured order.
 
@@ -322,29 +449,67 @@ def read_sum(today, tomorrow, now: datetime):
     `gaps` is `((day, position, entity, why), ...)` for every unusable
     member (`day` "today" or "tomorrow", `position` 1-based), so the page
     and the log can name it. With one member per day the forecast is what
-    `read()` gives (test_opt17.py proves it)."""
+    `read()` gives (test_opt17.py proves it).
+
+    OPT-27: with a `hold`, every fresh reading is remembered in it, and a
+    member that is missing or stale is covered by its last fresh reading
+    where `Hold.stand_in()` allows it (the forecast then has `kept` set when
+    that took a reading older than `FRESH_S`). After midnight, if the today
+    side is still short, the tomorrow figures read before midnight are
+    today's, until midnight + `KEPT_UNTIL_H`. Without a `hold` this is
+    exactly as before."""
     if not today:
         return None, NOT_SET, ()
     day0, day1 = _bounds(now)
-    gaps, days, ats, why0 = [], [], [], None
+    if hold is not None:
+        hold.forget_before(day0)
+    gaps, days, ats, why0, kept = [], [], [], None, False
     for i, (ent, st) in enumerate(today, 1):
         d, at, why = _today(st, day0, now)
+        if d is not None and hold is not None:
+            hold.remember("today", ent, d, at)
+        elif hold is not None and why in _COVERABLE:
+            r = hold.stand_in("today", ent, day0, now)
+            if r is not None:
+                d, at, k = r
+                kept = kept or k
         if d is None:
             gaps.append(("today", i, ent, why))
             why0 = why0 or why
         else:
             days.append(d)
             ats.append(at)
-    tdays = []
+    tdays, tats, tkept = [], [], False
     for i, (ent, st) in enumerate(tomorrow, 1):
-        t, why = _tomorrow(st, day0, day1, now)
+        t, t_at, why = _tomorrow(st, day0, day1, now)
+        if t is not None and hold is not None:
+            hold.remember("tomorrow", ent, t, t_at)
+        elif hold is not None and why in _COVERABLE:
+            r = hold.stand_in("tomorrow", ent, day1, now)
+            if r is not None:
+                t, t_at, k = r
+                tkept = tkept or k
         if t is None:
             gaps.append(("tomorrow", i, ent, why))
         else:
             tdays.append(t)
+            tats.append(t_at)
+    if why0 is not None and hold is not None and tomorrow and all(
+            g[3] in _COVERABLE for g in gaps if g[0] == "today"):
+        # Past midnight the sensors may still show yesterday's "left today".
+        # The figure each tomorrow sensor gave before midnight is for this
+        # day; all of them are needed, as for any sum.
+        subs = [hold.stand_in("tomorrow", ent, day0, now, as_today=True)
+                for ent, _st in tomorrow]
+        if all(r is not None for r in subs):
+            days = [r[0] for r in subs]
+            ats = [r[1] for r in subs]
+            gaps = [g for g in gaps if g[0] != "today"]
+            why0, kept = None, True
     gaps = tuple(gaps)
     if why0 is not None:
         return None, why0, gaps
     tday = _sum(tdays) if tomorrow and len(tdays) == len(tomorrow) else None
+    kept = kept or (tday is not None and tkept)
     # The oldest member's report is when the sum was last fully known.
-    return Forecast(_sum(days), tday, min(ats)), None, gaps
+    return Forecast(_sum(days), tday, min(ats), kept), None, gaps

goodwe_controller/app/static/app.css

@@ -246,3 +246,29 @@ select.sel:disabled{opacity:.6}
 .simple .card .lbl{font-weight:600;font-size:15px}
 .simple .inv .hd{border-bottom:0}
 .simple .inv .f{border-top:0;padding-top:0}
+/* UX-54: the Forecast screen */
+.fcline{text-align:right}
+.fcnote{background:var(--info-bg);border-radius:10px;padding:8px 10px;margin:0 0 8px}
+.fcbars{display:flex;align-items:flex-end;gap:2px;height:110px}
+.fcol{flex:1;position:relative;height:100%;min-width:0}
+.fcol i{position:absolute;display:block}
+.fcol .sun{bottom:0;left:0;right:0;background:var(--solar);border-radius:3px 3px 0 0;opacity:.85}
+.fcol .sun.est{opacity:.5}
+.fcol .got{bottom:0;left:30%;right:30%;background:repeating-linear-gradient(135deg,var(--ink) 0 3px,var(--card) 3px 5px);border:1px solid var(--ink);border-bottom:0}
+.fcol .use{left:-1px;right:-1px;height:3px;background:var(--house)}
+.fcols{position:absolute;inset:0;display:flex;gap:0}
+.fcols>i{flex:1;min-width:0;display:block}
+.lvlchart{position:relative;height:110px;margin:18px 0 4px}
+.lvlchart svg{position:absolute;inset:0;width:100%;height:100%;display:block}
+.lvlchart .yl{position:absolute;right:2px;font-size:10px;color:var(--faint);pointer-events:none}
+.fcnow{position:absolute;top:-4px;bottom:0;width:2px;background:var(--ink);opacity:.7;pointer-events:none}
+.fcnow span{position:absolute;top:-15px;left:-10px;font-size:10px}
+.legend i.sun{background:var(--solar)}
+.legend i.got{background:repeating-linear-gradient(135deg,var(--ink) 0 2px,var(--card) 2px 4px);border:1px solid var(--ink)}
+.legend i.use{height:3px;background:var(--house)}
+.legend i.lv{height:3px;background:var(--batt)}
+table.fct{width:100%;border-collapse:collapse;font-size:12px;font-variant-numeric:tabular-nums}
+table.fct th,table.fct td{padding:4px 3px;text-align:right;border-bottom:1px solid var(--line)}
+table.fct th:first-child,table.fct td:first-child{text-align:left}
+table.fct th{color:var(--muted);font-weight:600}
+.ymax{position:absolute;top:-2px;left:2px;font-size:10px;color:var(--faint);pointer-events:none}

goodwe_controller/app/static/app.js

@@ -448,6 +448,175 @@
     });
   }
 
+  /* ---------------- Forecast (UX-54) ---------------- */
+  // Today and tomorrow, per hour: the solar forecast and what was measured,
+  // the house's expected use, and each battery's expected level with its
+  // blocks. The data is built by app/dayview.py when the tab asks (GET
+  // forecast), the sentences in the page's language. A part that is not
+  // known yet comes as a note, so no chart is ever drawn empty.
+  // The SVG namespace, read off the page's own icons: the page names no URL.
+  const SVGNS = document.querySelector("svg").namespaceURI;
+  function sv(tag, attrs) {
+    const e = document.createElementNS(SVGNS, tag);
+    for (const k in attrs || {}) e.setAttribute(k, attrs[k]);
+    return e;
+  }
+  let FC = null;
+  let fcDay = 0;
+  let fcBusy = false;
+  let fcTimer = null;
+  const fmtKwh = (x) => dec(Number(x).toFixed(1));
+  const hoursOf = (d) => d.length_h || d.hours.length || 24;
+  function endLabel(d, i) { return i + 1 < d.hours.length ? d.hours[i + 1].label : "24:00"; }
+  function hourTip(d, i) {
+    const x = d.hours[i];
+    const lines = [];
+    if (x.forecast_kwh != null) lines.push(t("forecast.forecast") + ": " + fmtKwh(x.forecast_kwh) + " kWh");
+    if (x.measured_kwh != null) lines.push(t("forecast.measured") + ": " + fmtKwh(x.measured_kwh) + " kWh");
+    if (x.house_kwh != null) lines.push(t("forecast.house") + ": " + fmtKwh(x.house_kwh) + " kWh");
+    d.batteries.forEach((b, j) => { if (x.levels[j] != null) lines.push(b.name + ": " + dec(Math.round(x.levels[j]).toString()) + " %"); });
+    return [x.label + " " + t("plan.time_to") + " " + endLabel(d, i)].concat(lines);
+  }
+  function hourItem(tag, cls, d, i, kids) {
+    const tip = hourTip(d, i);
+    const e = h(tag, { class: cls, tabindex: "-1", role: "img", "aria-label": tip.join(". "), "data-tip": JSON.stringify(tip) }, kids);
+    return e;
+  }
+  function renderSun(d) {
+    const card = $("#fc-sun");
+    const any = d.sun.forecast || d.sun.measured || d.sun.house;
+    card.hidden = !any;
+    if (!any) return;
+    const mx = Math.max(0.5, ...d.hours.map((x) => Math.max(x.forecast_kwh || 0, x.measured_kwh || 0, x.house_kwh || 0)));
+    const pct = (v) => Math.max(0, Math.min(100, v / mx * 100)) + "%";
+    const bars = $("#fc-bars");
+    bars.setAttribute("aria-label", t("forecast.sun"));
+    bars.replaceChildren(...d.hours.map((x, i) => hourItem("div", "fcol", d, i, [
+      x.forecast_kwh != null ? h("i", { class: "sun" + (d.sun.estimate ? " est" : ""), style: "height:" + pct(x.forecast_kwh) }) : null,
+      x.measured_kwh != null ? h("i", { class: "got", style: "height:" + pct(x.measured_kwh) }) : null,
+      x.house_kwh != null ? h("i", { class: "use", style: "bottom:calc(" + pct(x.house_kwh) + " - 1px)" }) : null])));
+    roving(bars);
+    const chart = $("#fc-sunchart");
+    chart.querySelectorAll(".fcnow, .ymax").forEach((e) => e.remove());
+    chart.append(h("span", { class: "ymax", "aria-hidden": "true" }, fmtKwh(mx)));
+    if (fcDay === 0) chart.append(nowMark(d));
+    const used = [["sun", d.sun.forecast, "forecast"], ["got", d.sun.measured, "measured"], ["use", d.sun.house, "house"]];
+    $("#fc-legend").replaceChildren(...used.filter((u) => u[1]).map((u) => h("span", {}, h("i", { class: u[0], "aria-hidden": "true" }), t("forecast." + u[2]))));
+  }
+  function nowMark(d) {
+    return h("div", { class: "fcnow", "aria-hidden": "true", style: "left:" + Math.max(0, Math.min(100, FC.now_h / hoursOf(d) * 100)) + "%" }, h("span", {}, t("plan.now")));
+  }
+  function levelChart(d, b, bi) {
+    const L = hoursOf(d), W = L * 10;
+    const x = (hr) => hr * 10;
+    const box = h("div", { class: "chart" });
+    const area = h("div", { class: "lvlchart" });
+    const svg = sv("svg", { viewBox: "0 0 " + W + " 100", preserveAspectRatio: "none", "aria-hidden": "true", focusable: "false" });
+    [0, 50, 100].forEach((p) => svg.append(sv("line", { x1: 0, x2: W, y1: 100 - p, y2: 100 - p, stroke: "var(--line)", "stroke-width": 1, "vector-effect": "non-scaling-stroke" })));
+    const fill = { grid: "var(--accent)", give: "var(--house)", cycle: "var(--warn)" };
+    for (const r of b.blocks) {
+      if (r.end_h <= r.start_h) continue;
+      svg.append(sv("rect", { x: x(r.start_h), y: 0, width: x(r.end_h) - x(r.start_h), height: 100, fill: fill[r.kind] || "var(--mid)", opacity: 0.18 }));
+    }
+    const pts = b.levels.map((p) => x(p[0]) + "," + (100 - p[1]));
+    svg.append(sv("polygon", { points: x(b.levels[0][0]) + ",100 " + pts.join(" ") + " " + x(b.levels[b.levels.length - 1][0]) + ",100", fill: "var(--batt)", opacity: 0.12 }));
+    svg.append(sv("polyline", { points: pts.join(" "), fill: "none", stroke: "var(--batt)", "stroke-width": 2.5, "stroke-linejoin": "round", "vector-effect": "non-scaling-stroke" }));
+    area.append(svg);
+    [["100", 0], ["50", 50], ["0", 100]].forEach((y) => area.append(h("span", { class: "yl", "aria-hidden": "true", style: "top:" + y[1] + "%;transform:translateY(" + (y[1] === 100 ? "-100%" : y[1] === 0 ? "0" : "-50%") + ")" }, y[0] + " %")));
+    area.append(h("div", { class: "fcols", role: "group", "aria-label": b.name }, ...d.hours.map((hx, i) => hourItem("i", "", d, i, null))));
+    roving(area.querySelector(".fcols"));
+    if (fcDay === 0) area.append(nowMark(d));
+    box.append(area);
+    // The blocks under the chart, drawn as Home draws them.
+    if (b.blocks.length) {
+      const lane = h("div", { class: "lane", role: "group", "aria-label": b.name });
+      for (const r of b.blocks) {
+        if (r.end_h <= r.start_h) continue;
+        lane.append(chartItem("b", r.kind, "left:" + (r.start_h / L * 100) + "%;width:" + ((r.end_h - r.start_h) / L * 100) + "%",
+                              b.name + ", " + r.from + " " + t("plan.time_to") + " " + r.to, [r.what, r.why, r.amount]));
+      }
+      box.append(lane);
+      roving(lane);
+    }
+    box.append(h("div", { class: "axis", "aria-hidden": "true" }, h("span", {}, "00:00"), h("span", {}, "06:00"), h("span", {}, "12:00"), h("span", {}, "18:00"), h("span", {}, "24:00")));
+    return box;
+  }
+  function batteryCardFc(d, b, bi) {
+    const drawn = b.levels.length > 1;
+    const list = b.blocks.map((r) => h("li", {}, h("strong", {}, r.from + " " + t("plan.time_to") + " " + r.to + ": "), tipText([r.what, r.why, r.amount])));
+    return h("div", { class: "card" },
+      h("div", { class: "row spread" }, h("h2", {}, b.name),
+        h("span", { class: "tiny muted" }, (b.capacity_kwh ? fmtKwh(b.capacity_kwh) + " kWh · " : "") + t("forecast.levels"))),
+      drawn ? levelChart(d, b, bi) : null,
+      list.length ? h("ul", { class: "plain small" }, ...list) : null,
+      b.line ? h("p", { class: "small muted", style: "margin:6px 0 0" }, b.line) : null);
+  }
+  function renderTable(d) {
+    const more = $("#fc-more");
+    const any = d.sun.forecast || d.sun.measured || d.sun.house;
+    more.hidden = !any;
+    if (!any) return;
+    const lv = d.batteries.filter((b) => b.levels.length > 1);
+    const head = h("tr", {}, h("th", { scope: "col" }, t("forecast.hour")),
+      d.sun.forecast ? h("th", { scope: "col" }, t("forecast.solar")) : null,
+      d.sun.measured ? h("th", { scope: "col" }, t("forecast.got")) : null,
+      d.sun.house ? h("th", { scope: "col" }, t("forecast.use")) : null,
+      ...lv.map((b) => h("th", { scope: "col" }, b.name + " %")));
+    const cell = (v, f) => h("td", {}, v == null ? "–" : f(v));
+    const rows = d.hours.map((x) => h("tr", {},
+      h("td", {}, x.label),
+      d.sun.forecast ? cell(x.forecast_kwh, fmtKwh) : null,
+      d.sun.measured ? cell(x.measured_kwh, fmtKwh) : null,
+      d.sun.house ? cell(x.house_kwh, fmtKwh) : null,
+      ...lv.map((b) => cell(x.levels[d.batteries.indexOf(b)], (v) => dec(Math.round(v).toString())))));
+    $("#fc-table").replaceChildren(h("thead", {}, head), h("tbody", {}, ...rows));
+  }
+  function renderForecast() {
+    const loading = $("#fc-loading");
+    if (!FC || FC.ok !== true) {
+      loading.hidden = false; loading.textContent = FC ? t("offline.name") : t("forecast.loading");
+      $("#fc-notes").replaceChildren(); $("#fc-sun").hidden = true; $("#fc-batts").replaceChildren(); $("#fc-more").hidden = true; $("#fc-line").textContent = "";
+      return;
+    }
+    loading.hidden = true;
+    const d = FC.days[fcDay];
+    $("#fc-line").textContent = d.line || "";
+    $("#fc-notes").replaceChildren(...d.notes.map((n) => h("p", { class: "fcnote small" }, n)));
+    renderSun(d);
+    $("#fc-batts").replaceChildren(...d.batteries.map((b, i) => batteryCardFc(d, b, i)));
+    renderTable(d);
+    document.querySelectorAll("#fc-day button").forEach((b) => {
+      const on = Number(b.dataset.d) === fcDay;
+      b.setAttribute("aria-checked", String(on)); b.tabIndex = on ? 0 : -1;
+    });
+  }
+  async function loadForecast() {
+    if (fcBusy) return;
+    fcBusy = true;
+    try {
+      const r = await fetch("forecast?lang=" + LANG, { cache: "no-store" });
+      if (!r.ok) throw new Error("forecast " + r.status);
+      FC = await r.json();
+    } catch (e) { FC = { ok: false }; }
+    finally { fcBusy = false; }
+    renderForecast();
+  }
+  document.querySelectorAll("#fc-day button").forEach((b, i, all) => {
+    b.addEventListener("click", () => { fcDay = Number(b.dataset.d); renderForecast(); });
+    b.addEventListener("keydown", (e) => {
+      const j = { ArrowRight: i + 1, ArrowLeft: i - 1 + all.length }[e.key];
+      if (j === undefined) return;
+      e.preventDefault(); fcDay = j % all.length; renderForecast(); all[fcDay].focus();
+    });
+  });
+  // Every 30 s while the screen shows: the data moves slowly, and each load
+  // is built on request.
+  function scheduleForecast() {
+    const on = !document.hidden && $("#t-fc").getAttribute("aria-selected") === "true";
+    if (on && !fcTimer) { loadForecast(); fcTimer = setInterval(loadForecast, 30000); }
+    if (!on && fcTimer) { clearInterval(fcTimer); fcTimer = null; }
+  }
+
   /* ---------------- control buttons ---------------- */
   // The action is a toggle, so the page reads the live state first and sends
   // nothing when control is already where the person asked it to be.
@@ -511,11 +680,13 @@
   }
   addEventListener("hashchange", fromHash);
 
-  /* ---------------- polling: every 3 s while Home or Batteries shows ---------------- */
+  /* ---------------- polling: every 3 s while Home, Batteries or Forecast shows ---------------- */
   let timer = null;
   function schedule() {
+    scheduleForecast();
     const live = !document.hidden && ($("#t-home").getAttribute("aria-selected") === "true" ||
-                                      $("#t-batt").getAttribute("aria-selected") === "true");
+                                      $("#t-batt").getAttribute("aria-selected") === "true" ||
+                                      $("#t-fc").getAttribute("aria-selected") === "true");
     if (live && !timer) { refresh(); timer = setInterval(refresh, 3000); }
     if (!live && timer) { clearInterval(timer); timer = null; }
   }

goodwe_controller/app/static/index.html

@@ -18,6 +18,7 @@
 <nav class="tabs" role="tablist" id="tabs" data-t-label="tabs.label">
   <button class="tab" role="tab" id="t-home" aria-controls="s-home" aria-selected="true" data-hash="home"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M3 11l9-7 9 7v9a1 1 0 0 1-1 1h-5v-6H9v6H4a1 1 0 0 1-1-1z"/></svg><span data-t="tabs.home"></span><span class="badge" id="attn-badge" hidden></span></button>
   <button class="tab" role="tab" id="t-batt" aria-controls="s-batt" aria-selected="false" data-hash="batteries" tabindex="-1"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><rect x="3" y="7" width="16" height="10" rx="2"/><path d="M21 11v2"/><rect x="5.5" y="9.5" width="7" height="5" fill="currentColor" stroke="none"/></svg><span data-t="tabs.batteries"></span></button>
+  <button class="tab" role="tab" id="t-fc" aria-controls="s-fc" aria-selected="false" data-hash="forecast" tabindex="-1"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M3 20h18M4 16l5-6 4 4 7-9"/></svg><span data-t="tabs.forecast"></span></button>
   <button class="tab" role="tab" id="t-set" aria-controls="s-set" aria-selected="false" data-hash="settings" tabindex="-1"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M4 6h10M18 6h2M4 12h4M12 12h8M4 18h12M20 18h0"/><circle cx="16" cy="6" r="2"/><circle cx="10" cy="12" r="2"/><circle cx="18" cy="18" r="2"/></svg><span data-t="tabs.settings"></span></button>
   <button class="tab" role="tab" id="t-wiz" aria-controls="s-wiz" aria-selected="false" data-hash="setup" tabindex="-1"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M14 7l3 3M5 19l9.5-9.5 3 3L8 22H5z"/><path d="M19 2v4M17 4h4"/></svg><span data-t="tabs.setup"></span></button>
 </nav>
@@ -114,6 +115,32 @@
   </details>
 </section>
 
+<section class="screen" id="s-fc" role="tabpanel" aria-labelledby="t-fc" hidden>
+  <div class="row spread" style="margin-bottom:8px">
+    <div class="seg" role="radiogroup" id="fc-day" data-t-label="forecast.day">
+      <button type="button" role="radio" aria-checked="true" data-d="0" data-t="forecast.today"></button>
+      <button type="button" role="radio" aria-checked="false" data-d="1" tabindex="-1" data-t="forecast.tomorrow"></button>
+    </div>
+    <span class="tiny muted grow fcline" id="fc-line"></span>
+  </div>
+  <div id="fc-notes" aria-live="polite"></div>
+  <p class="small muted" id="fc-loading" data-t="forecast.loading"></p>
+  <div class="card" id="fc-sun" hidden>
+    <div class="row spread"><h2 data-t="forecast.sun"></h2><span class="tiny muted" data-t="forecast.unit"></span></div>
+    <div class="chart" id="fc-sunchart">
+      <div class="fcbars" id="fc-bars" role="group"></div>
+      <div class="axis" aria-hidden="true"><span>00:00</span><span>06:00</span><span>12:00</span><span>18:00</span><span>24:00</span></div>
+    </div>
+    <div class="legend" id="fc-legend"></div>
+    <p class="tiny muted" style="margin:6px 0 0" data-t="plan.description"></p>
+  </div>
+  <div id="fc-batts"></div>
+  <details class="grp" id="fc-more" hidden>
+    <summary><span class="grow"><strong data-t="forecast.table"></strong></span><span class="chev" aria-hidden="true">&#8250;</span></summary>
+    <div class="body"><table class="fct" id="fc-table"></table></div>
+  </details>
+</section>
+
 <section class="screen" id="s-set" role="tabpanel" aria-labelledby="t-set" hidden>
   <div class="row spread" style="margin-bottom:6px">
     <h2 style="margin:0" data-s="name"></h2>

goodwe_controller/app/ui_text/en.json

@@ -45,7 +45,7 @@
   },
   "home": {
     "app": {"name": "Battery add-on"},
-    "tabs": {"home": "Home", "batteries": "Batteries", "settings": "Settings", "setup": "Setup", "label": "Screens"},
+    "tabs": {"home": "Home", "batteries": "Batteries", "forecast": "Forecast", "settings": "Settings", "setup": "Setup", "label": "Screens"},
     "now": {"name": "Now", "description": "Updated every 3 seconds.", "solar": "Solar", "house": "House", "grid": "Grid", "batteries": "Batteries"},
     "plan": {
       "name": "Today's plan",
@@ -68,6 +68,24 @@
       "no_prices": {"description": "No prices for today, so the chart shows only the plan."},
       "list": "The plan in words"
     },
+    "forecast": {
+      "name": "Forecast",
+      "day": "Day",
+      "today": "Today",
+      "tomorrow": "Tomorrow",
+      "sun": "Solar and house",
+      "unit": "kWh per hour",
+      "forecast": "Solar forecast",
+      "measured": "Measured solar",
+      "house": "House use",
+      "levels": "Battery level",
+      "table": "Hour by hour",
+      "hour": "Hour",
+      "solar": "Solar",
+      "got": "Measured",
+      "use": "House",
+      "loading": "Loading the forecast."
+    },
     "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"},
     "control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"},
@@ -342,7 +360,7 @@
       "tops_up": "Too little sun is forecast, so it charges some from the grid.",
       "no_forecast": "No solar forecast, so it charges from solar only."
     },
-    "solar": {"line": "Solar still to come today: {kwh}, we count on {count}. Updated {at}.", "no_forecast": "No solar forecast now, so Leftover solar charges from solar only.", "learning": "The add-on is learning your house's use. The plan starts after one full day."},
+    "solar": {"line": "Solar still to come today: {kwh}, we count on {count}. Updated {at}.", "kept": "Solar forecast read {at}, used for tonight's plan.", "no_forecast": "No solar forecast now, so Leftover solar charges from solar only.", "learning": "The add-on is learning your house's use. The plan starts after one full day."},
     "today": {
       "not_planned": "Not planned yet.",
       "no_runs": "No cheap or expensive hours left today.",
@@ -425,6 +443,22 @@
       "known": "Tomorrow's prices are in.",
       "unknown": "Tomorrow's prices usually arrive after 13:00."
     },
+    "day": {
+      "modes_off": "Battery modes are off. No forecast is read and no level is planned.",
+      "not_set": "No solar forecast is set up. Without one, no battery level is planned.",
+      "no_forecast": "The solar forecast is missing or too old. The levels return when it is back.",
+      "learning": "The add-on is learning your house's use. The levels start after one full day.",
+      "no_tomorrow": "There is no solar forecast for tomorrow yet. The levels stop at {at}.",
+      "estimate": "The forecast gives one total for the day. The add-on spreads it over the hours.",
+      "trust": "The levels count on {pct} % of the forecast.",
+      "cycle": "{name} does its monthly cycle. Its level is not shown once the cycle starts.",
+      "no_level": "{name} has no level reading yet. Its level is not shown.",
+      "measured_from": "Measured solar is counted from {at}, when the add-on started.",
+      "tomorrow_total": "Solar expected tomorrow: {kwh}, we count on {count}.",
+      "no_blocks": "No charge or give blocks planned.",
+      "give_later": "The add-on plans to give power. No block shows while a battery has no energy to give.",
+      "ahead": "The add-on plans about a day ahead. Blocks for later hours appear as they come near."
+    },
     "region": {
       "preset": "Levies and VAT: {region}, {year} figures.",
       "own": "Levies and VAT: your own figure."

goodwe_controller/app/ui_text/nl.json

@@ -42,7 +42,7 @@
   "applies": {"restart": {"name": "Geldt na een herstart"}, "now": {"name": "Geldt meteen"}},
   "home": {
     "app": {"name": "Batterij-add-on"},
-    "tabs": {"home": "Start", "batteries": "Batterijen", "settings": "Instellingen", "setup": "Installatie", "label": "Schermen"},
+    "tabs": {"home": "Start", "batteries": "Batterijen", "forecast": "Prognose", "settings": "Instellingen", "setup": "Installatie", "label": "Schermen"},
     "now": {"name": "Nu", "description": "Elke 3 seconden bijgewerkt.", "solar": "Zonnepanelen", "house": "Huis", "grid": "Net", "batteries": "Batterijen"},
     "plan": {
       "name": "Plan voor vandaag",
@@ -65,6 +65,24 @@
       "no_prices": {"description": "Geen prijzen voor vandaag, dus de grafiek toont alleen het plan."},
       "list": "Het plan in woorden"
     },
+    "forecast": {
+      "name": "Prognose",
+      "day": "Dag",
+      "today": "Vandaag",
+      "tomorrow": "Morgen",
+      "sun": "Zon en huis",
+      "unit": "kWh per uur",
+      "forecast": "Zonneprognose",
+      "measured": "Gemeten zon",
+      "house": "Huisverbruik",
+      "levels": "Laadniveau",
+      "table": "Uur per uur",
+      "hour": "Uur",
+      "solar": "Zon",
+      "got": "Gemeten",
+      "use": "Huis",
+      "loading": "De prognose wordt geladen."
+    },
     "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"},
     "control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"},
@@ -282,7 +300,7 @@
       "tops_up": "Te weinig zon voorspeld, dus ze laadt wat van het net.",
       "no_forecast": "Geen zonneprognose, dus ze laadt alleen met zonne-energie."
     },
-    "solar": {"line": "Nog verwachte zon vandaag: {kwh}, we rekenen op {count}. Bijgewerkt om {at}.", "no_forecast": "Nu geen zonneprognose, dus Overschot zonne-energie laadt alleen met zon.", "learning": "De add-on leert eerst het verbruik van uw huis. Het plan start na één volle dag."},
+    "solar": {"line": "Nog verwachte zon vandaag: {kwh}, we rekenen op {count}. Bijgewerkt om {at}.", "kept": "Zonneprognose van {at}, gebruikt voor het plan van vanavond.", "no_forecast": "Nu geen zonneprognose, dus Overschot zonne-energie laadt alleen met zon.", "learning": "De add-on leert eerst het verbruik van uw huis. Het plan start na één volle dag."},
     "today": {
       "not_planned": "Nog niet gepland.",
       "no_runs": "Vandaag geen goedkope of dure uren meer.",
@@ -353,6 +371,22 @@
     "period_unmeasured": "Een deel van dit kwartier is niet gemeten.",
     "prices": {"now": "Prijs nu {eur} per kWh, alles inbegrepen.", "today": "Vandaag: laagste {lo} om {lo_at}, hoogste {hi} om {hi_at}.", "none": "Geen prijzen voor vandaag."},
     "tomorrow": {"known": "De prijzen van morgen zijn binnen.", "unknown": "De prijzen van morgen komen meestal na 13:00."},
+    "day": {
+      "modes_off": "Batterijmodi staan uit. Er wordt geen prognose gelezen en geen niveau gepland.",
+      "not_set": "Er is geen zonneprognose ingesteld. Zonder prognose wordt geen laadniveau gepland.",
+      "no_forecast": "De zonneprognose ontbreekt of is te oud. De niveaus komen terug als ze er weer is.",
+      "learning": "De add-on leert het verbruik van uw huis. De niveaus starten na één volle dag.",
+      "no_tomorrow": "Er is nog geen zonneprognose voor morgen. De niveaus stoppen om {at}.",
+      "estimate": "De prognose geeft één totaal voor de dag. De add-on verdeelt het over de uren.",
+      "trust": "De niveaus rekenen op {pct} % van de prognose.",
+      "cycle": "{name} doet de maandelijkse cyclus. Het niveau wordt niet getoond zodra de cyclus start.",
+      "no_level": "{name} geeft nog geen laadniveau door. Het niveau wordt niet getoond.",
+      "measured_from": "Gemeten zon telt vanaf {at}, toen de add-on startte.",
+      "tomorrow_total": "Verwachte zon morgen: {kwh}, we rekenen op {count}.",
+      "no_blocks": "Geen laad- of leverblokken gepland.",
+      "give_later": "De add-on plant stroom te leveren. Er verschijnt geen blok zolang een batterij niets kan leveren.",
+      "ahead": "De add-on plant ongeveer een dag vooruit. Blokken voor latere uren verschijnen als ze naderen."
+    },
     "region": {"preset": "Heffingen en btw: {region}, cijfers van {year}.", "own": "Heffingen en btw: uw eigen bedrag."},
     "peak_not_covered": "Geen piekgrens: deze meter meet geen kwartieren.",
     "control": {"shadow": "Schaduwmodus: elke omvormer blijft op 0 W.", "running": "De regeling is actief.", "stopped": "De regeling is gestopt. Elke omvormer staat op 0 W."},

goodwe_controller/app/web.py

@@ -150,6 +150,12 @@ def build_app(controller, selfcfg=None) -> web.Application:
             return web.json_response(controller.status_payload())
         return web.json_response(controller.status_payload(lang=lang))
 
+    async def forecast(request):
+        """UX-54: the Forecast tab's data, built when the tab asks. Reads only."""
+        build = getattr(controller, "forecast_payload", None)
+        lang = uitext.lang_of(request.query.get("lang"))
+        return web.json_response(build(lang=lang) if build else {"ok": False})
+
     async def action(request):
         try:
             body = await request.json()
@@ -471,6 +477,7 @@ def build_app(controller, selfcfg=None) -> web.Application:
     app.add_routes([
         web.get("/", index),
         web.get("/status", status),
+        web.get("/forecast", forecast),
         web.post("/action", action),
         web.get("/config", config_index),
         web.get("/config/model", config_model),

goodwe_controller/config.yaml

@@ -1,5 +1,5 @@
 name: GoodWe RS485 Controller
-version: "0.19.0"
+version: "0.19.1"
 slug: goodwe_controller
 description: >-
   Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a

goodwe_controller/test_home.py

@@ -831,10 +831,12 @@ check("the page is assembled: no placeholder is left and the words parse, "
       "/*APP_CSS*/" not in PAGE and "/*APP_JS*/" not in PAGE
       and "/*UI_TEXT*/" not in PAGE
       and _WORDS["en"]["home"] == UI and set(_WORDS) == {"en", "nl"})
-check("four tabs with the four hash routes, in a keyboard tablist",
+check("five tabs with the five hash routes, in a keyboard tablist (UX-54 "
+      "adds Forecast beside Home and Batteries)",
       re.findall(r'data-hash="(\w+)"', PAGE) == ["home", "batteries",
-                                                 "settings", "setup"]
-      and 'role="tablist"' in PAGE and PAGE.count('role="tabpanel"') == 4
+                                                 "forecast", "settings",
+                                                 "setup"]
+      and 'role="tablist"' in PAGE and PAGE.count('role="tabpanel"') == 5
       and "ArrowRight" in JS and "ArrowLeft" in JS)
 _ext = re.findall(r"""(?:https?:)?//[A-Za-z0-9.-]+\.[a-z]{2,}""", PAGE)
 check(f"no external file and no web font: no URL leaves the add-on "

goodwe_controller/test_modes_p4.py

@@ -540,6 +540,12 @@ rp.Hass.state = _sensor
 rp_start = [UTC0]
 FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
            "cycle_cost_threshold_eur": 0.20}
+# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
+# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
+# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
+# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
+# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
+GATE_030 = {"cycle_cost_threshold_eur": 0.30}
 
 
 def seed_profile(c):
@@ -597,7 +603,8 @@ def invariants(tag, rows, c):
 
 
 # Sunny: 40 kWh forecast. B (Leftover solar) at 30 % needs nothing.
-rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
+rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0},
+                       extra=GATE_030)
 charge = invariants("sunny", rows, c)
 _last = nth(rows, -1, "a cycle")
 print(f"    sunny: verdict {present(_last) and _last['plan'] and _last['plan'].verdict}, "
@@ -607,6 +614,35 @@ check("sunny: a day plan is made, and says sunny",
           for r in rows))
 check("sunny: no grid charge at all", not charge)
 
+# TARIFF-24 round 2: the same day at the cycle cost 0.20 itself. With the
+# forecast read the gap needed is 0.20 (not 1.5 x = 0.30), so the midday
+# quarter 0.339 against the evening 0.551 (gap 0.21, between 1x and 1.5x) is
+# a planned top-up for B (Leftover solar) up to its planned level.
+rows_g, st_, c_g = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
+charge_g = invariants("gap between 1x and 1.5x", rows_g, c_g)
+_first_g = nth(charge_g, 0, "a charge cycle")
+_gaps = [min(g.mean_eur_kwh for g in r["runs"].give)
+         - r["runs"].cheap.mean_eur_kwh for r in charge_g
+         if r["runs"] is not None and r["runs"].give]
+print(f"    gap 0.20 <= gap < 0.30: {len(charge_g)} charge cycles, run gap "
+      f"{min(_gaps, default=0):.3f}, B to "
+      f"{max((r['soc']['b'] for r in rows_g), default=0):.1f} %")
+check("a forecast day whose price gap lies between 1x and 1.5x the cycle "
+      "cost (0.20 < 0.21 < 0.30) plans a cheap run: B charges from the grid "
+      "inside it, only B, and only up to its planned level",
+      present(_first_g) and len(_gaps) == len(charge_g)
+      and all(0.20 <= g < 0.30 for g in _gaps)
+      and all(r["runs"].cheap.holds(r["now"]) for r in charge_g)
+      and all(r["roles"][B] == modetrade.CHARGE for r in charge_g)
+      and all(r["roles"][A] != modetrade.CHARGE for r in charge_g)
+      and max(r["soc"]["b"] for r in rows_g) <= 45.64 + 2.0)
+check("...and the same day with no forecast read does not (it needs 0.30): "
+      "the old gate, kept for a day without a forecast",
+      not [r for r in run_day(SF_LS, fc=None,
+                              soc0={"a": 60.0, "b": 30.0})[0]
+           if r["action"] == arbitrage.CHARGE
+           and r["now"].astimezone(L).hour == 12])
+
 # Dark: 1 kWh. B buys the evening's shortfall only, in the cheap run.
 rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0})
 charge = invariants("dark", rows, c)
@@ -623,7 +659,8 @@ check("dark: A rests while B charges", all(r["roles"][A] == modetrade.REST
                                            for r in charge))
 
 # Cheap hours on a partly sunny day: ignores the plan, fills as in P3.
-rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0})
+rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0},
+                       extra=GATE_030)
 charge = invariants("cheap hours, partly", rows, c)
 top = max(r["soc"]["b"] for r in rows)
 print(f"    cheap hours partly: B reached {top:.1f} %")
@@ -635,9 +672,24 @@ check("Cheap hours with a sun forecast charges as with none (P3)",
       and top > 80.0)
 
 # The forecast goes away mid-run: Leftover solar stops at once (P3 option A).
+# OPT-27: a sensor that is unavailable is covered by its last fresh reading
+# for up to 3 h (`solarfc.Hold`), so "lost" here is a hold that never covers;
+# the next scenario is the same loss with the hold (test_opt27.py).
 DROP = UTC0 + timedelta(hours=1, minutes=30)
+
+
+class _NoHold(solarfc.Hold):
+    def stand_in(self, *a, **k):
+        return None
+
+
+def seed_profile_no_hold(c):
+    seed_profile(c)
+    c.fc_hold = _NoHold()
+
+
 rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
-                       soc0={"a": 60.0, "b": 10.0})
+                       soc0={"a": 60.0, "b": 10.0}, patch=seed_profile_no_hold)
 invariants("forecast lost mid-run", rows, c)
 before = [r for r in rows if r["now"] < DROP and r["action"]
           == arbitrage.CHARGE]
@@ -645,10 +697,20 @@ late = [r for r in rows if r["now"] > DROP + timedelta(
     seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE]
 check("forecast lost mid-run: Leftover solar was charging, and stops within "
       "a forecast read (60 s) and a cycle", before and not late)
+rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
+                       soc0={"a": 60.0, "b": 10.0})
+invariants("forecast unavailable mid-run, covered", rows, c)
+check("forecast unavailable mid-run (OPT-27): the last reading covers it, so "
+      "Leftover solar goes on charging past the point where it was lost",
+      [r for r in rows if r["now"] < DROP and r["action"]
+       == arbitrage.CHARGE]
+      and [r for r in rows if r["now"] > DROP + timedelta(
+          seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE])
 
 # The forecast is far too high (40 kWh, and there is no sun at all): no grid
 # charge, so B covers less of the evening - a money risk, never a safety one.
-rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0})
+rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0},
+                       extra=GATE_030)
 invariants("forecast too high", rows, c)
 check("forecast too high: no grid charge, and B still keeps its power for "
       "the dear run", not [r for r in rows if r["action"]
@@ -658,7 +720,7 @@ check("forecast too high: no grid charge, and B still keeps its power for "
 
 # A refusal wins over the plan.
 rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
-                       refuse=("b",))
+                       refuse=("b",), extra=GATE_030)
 invariants("refusal", rows, c)
 check("refusal: B refuses to charge, so the plan's charge ends and B is "
       "never a charger after it", rows and not [

goodwe_controller/test_opt27.py

@@ -0,0 +1,548 @@
+"""Runnable check for OPT-27.  `python3 test_opt27.py`
+
+Forecast.Solar's sensors stop changing in the evening, so at night every
+Forecast.Solar site was "no forecast": a price mode's night cheap run needed
+1.5x the cycle cost and Leftover solar bought nothing. And one missed poll
+(`unavailable`) dropped the forecast at once. `solarfc.Hold` now keeps the last
+fresh reading of each sensor, for the day it is FOR:
+
+* up to `FRESH_S` when the sensor is missing or unavailable (a short outage);
+* from the end of the bell (20:00) until local midnight + 3 h however old it
+  is (the night plan); never beyond, never for another day.
+
+DECISIONS/OPT-27-last-fresh-forecast-for-the-night.md.
+
+1. `solarfc` alone: the evening, the outage, the bounds, the day a figure is
+   for, restart (dump/load), and no hold = as before.
+2. The real Controller on a day/night tariff (0.34/0.26, gap 0.08, cycle cost
+   0.07), forecast sensors that stop updating at 17:05 local:
+   a. the 22:00 night run is planned with the cycle-cost gap and charges;
+   b. no forecast all day: the night run still needs 1.5x and does not charge;
+   c. an evening restart keeps it (a new Controller on the saved store);
+   d. a one-hour outage at 18:47 does not drop it;
+   e. past midnight + 3 h the figure is not used, before it it is.
+3. The screens: the forecast line says when it was read and that it is used
+   for tonight's plan (EN and NL), and Home agrees with control.
+
+Mutations (MUTATION.md, purged copies, graded over this file): see the
+DECISIONS note and the dev report.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import tempfile
+import time
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+import opt11p3_replay as rp                                    # noqa: E402
+from named_absence import first, nth, present                  # noqa: E402
+import app.main as m                                           # noqa: E402
+from app import homeview, modetrade, solarfc                   # noqa: E402
+from app.main import Controller                                # noqa: E402
+from app.p1 import make_sample, split_signed                   # noqa: E402
+from app.store import unit_key                                 # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+L = timezone(timedelta(hours=1))             # Brussels in winter (CET)
+
+
+def at(day, hh, mm=0):
+    """Local time on 2026-11-`day` (CET) as UTC."""
+    return datetime(2026, 11, day, hh, mm, tzinfo=L).astimezone(timezone.utc)
+
+
+def st(kwh, when, *, unit="kWh"):
+    return {"state": f"{kwh}", "attributes": {"unit_of_measurement": unit},
+            "last_updated": when.isoformat(),
+            "last_reported": when.isoformat()}
+
+
+GONE = {"state": "unavailable", "attributes": {}}
+T_ENT, M_ENT = "sensor.fc_today", "sensor.fc_tomorrow"
+
+# --------------------------------------------------------------------------- #
+print("1. solarfc: the hold")
+D1_READ = at(3, 17, 5)                       # the last fresh reading, 17:05
+EVE = at(3, 22, 0)
+
+
+def rs(today, tomorrow, now, hold):
+    return solarfc.read_sum([(T_ENT, today)], [(M_ENT, tomorrow)], now, hold)
+
+
+h = solarfc.Hold()
+fc, why, gaps = rs(st(0.4, D1_READ), st(12.0, D1_READ), at(3, 17, 10), h)
+check("a fresh reading is a forecast, not kept", fc is not None
+      and not fc.kept and fc.tomorrow.kwh == 12.0 and fc.today.kwh == 0.4)
+check("it is remembered (the hold is flagged for saving)", h.changed)
+fc_no, why_no, _g = rs(st(0.4, D1_READ), st(12.0, D1_READ), EVE, None)
+check("with no hold, 22:00 is no forecast (as before)",
+      fc_no is None and why_no == solarfc.STALE)
+fc, why, gaps = rs(st(0.4, D1_READ), st(12.0, D1_READ), EVE, h)
+print(f"    22:00, sensors still show 17:05: {fc and fc.kept=}, {gaps=}")
+check("22:00 with the sensors stale since 17:05: the 17:05 figures are used",
+      fc is not None and fc.kept and fc.tomorrow.kwh == 12.0
+      and fc.at == D1_READ and gaps == ())
+check("... today has no sun left in it, tomorrow's is counted from 06:00",
+      fc is not None and fc.between(EVE, at(4, 7, 0)) is not None
+      and 0.0 < fc.between(EVE, at(4, 7, 0)) < 0.5
+      and fc.today.kwh == 0.4)
+fc2, _w, _g = rs(GONE, GONE, EVE, h)
+check("the same when the sensors are unavailable at 22:00",
+      fc2 is not None and fc2.kept and fc2.tomorrow.kwh == 12.0)
+# A new fresh reading replaces the old one at once.
+fc3, _w, _g = rs(st(0.0, at(3, 22, 20)), st(14.5, at(3, 22, 20)),
+                 at(3, 22, 30), h)
+check("a newer fresh reading is used and is not 'kept'",
+      fc3 is not None and not fc3.kept and fc3.tomorrow.kwh == 14.5)
+fc3b, _w, _g = rs(st(0.4, D1_READ), st(12.0, D1_READ), at(3, 23, 0), h)
+check("... and later the newest reading is the one kept, not the old one",
+      fc3b is not None and fc3b.tomorrow.kwh == 14.5)
+
+# A short outage: unavailable for one or two polls, any time of day.
+h2 = solarfc.Hold()
+rs(st(1.1, at(3, 18, 5)), st(12.0, at(3, 18, 5)), at(3, 18, 6), h2)
+for label, now in (("18:47", at(3, 18, 47)), ("19:20", at(3, 19, 20)),
+                   ("19:47", at(3, 19, 47)), ("20:55", at(3, 20, 55))):
+    fo, _w, _g = rs(GONE, GONE, now, h2)
+    check(f"unavailable at {label}: the 18:05 forecast is still used",
+          fo is not None and fo.tomorrow.kwh == 12.0)
+fo, _w, _g = rs(GONE, GONE, at(3, 20, 55), solarfc.Hold())
+check("(nothing was ever read: still no forecast)", fo is None)
+# Daytime is as before: an outage longer than FRESH_S drops it.
+h3 = solarfc.Hold()
+rs(st(6.0, at(4, 9, 5)), st(12.0, at(4, 9, 5)), at(4, 9, 6), h3)
+d_in = rs(GONE, GONE, at(4, 11, 50), h3)[0]
+d_out = rs(GONE, GONE, at(4, 12, 10), h3)[0]
+d_out2 = rs(st(6.0, at(4, 9, 5)), st(12.0, at(4, 9, 5)), at(4, 14, 0), h3)[0]
+check("daytime: an outage under 3 h is covered, one over 3 h is not",
+      d_in is not None and not d_in.kept and d_out is None)
+check("daytime: a sensor that stopped is stale after 3 h, as before "
+      "(the hold does not start before the bell ends)", d_out2 is None)
+
+# Round 2: today fresh, tomorrow's sensor stopped or down in the daytime.
+h9 = solarfc.Hold()
+rs(st(5.0, at(4, 9, 5)), st(12.0, at(4, 9, 5)), at(4, 9, 6), h9)
+for label, tm in (("stale", st(12.0, at(4, 9, 5))), ("unavailable", GONE)):
+    fd = rs(st(3.0, at(4, 13, 55)), tm, at(4, 14, 0), h9)[0]
+    check(f"14:00, today fresh, tomorrow {label} since 09:05 (over 3 h): "
+          "no tomorrow, nothing kept",
+          fd is not None and fd.tomorrow is None and not fd.kept)
+    fn = rs(st(0.1, at(4, 20, 55)), tm, at(4, 21, 0), h9)[0]
+    check(f"21:00, tomorrow {label}: the 09:05 figure covers it, kept",
+          fn is not None and fn.tomorrow is not None
+          and fn.tomorrow.kwh == 12.0 and fn.kept)
+    fs = rs(st(3.0, at(4, 10, 55)), tm, at(4, 11, 0), h9)[0]
+    check(f"11:00, tomorrow {label} for under 3 h: still covered, not kept",
+          fs is not None and fs.tomorrow is not None and not fs.kept)
+
+# The bound: midnight + 3 h, and the day a figure is for.
+fm = rs(st(0.0, at(3, 23, 0)), st(0.0, at(3, 23, 0)), at(4, 1, 0), h2)[0]
+check("00:30 is covered by the 18:05 tomorrow figure, as TODAY's",
+      rs(GONE, GONE, at(4, 0, 30), h2)[0] is not None)
+fmid = rs(GONE, GONE, at(4, 2, 59), h2)[0]
+print(f"    02:59: {fmid and (fmid.today.kwh, fmid.tomorrow, fmid.kept)}")
+check("02:59: tomorrow's 12.0 kWh is now today's, there is no tomorrow",
+      fmid is not None and fmid.today.kwh == 12.0 and fmid.tomorrow is None
+      and fmid.kept and fmid.today.day0 == at(4, 0, 0))
+check("... its sun is counted on the day it is for (06:00-20:00 on the 4th)",
+      fmid is not None and fmid.between(at(4, 3, 0), at(4, 7, 0)) is not None
+      and fmid.between(at(4, 3, 0), at(4, 7, 0)) > 0.0)
+check("03:01 (midnight + 3 h): not used any more",
+      rs(GONE, GONE, at(4, 3, 1), h2)[0] is None)
+check("... and not the next evening either (older than one night)",
+      rs(GONE, GONE, at(4, 22, 0), h2)[0] is None)
+fe = rs(st(0.1, at(4, 21, 50)), GONE, at(4, 22, 0), h2)[0]
+check("... the next evening, with today fresh and tomorrow's sensor down, "
+      "there is no tomorrow: the 4th's figure is not the 5th's",
+      fe is not None and fe.today.kwh == 0.1 and fe.tomorrow is None)
+# Never today's figure for tomorrow.
+h4 = solarfc.Hold()
+rs(st(3.0, at(3, 17, 0)), st(12.0, at(3, 17, 0)), at(3, 17, 5), h4)
+# Next day 00:30: today's sensor is fresh again (4.0), tomorrow's is gone.
+fx = rs(st(4.0, at(4, 0, 20)), GONE, at(4, 0, 30), h4)[0]
+check("00:30: today is the fresh 4.0, and there is NO tomorrow "
+      "(the 3rd's 'today' 3.0 and 'tomorrow' 12.0 are not the 5th's)",
+      fx is not None and fx.today.kwh == 4.0 and fx.tomorrow is None
+      and not fx.kept)
+fy = rs(st(4.0, at(4, 0, 20)), st(9.0, at(4, 0, 20)), at(4, 0, 30), h4)[0]
+check("00:30 with both fresh: tomorrow is the fresh 9.0, not the old 12.0",
+      fy is not None and fy.tomorrow.kwh == 9.0 and not fy.kept)
+# A tomorrow sensor that is down while today's is fresh, in the evening: the
+# hold gives the tomorrow figure for tomorrow, never today's figure.
+h5 = solarfc.Hold()
+rs(st(3.0, at(3, 17, 0)), st(12.0, at(3, 17, 0)), at(3, 17, 5), h5)
+fz = rs(st(0.2, at(3, 21, 30)), GONE, at(3, 21, 40), h5)[0]
+check("21:40: today fresh, tomorrow down: tomorrow is the kept 12.0 (not "
+      "today's 0.2 or 3.0)", fz is not None and fz.tomorrow.kwh == 12.0
+      and fz.today.kwh == 0.2 and fz.kept)
+# A set-up fault is never covered.
+h6 = solarfc.Hold()
+rs(st(3.0, at(3, 17, 0)), st(12.0, at(3, 17, 0)), at(3, 17, 5), h6)
+fb = rs(st("lots", at(3, 21, 30)), st(12.0, at(3, 21, 30)),
+        at(3, 21, 40), h6)
+fu = rs(st(0.2, at(3, 21, 30), unit="W"), st(12.0, at(3, 21, 30)),
+        at(3, 21, 40), h6)
+check("a bad value or a wrong unit is not covered by the hold",
+      fb[0] is None and fb[1] == solarfc.BAD and fu[0] is None
+      and fu[1] == solarfc.UNIT)
+# Several sensors: all or nothing.
+h7 = solarfc.Hold()
+two_t = [("sensor.t1", st(1.0, at(3, 17, 0))),
+         ("sensor.t2", st(2.0, at(3, 17, 0)))]
+two_m = [("sensor.m1", st(5.0, at(3, 17, 0))),
+         ("sensor.m2", st(6.0, at(3, 17, 0)))]
+solarfc.read_sum(two_t, two_m, at(3, 17, 5), h7)
+gone2 = [("sensor.t1", GONE), ("sensor.t2", GONE)]
+f2 = solarfc.read_sum(gone2, [("sensor.m1", GONE), ("sensor.m2", GONE)],
+                      at(3, 22, 0), h7)
+check("three or two sensors: the kept figures are summed",
+      f2[0] is not None and f2[0].tomorrow.kwh == 11.0
+      and f2[0].today.kwh == 3.0 and f2[2] == ())
+h8 = solarfc.Hold()
+solarfc.read_sum(two_t[:1] + [("sensor.t2", GONE)], two_m, at(3, 17, 5), h8)
+f3 = solarfc.read_sum(gone2, [("sensor.m1", GONE), ("sensor.m2", GONE)],
+                      at(3, 22, 0), h8)
+check("one sensor never read fresh: no partial sum, the gap is named",
+      f3[0] is None and any(g[:3] == ("today", 2, "sensor.t2") for g in f3[2]))
+# Restart: what the store holds comes back.
+saved = json.loads(json.dumps(h.dump()))
+hr = solarfc.Hold(saved)
+fr = rs(GONE, GONE, at(3, 23, 0), hr)[0]
+check("dump/load through JSON: the kept figures come back (40 min old: "
+      "inside FRESH_S, so not 'kept' in the screens' sense)",
+      fr is not None and not fr.kept and fr.tomorrow.kwh == 14.5
+      and fr.at == at(3, 22, 20))
+junk = solarfc.Hold({"r": [["today", 7, "x", "y", "z", []],
+                           ["tomorrow", T_ENT, "2026-11-04T00:00:00+00:00",
+                            -1, "2026-11-03T16:00:00+00:00", []],
+                           "bad", None]})
+check("a damaged store entry is dropped, not raised",
+      rs(GONE, GONE, at(3, 22, 0), junk)[0] is None
+      and solarfc.Hold(None).dump()["r"] == [] and solarfc.Hold(5).changed
+      is False)
+hp = solarfc.Hold()
+rs(st(8.0, at(3, 9, 0), ), st(12.0, at(3, 9, 0)), at(3, 9, 5), hp)
+periods = [{"period_start": f"2026-11-04T{hh:02d}:00:00+01:00",
+            "pv_estimate": 1.0} for hh in range(8, 16)]
+s_per = st(10.0, at(3, 17, 0))
+s_per["attributes"]["detailedForecast"] = periods
+rs(st(0.0, at(3, 17, 0)), s_per, at(3, 17, 5), hp)
+hq = solarfc.Hold(json.loads(json.dumps(hp.dump())))
+fq = rs(GONE, GONE, at(3, 22, 0), hq)[0]
+check("an hourly split (Solcast shape) survives the store",
+      fq is not None and fq.tomorrow.periods
+      and abs(fq.between(at(4, 8, 0), at(4, 16, 0)) - 7.5) < 1e-6)
+
+# --------------------------------------------------------------------------- #
+print("\n2. The real Controller: day/night 0.34 / 0.26, cycle cost 0.07")
+A, B = "inverter-a", "inverter-b"
+PROFILE = ('{"periods": ['
+           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
+           ' "eur_per_kwh": 0.26},'
+           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
+           ' "eur_per_kwh": 0.34}]}')
+CHOICE = {"a": (True, "leftover_solar", False),
+          "b": (True, "cheap_hours", False)}
+DAY3 = 3
+
+
+def opts(cost=0.07):
+    o = dict(rp.options(True, False, 2))
+    o.update(cycle_cost_threshold_eur=cost, static_profile=PROFILE,
+             pv_forecast_entity=T_ENT, pv_forecast_tomorrow_entity=M_ENT)
+    return o
+
+
+def stops_at(last, *, down=()):
+    """Sensors that update until `last` and then show that reading for
+    good. `down`: (from, to) windows in which they are unavailable."""
+    def f(now, ent):
+        for a, z in down:
+            if a <= now < z:
+                return GONE
+        when = min(now, last)
+        return st(0.4 if ent == T_ENT else 12.0, when)
+    return f
+
+
+def never(now, ent):
+    return st(0.0 if ent == T_ENT else 12.0, now - timedelta(hours=9))
+
+
+def drive27(o, sensors, *, pre, start, minutes=20, restart=None,
+            keep_store=True, snap=False):
+    """-> (controller, rows, pre_rows). `pre`: the times the forecast is read
+    before the first cycle (the evening). `restart`: a time in `pre` at which
+    the add-on restarts: a new Controller on the saved store."""
+    store = rp._Store()
+    for u, (use, mode, sell) in CHOICE.items():
+        for k, val in (("pack_use", use), ("pack_mode", mode),
+                       ("pack_sell", sell)):
+            store.data[unit_key(f"inverter-{u}", k)] = val
+    clock = [pre[0] if pre else start]
+    rows, pre_rows = [], []
+    cur = [store]
+
+    class H(rp.Hass):
+        async def state(self, e):
+            return sensors(clock[0], e)
+
+    def build(store):
+        hass = H(("a", "b"), lambda t: 300.0, {"a": 40.0, "b": 40.0})
+        tmp = tempfile.mkdtemp(prefix="o27-")
+        c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
+                       peak_db_path=os.path.join(tmp, "tariff.db"),
+                       price_history_path=os.path.join(tmp, "ph.json"))
+        for i in c.inverters:
+            i.dev_min, i.dev_max = -5000.0, 5000.0
+        c.auto = True
+        # A house profile a few days old (300 W round the clock), so the day
+        # plan is made as it is on a site that has run for a week.
+        c.house_profile.load({d: {str(hh): 300.0 for hh in range(24)}
+                              for d in ("2026-10-31", "2026-11-01",
+                                        "2026-11-02")})
+        return c, hass
+
+    async def go():
+        c, hass = build(store)
+        real_dt, real_hv = m.datetime, homeview.datetime
+
+        class _DT(real_dt):
+            @classmethod
+            def now(cls, tz=None):
+                return clock[0] if tz is None else clock[0].astimezone(tz)
+
+        m.datetime = homeview.datetime = _DT
+        task = None
+        try:
+            for t_pre in pre:
+                clock[0] = t_pre
+                if restart is not None and t_pre == restart:
+                    # The saved file, through JSON; `keep_store=False` loses
+                    # the hold only (the control for the test).
+                    data = json.loads(json.dumps(cur[0].data))
+                    if not keep_store:
+                        data.pop(m.FC_HOLD_KEY, None)
+                    new = rp._Store()
+                    new.data.update(data)
+                    cur[0] = new
+                    c, hass = build(new)
+                await c._read_forecast()
+                pre_rows.append((t_pre, c.solar_fc is not None,
+                                 bool(c.solar_fc and c.solar_fc.kept)))
+            clock[0] = start
+            task = asyncio.create_task(c.run_tariff_refresh())
+            t = 0.0
+            while t < minutes * 60:
+                now = start + timedelta(seconds=t)
+                hass.t = t
+                clock[0] = now
+                if t == 0.0:
+                    for _ in range(500):
+                        if c.tariff_plan is not None and (
+                                c.tariff_at is not None and c.tariff_at >= now):
+                            break
+                        await asyncio.sleep(0)
+                imp, exp = split_signed(hass.grid())
+                c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
+                                        ingest_ts=now,
+                                        ingest_mono=time.monotonic()))
+                await c.read_inputs(now_mono=t)
+                await c.cycle()
+                hass.advance(5.0, 10.0)
+                rp_ = c.mode_runs
+                rows.append(dict(
+                    t=t, fc_none=c.solar_fc is None,
+                    kept=bool(c.solar_fc and c.solar_fc.kept),
+                    runs_on=None if rp_ is None else rp_.on,
+                    reason=None if rp_ is None else rp_.reason,
+                    roles=dict(c.mode_tick.roles) if c.mode_tick else {},
+                    charging=hass.plants["b"].p < -200.0,
+                    soc_b=hass.plants["b"].soc))
+                t += 5.0
+            keep = c.o
+            c.o = dict(keep, arbitrage_enabled=True)
+            try:
+                c.mirror, c.mirror_why = homeview.trade_verdict(
+                    c, c.fresh_tariff_plan(clock[0]), clock[0])
+            finally:
+                c.o = keep
+            c.cards = homeview.battery_rows(c, False, True)
+            c.block = homeview.solar_block(c, clock[0])
+            c.hold_saved = json.loads(json.dumps(cur[0].data.get(
+                m.FC_HOLD_KEY)))
+        finally:
+            if task is not None:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+            m.datetime, homeview.datetime = real_dt, real_hv
+        return c
+
+    return asyncio.run(go()), rows, pre_rows
+
+
+def why_of(c, name):
+    card = first((b for b in c.cards if b["name"] == name), f"card {name}")
+    return card["why_key"]
+
+
+EVENING = [at(DAY3, 16, 0) + timedelta(minutes=30 * i) for i in range(12)]
+LAST = at(DAY3, 17, 5)
+NIGHT_START = at(DAY3, 22, 0)
+
+# a. a forecast that stops updating at sunset
+ca, ra, pa = drive27(opts(), stops_at(LAST), pre=EVENING + [at(DAY3, 21, 55)],
+                     start=NIGHT_START)
+la = nth(ra, -1, "last cycle")
+print(f"    a. 22:00 with the 17:05 forecast: kept={la['kept']} on="
+      f"{la['runs_on']} reason={la['reason']}; B charging "
+      f"{sum(r['charging'] for r in ra)} of {len(ra)}; Why A {why_of(ca, A)} "
+      f"B {why_of(ca, B)}; Home mirror {ca.mirror}")
+check("the forecast was read fresh before 17:05 and kept after it",
+      any(not k for _t, ok, k in pa if _t <= LAST + timedelta(minutes=30))
+      and all(ok for _t, ok, _k in pa)
+      and all(k for _t, _ok, k in pa if _t >= at(DAY3, 20, 15)))
+check("22:00 night run: planned with the cycle-cost gap (needs 0.07 < 0.08)",
+      present(la) and not la["fc_none"] and la["kept"]
+      and la["runs_on"] is True and la["reason"] != "not_worth")
+check("... and B (Cheap hours) charges from the grid in the night period",
+      sum(r["charging"] for r in ra) > len(ra) // 2
+      and la["roles"].get(B) == modetrade.CHARGE
+      and why_of(ca, A) != "no_spread" and why_of(ca, B) != "no_spread")
+check("the day plan is made from the kept forecast (levels for Leftover "
+      "solar), as it is from a fresh one",
+      ca.day_plan is not None and ca.plan_targets() is not None
+      and ca.block["state"] == "plan")
+check("Home's mirror of the gate allows it, as control does",
+      ca.mirror is not None and ca.mirror_why == "allowed")
+
+# b. no forecast all day
+cb, rb, pb = drive27(opts(), never, pre=EVENING + [at(DAY3, 21, 55)],
+                     start=NIGHT_START)
+lb = nth(rb, -1, "last cycle")
+print(f"    b. no forecast all day: on={lb['runs_on']} reason={lb['reason']}; "
+      f"B charging {sum(r['charging'] for r in rb)}; Why A {why_of(cb, A)} "
+      f"B {why_of(cb, B)}")
+check("with no forecast all day the night run still needs 1.5x (0.105 > 0.08)"
+      ": not worth, no charge, 'Prices differ too little'",
+      present(lb) and lb["fc_none"] and lb["runs_on"] is False
+      and lb["reason"] == "not_worth"
+      and not any(r["charging"] for r in rb)
+      and why_of(cb, A) == "no_spread" and why_of(cb, B) == "no_spread"
+      and not any(ok for _t, ok, _k in pb))
+check("... and there is no day plan (Leftover solar takes solar only)",
+      cb.day_plan is None and cb.plan_targets() is None
+      and cb.block["state"] == "no_forecast")
+check("... Home's mirror refuses it too, for the gap ('not_worth')",
+      cb.mirror is None and cb.mirror_why == "not_worth")
+check("... and nothing is saved for the night (no fresh reading was made)",
+      cb.hold_saved is None or cb.hold_saved.get("r") == [])
+
+# c. an evening restart
+cc, rc, pc = drive27(opts(), stops_at(LAST),
+                     pre=EVENING + [at(DAY3, 21, 55)], start=NIGHT_START,
+                     restart=at(DAY3, 21, 55))
+lc = nth(rc, -1, "last cycle")
+check("an evening restart (new Controller on the saved store) keeps the "
+      "forecast: the night run is planned and charges",
+      present(lc) and lc["kept"] and lc["runs_on"] is True
+      and sum(r["charging"] for r in rc) > len(rc) // 2
+      and present(nth(pc, -1, "last read")) and pc[-1][1] and pc[-1][2])
+cc0, rc0, pc0 = drive27(opts(), stops_at(LAST),
+                        pre=EVENING + [at(DAY3, 21, 55)], start=NIGHT_START,
+                        restart=at(DAY3, 21, 55), keep_store=False)
+lc0 = nth(rc0, -1, "last cycle")
+check("(control: the same restart with the store lost is blind, 1.5x)",
+      present(lc0) and lc0["fc_none"] and lc0["runs_on"] is False
+      and present(nth(pc0, -1, "last read")) and not pc0[-1][1])
+
+# d. a one-hour outage at 18:47
+OUT = (at(DAY3, 18, 47), at(DAY3, 19, 47))
+quarter = [at(DAY3, 16, 0) + timedelta(minutes=15 * i) for i in range(24)]
+cd, rd, pd = drive27(opts(), stops_at(at(DAY3, 18, 5), down=[OUT]),
+                     pre=quarter + [at(DAY3, 21, 55)], start=NIGHT_START)
+ld = nth(rd, -1, "last cycle")
+inside = [(t_, ok) for t_, ok, _k in pd if OUT[0] <= t_ < OUT[1]]
+print(f"    d. reads inside the outage: {len(inside)}, with a forecast: "
+      f"{sum(ok for _t, ok in inside)}")
+check("a one-hour outage at 18:47 does not drop the forecast "
+      "(every read from 16:00 to 22:00 has one)",
+      present(pd) and len(inside) >= 4 and all(ok for _t, ok, _k in pd))
+check("... and the 22:00 night run is planned and charges",
+      present(ld) and ld["runs_on"] is True
+      and sum(r["charging"] for r in rd) > len(rd) // 2)
+
+# e. the bound: midnight + 3 h
+mid = [at(DAY3, 16, 0) + timedelta(minutes=30 * i) for i in range(12)]
+ce, re_, pe = drive27(opts(), stops_at(LAST), pre=mid + [at(4, 2, 30)],
+                      start=at(4, 2, 30))
+le = nth(re_, -1, "last cycle")
+check("02:30 (before midnight + 3 h): the figure from 17:05 is still used, "
+      "as today's; the night run is planned",
+      present(le) and le["kept"] and le["runs_on"] is True)
+cf, rf, pf = drive27(opts(), stops_at(LAST), pre=mid + [at(4, 3, 30)],
+                     start=at(4, 3, 30))
+lf = nth(rf, -1, "last cycle")
+check("03:30 (after midnight + 3 h): a figure from before the night is not "
+      "used: no forecast, 1.5x, not worth, no charge",
+      present(lf) and lf["fc_none"] and lf["runs_on"] is False
+      and lf["reason"] == "not_worth" and not any(r["charging"] for r in rf))
+
+# --------------------------------------------------------------------------- #
+print("\n3. The screens")
+blk = ca.block
+print(f"    forecast line: {blk['line']!r} (state {blk['state']})")
+check("the forecast line says when it was read and that it is used for "
+      "tonight's plan", blk["line"] == "Solar forecast read 17:05, used for "
+      "tonight's plan.")
+check("the same line comes from the Forecast tab (dayview) on today",
+      homeview.line_solar(0.4, 0.3, "17:05", kept=True) == blk["line"]
+      and homeview.line_solar(0.4, 0.3, "17:05").startswith(
+          "Solar still to come today"))
+en = json.load(open(os.path.join(HERE, "app", "ui_text", "en.json"),
+                    encoding="utf-8"))
+nl = json.load(open(os.path.join(HERE, "app", "ui_text", "nl.json"),
+                    encoding="utf-8"))
+k_en = en["home_words"]["solar"]["kept"]
+k_nl = nl["home_words"]["solar"]["kept"]
+print(f"    EN {k_en!r}\n    NL {k_nl!r}")
+check("EN and NL both say it, with the time, and the NL is not the English",
+      "{at}" in k_en and "{at}" in k_nl and k_en != k_nl
+      and "plan" in k_en and "vanavond" in k_nl)
+check("a daytime reading keeps the old line (daytime unchanged)",
+      "Updated 09:05" in homeview.line_solar(1.0, 0.7, "09:05")
+      and "Bijgewerkt" in json.dumps(nl["home_words"]["solar"]["line"]))
+check("no forecast: the old 'No solar forecast now' line, no 'kept'",
+      cb.block["state"] == "no_forecast"
+      and "tonight" not in cb.block["line"])
+check("control and Batteries screen agree on the 22:00 run: not 'no_spread'",
+      why_of(ca, A) != "no_spread" and why_of(ca, B) != "no_spread"
+      and la["runs_on"] is True)
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print("  -", f)
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_selfconfig.py

@@ -636,10 +636,12 @@ _app = web.build_app(FakeController(), FakeSupervisor())
 _routes = sorted({(r.method, r.get_info().get("path"))
                   for r in _app.router.routes() if r.method != "HEAD"})
 print("    " + "  ".join(f"{m} {p}" for m, p in _routes))
-check("the configuration surface adds five routes and UX-13 one GET, and "
-      "none touches the three that were there",
+check("the configuration surface adds five routes, UX-13 one GET and "
+      "UX-54 one more GET (the Forecast tab), and none touches the three "
+      "that were there",
       _routes == [("GET", "/"), ("GET", "/config"), ("GET", "/config/model"),
-                  ("GET", "/ha/entities"), ("GET", "/status"),
+                  ("GET", "/forecast"), ("GET", "/ha/entities"),
+                  ("GET", "/status"),
                   ("POST", "/action"), ("POST", "/config/restart"),
                   ("POST", "/config/save"), ("POST", "/config/validate")])
 _ents_src = io.open(os.path.join(HERE, "app", "haentities.py"),

goodwe_controller/test_tariff24.py

@@ -0,0 +1,374 @@
+"""Runnable check for TARIFF-24.  `python3 test_tariff24.py`
+
+Battery modes on, a day/night `static_profile`, no price feed and the site trade
+switch off used to start no tariff task: `Controller.tariff_plan` stayed None,
+`mode_runs` stayed None, Leftover solar and Cheap hours never charged from the
+grid, and the Batteries screen said "No prices" while Home priced the day from
+the profile itself. DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
+
+1. The startup gate: `tariff_refresh_wanted()` by configuration, and the guard
+   `amain()` really puts on the task (read from its source, not retyped).
+2. End to end, on the real Controller and the real `run_tariff_refresh()` task,
+   started only if `amain()`'s own guard says so: night period, one battery
+   Leftover solar and one Cheap hours.
+3. The same with a gap below the cycle cost.
+4. Home and the Batteries screen agree.
+5. UX-55: with every battery Solar first Home no longer says "no prices have
+   arrived" on a static profile, and still does with no profile and no feed.
+6. Nothing else moved: modes off starts no task; the gate rows in part 1 keep
+   the arbitrage and feed cases as before.
+
+Mutations (MUTATION.md, purged copies, graded over this file): the gate
+reverted to `provider or arbitrage` fails 18 checks in parts 1 to 5; `True`
+fails the modes-off rows; `bool(opts.get(...))` fails the exact-true row;
+dropping the arbitrage term fails the arbitrage rows.
+"""
+
+import ast
+import asyncio
+import logging
+import os
+import sys
+import tempfile
+import time
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+import opt11p3_replay as rp                                    # noqa: E402
+from named_absence import first, nth, present                  # noqa: E402
+import app.main as m                                           # noqa: E402
+from app import homeview, modetrade, packmode                  # noqa: E402
+from app import price as _price, static_tariff as _st          # noqa: E402
+from app.main import Controller, tariff_refresh_wanted         # noqa: E402
+from app.p1 import make_sample, split_signed                   # noqa: E402
+from app.store import unit_key                                 # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+A, B = "inverter-a", "inverter-b"
+
+# A Belgian-style day/night tariff, example values: dear 07:00-22:00, cheap
+# 22:00-07:00, every day. The gap is 0.08 EUR/kWh.
+PROFILE = ('{"periods": ['
+           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
+           ' "eur_per_kwh": 0.22},'
+           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
+           ' "eur_per_kwh": 0.30}]}')
+# A Friday in winter time (+01:00), 23:00 local: inside the night period.
+L = timezone(timedelta(hours=1))
+NIGHT = datetime(2026, 10, 30, 23, 0, tzinfo=L).astimezone(timezone.utc)
+
+
+def opts(*, modes=True, arb=False, profile=PROFILE, provider=None,
+         cost=0.05):
+    o = dict(rp.options(modes, arb, 2))
+    o["cycle_cost_threshold_eur"] = cost
+    if profile is not None:
+        o["static_profile"] = profile
+    if provider is not None:
+        o["price_provider"] = provider
+    return o
+
+
+# --------------------------------------------------------------------------- #
+# The guard amain() puts on the tariff task, read from amain()'s source.
+# --------------------------------------------------------------------------- #
+def _guards_of(node, guards=()):
+    """[(guards, coroutine name)] for every create_task(...) under `node`."""
+    out = []
+    for child in ast.iter_child_nodes(node):
+        if isinstance(child, ast.If):
+            test = ast.unparse(child.test)
+            for stmt in child.body:
+                out += _guards_of(stmt, guards + (test,))
+            for stmt in child.orelse:
+                out += _guards_of(stmt, guards + (f"not ({test})",))
+            continue
+        if isinstance(child, ast.Call) and \
+                ast.unparse(child.func).endswith("create_task") and child.args:
+            arg = child.args[0]
+            name = (arg.func.attr if isinstance(arg, ast.Call)
+                    and isinstance(arg.func, ast.Attribute)
+                    else ast.unparse(arg))
+            out.append((guards, name))
+            continue
+        out += _guards_of(child, guards)
+    return out
+
+
+_TREE = ast.parse(open(os.path.join(HERE, "app", "main.py"),
+                       encoding="utf-8").read())
+_AMAIN = first((n for n in ast.walk(_TREE)
+                if isinstance(n, ast.AsyncFunctionDef) and n.name == "amain"),
+               "amain() in main.py")
+_TASK_GUARDS = [g for g, n in _guards_of(_AMAIN) if n == "run_tariff_refresh"]
+
+
+def task_started(o) -> bool:
+    """Would amain() start the tariff refresh task for options `o`?"""
+    if len(_TASK_GUARDS) != 1:
+        return False
+    return all(bool(eval(g, vars(m), {"opts": o})) for g in _TASK_GUARDS[0])
+
+
+# --------------------------------------------------------------------------- #
+print("1. the startup gate")
+check("amain() starts the tariff refresh from exactly one guard, and that "
+      "guard can be decided from the options alone",
+      len(_TASK_GUARDS) == 1 and len(_TASK_GUARDS[0]) >= 1
+      and all(isinstance(eval(g, vars(m), {"opts": opts()}), bool)
+              for g in _TASK_GUARDS[0]))
+GATE = [
+    # label, options, task wanted
+    ("modes on + static day/night only", opts(), True),
+    ("modes on + a fixed price only",
+     opts(profile='{"periods": [{"name": "all", "days": "all", "from": '
+                  '"00:00", "to": "24:00", "eur_per_kwh": 0.27}]}'), True),
+    ("modes on, nothing else", opts(profile=None), True),
+    ("modes off + arbitrage off + no feed (static profile)",
+     opts(modes=False), False),
+    ("modes off + arbitrage off + no feed, no profile",
+     opts(modes=False, profile=None), False),
+    ("modes off + arbitrage on", opts(modes=False, arb=True), True),
+    ("modes off + a feed", opts(modes=False, provider="generic_dayahead"),
+     True),
+    ("modes on + a feed", opts(provider="generic_dayahead"), True),
+    ("modes on + arbitrage on", opts(arb=True), True),
+]
+for label, o, want in GATE:
+    got = tariff_refresh_wanted(o)
+    print(f"    wanted={got!s:5}  started={task_started(o)!s:5}  {label}")
+    check(f"{label}: tariff_refresh_wanted() is {want}", got is want)
+    check(f"{label}: amain() starts the task exactly as that says",
+          task_started(o) is want)
+check("battery_modes_enabled has to be exactly true (packmode.enabled()): "
+      "'true' as text or 1 does not start the task",
+      not tariff_refresh_wanted(dict(opts(), battery_modes_enabled="true"))
+      and not tariff_refresh_wanted(dict(opts(), battery_modes_enabled=1)))
+
+
+# --------------------------------------------------------------------------- #
+# The real Controller over a few minutes of a night: the task starts only if
+# amain()'s own guard says so; then read_inputs() + cycle() as the control
+# loop runs them.
+# --------------------------------------------------------------------------- #
+CHOICE = {"a": (True, "leftover_solar", False),
+          "b": (True, "cheap_hours", False)}
+
+
+FETCHES = []
+
+
+async def _no_fetch(*a, **k):
+    FETCHES.append(a)
+    raise AssertionError("the tariff task reached for a price feed")
+
+
+def drive(o, *, start=NIGHT, minutes=20, soc0=None, choice=CHOICE,
+          house_w=300.0, tick=5.0):
+    """-> (controller, rows, task_was_started)."""
+    store = rp._Store()
+    for u, (use, mode, sell) in choice.items():
+        store.data[unit_key(f"inverter-{u}", "pack_use")] = use
+        store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode
+        store.data[unit_key(f"inverter-{u}", "pack_sell")] = sell
+    rows = []
+
+    async def go():
+        hass = rp.Hass(("a", "b"), lambda t: house_w,
+                       soc0 or {"a": 40.0, "b": 40.0})
+        tmp = tempfile.mkdtemp(prefix="t24-")
+        c = Controller(dict(o), hass, store, rp._Pub(),
+                       stop=asyncio.Event(),
+                       peak_db_path=os.path.join(tmp, "tariff.db"),
+                       price_history_path=os.path.join(tmp, "ph.json"))
+        for i in c.inverters:
+            i.dev_min, i.dev_max = -5000.0, 5000.0
+        c.auto = True
+        real_dt, real_hv = m.datetime, homeview.datetime
+        clock = [start]
+
+        class _DT(real_dt):
+            @classmethod
+            def now(cls, tz=None):
+                return clock[0] if tz is None else clock[0].astimezone(tz)
+
+        m.datetime = homeview.datetime = _DT
+        _real_load = _price.load_prices, _st.load_prices
+        _price.load_prices = _st.load_prices = _no_fetch
+        started = task_started(o)
+        task = (asyncio.create_task(c.run_tariff_refresh())
+                if started else None)
+        try:
+            t = 0.0
+            while t < minutes * 60:
+                now = start + timedelta(seconds=t)
+                hass.t = t
+                clock[0] = now
+                if t == 0.0 and started:
+                    for _ in range(500):     # let the task do its first pass
+                        if c.tariff_plan is not None:
+                            break
+                        await asyncio.sleep(0)
+                imp, exp = split_signed(hass.grid())
+                c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
+                                        ingest_ts=now,
+                                        ingest_mono=time.monotonic()))
+                await c.read_inputs(now_mono=t)
+                await c.cycle()
+                hass.advance(tick, 10.0)
+                rows.append(dict(
+                    now=now, runs=c.mode_runs, tick=c.mode_tick,
+                    plan=c.fresh_tariff_plan(now),
+                    action=getattr(c.arb, "action", None),
+                    p={u: p.p for u, p in hass.plants.items()},
+                    soc={u: p.soc for u, p in hass.plants.items()}))
+                t += tick
+            # What the two screens say at the end, while the clock is still
+            # the simulated one.
+            c.home_plan = homeview.build_plan(c, clock[0], False, True)
+            c.battery_cards = homeview.battery_rows(c, False, True)
+        finally:
+            if task is not None:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+            m.datetime, homeview.datetime = real_dt, real_hv
+            _price.load_prices, _st.load_prices = _real_load
+        return c, started
+
+    c, started = asyncio.run(go())
+    return c, rows, started
+
+
+def charging_b(rows):
+    """Cycles in which the Cheap hours battery was charging (grid: no sun and
+    a 300 W house in this scenario)."""
+    return [r for r in rows if r["p"]["b"] < -200.0]
+
+
+def why_of(c, name):
+    card = first((b for b in c.battery_cards if b["name"] == name),
+                 f"a card for {name}")
+    return card["why_key"]
+
+
+# --------------------------------------------------------------------------- #
+print("\n2. end to end, night, modes on, static day/night, no feed, no arbitrage")
+c1, r1, started1 = drive(opts())
+_last = nth(r1, -1, "the last cycle")
+_first1 = nth(r1, 0, "the first cycle")
+print(f"    tariff task started by amain's guard: {started1}")
+print(f"    tariff_plan: {None if c1.tariff_plan is None else c1.tariff_plan.words}")
+print(f"    mode_runs: {_last['runs']}")
+print(f"    mode_tick reason / roles: "
+      f"{None if _last['tick'] is None else (_last['tick'].why, dict(_last['tick'].roles))}")
+print(f"    Batteries screen why_key: A {why_of(c1, A)}, B {why_of(c1, B)}")
+print(f"    cycles with B charging: {len(charging_b(r1))} of {len(r1)}, "
+      f"B soc {_first1['soc']['b']:.1f} -> {_last['soc']['b']:.1f}")
+check("the tariff refresh task is started", started1)
+check("...and it adds no network call: with price_provider off the feed "
+      "loader is never reached (it is replaced by one that fails)",
+      not FETCHES and not _price.provider_configured(opts()))
+check("a fresh tariff plan with prices is held", present(_last)
+      and _last["plan"] is not None and _last["plan"].has_prices)
+check("the price runs exist (mode_runs is not None) and carry a cheap run "
+      "that holds in the night period",
+      present(_last) and _last["runs"] is not None and _last["runs"].on
+      and _last["runs"].cheap is not None
+      and _last["runs"].cheap.holds(_last["now"]))
+check("the Cheap hours battery charges from the grid in the night period",
+      len(charging_b(r1)) > len(r1) // 2
+      and present(_last, _first1)
+      and _last["soc"]["b"] > _first1["soc"]["b"] + 0.3)
+check("...and the Leftover solar battery does not (no sun, no forecast)",
+      not any(r["p"]["a"] < -200.0 for r in r1))
+check("...the reason is not 'no prices': neither battery reads no_prices",
+      why_of(c1, A) != "no_prices" and why_of(c1, B) != "no_prices")
+check("...only the Cheap hours battery got the grid charge role",
+      present(_last) and _last["tick"] is not None
+      and _last["tick"].roles.get(B) == modetrade.CHARGE
+      and _last["tick"].roles.get(A) != modetrade.CHARGE)
+
+# --------------------------------------------------------------------------- #
+print("\n3. the same with a gap below the cycle cost")
+c3, r3, started3 = drive(opts(cost=0.20))
+_l3 = nth(r3, -1, "the last cycle")
+print(f"    started {started3}; mode_runs {_l3['runs']}; "
+      f"why A {why_of(c3, A)}, B {why_of(c3, B)}")
+check("the task is started and the plan is there, so mode_runs is not None",
+      started3 and present(_l3) and _l3["plan"] is not None
+      and _l3["runs"] is not None)
+check("the reason is the gap: no_spread ('Prices differ too little'), "
+      "never no_prices, on both batteries",
+      why_of(c3, A) == "no_spread" and why_of(c3, B) == "no_spread"
+      and present(_l3) and _l3["runs"] is not None
+      and not _l3["runs"].on)
+check("...and no battery charges from the grid",
+      not charging_b(r3) and not any(r["p"]["a"] < -200.0 for r in r3))
+
+# --------------------------------------------------------------------------- #
+print("\n4. Home and the Batteries screen agree")
+hp = c1.home_plan
+_bars = [b for b in hp["prices"] if b["eur_kwh"] is not None]
+_words = {b["why_key"]: b["why"] for b in c1.battery_cards}
+print(f"    Home: has_prices {hp['has_prices']}, {len(_bars)} priced bars, "
+      f"verdict {hp['verdict_key']}, lines {hp['lines']}")
+print(f"    Batteries: {[(b['name'], b['why_key'], b['why']) for b in c1.battery_cards]}")
+check("Home prices the day, and the Batteries screen does not say it has no "
+      "prices", hp["has_prices"] and _bars
+      and all(b["why_key"] != "no_prices" for b in c1.battery_cards))
+check("Home's plan has the grid charge block for the Cheap hours battery "
+      "(the 'trade' verdict) and no 'no prices have arrived' line",
+      hp["verdict_key"] == "trade"
+      and any(r["kind"] == "grid" for r in hp["runs"])
+      and not any("no prices have arrived" in ln for ln in hp["lines"]))
+hp3 = c3.home_plan
+check("with the gap too small both say so: Home 'price gap is too small', "
+      "the batteries 'differ too little'; neither says no prices",
+      any("price gap is too small" in ln for ln in hp3["lines"])
+      and all(b["why_key"] == "no_spread" for b in c3.battery_cards))
+
+# --------------------------------------------------------------------------- #
+print("\n5. UX-55: every battery Solar first, static day/night, no feed")
+SF = {"a": (True, "solar_first", False), "b": (True, "solar_first", False)}
+c5, r5, s5 = drive(opts(), choice=SF, minutes=5)
+print(f"    Home lines: {c5.home_plan['lines']}")
+check("Home no longer says 'no prices have arrived' with every battery Solar "
+      "first on a static profile",
+      s5 and not any("no prices have arrived" in ln
+                     for ln in c5.home_plan["lines"]))
+c5b, r5b, s5b = drive(opts(profile=None), choice=SF, minutes=5)
+print(f"    no profile, no feed: started {s5b}, Home lines "
+      f"{c5b.home_plan['lines']}")
+check("...and with no profile and no feed there are truly no prices, and "
+      "Home still says so",
+      any("no prices have arrived" in ln for ln in c5b.home_plan["lines"]))
+
+# --------------------------------------------------------------------------- #
+print("\n6. nothing else moved")
+c6, r6, s6 = drive(opts(modes=False), choice={}, minutes=5)
+check("modes off, arbitrage off, no feed: no task, no plan, no price runs "
+      "(as before)", not s6 and c6.tariff_plan is None
+      and all(r["runs"] is None for r in r6))
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print(f"  - {f}")
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_tariff24_weather.py

@@ -0,0 +1,451 @@
+"""Runnable check for TARIFF-24 round 2 (AUDIT-02 F1).  `python3 test_tariff24_weather.py`
+
+With battery modes on, the price gap a mode needs was always widened x1.5
+(`Uncertainty.NO_WEATHER`) even with a solar forecast read. Now the doubt is
+added only when no usable forecast is read (`arbitrage.weather_uncertainty()`),
+in the run plan (`_price_runs()`), the charge gate (`_mode_roles()`) and Home's
+mirror (`homeview.trade_verdict()`). Modes off is untouched.
+DECISIONS/TARIFF-24-modes-need-the-tariff-task.md.
+
+1. The rule itself, and that modes off keeps the doubt.
+2. Day/night 0.34/0.26 (gap 0.08), modes on, real Controller, night period:
+   with a forecast at cycle cost 0.07 the cheap run is planned and the Cheap
+   hours battery charges; without one, or with a stale one, the same cost needs
+   0.105 and the reason is `not_worth` / "Prices differ too little".
+3. A dynamic day with a 0.12 gap at cost 0.10: on with a forecast, not worth
+   without.
+4. The forecast coming (the gate follows in the same cycle) and going mid-run:
+   a run under way keeps its gap to its end, the next run needs the wider one;
+   a forecast unavailable for one or two reads mid-run does not stop or
+   restart the charge.
+5. Home agrees with control in each case (Batteries Why, Home line, and
+   `trade_verdict()`, Home's mirror of the gate).
+
+Mutations (MUTATION.md, purged copies, graded over this file): the doubt always
+added (the old code) fails parts 2 to 5; never added fails the without-forecast
+rows; Home's mirror left on the old rule fails part 5.
+"""
+
+import asyncio
+import logging
+import math
+import os
+import sys
+import tempfile
+import time
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+import opt11p3_replay as rp                                    # noqa: E402
+from named_absence import first, nth, present                  # noqa: E402
+import app.main as m                                           # noqa: E402
+from app import arbitrage, homeview, modetrade, solarfc        # noqa: E402
+from app.main import Controller                                # noqa: E402
+from app.p1 import make_sample, split_signed                   # noqa: E402
+from app.price import (PricePoint, PriceProduct, PriceRead,    # noqa: E402
+                       Uncertainty, brussels)
+from app.static_tariff import TariffPlan                       # noqa: E402
+from app.store import unit_key                                 # noqa: E402
+
+fails = []
+
+
+class _NoHold(solarfc.Hold):
+    """OPT-27: a hold that never stands in for a lost sensor."""
+
+    def stand_in(self, *a, **k):
+        return None
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+A, B = "inverter-a", "inverter-b"
+PROFILE = ('{"periods": ['
+           '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
+           ' "eur_per_kwh": 0.26},'
+           '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
+           ' "eur_per_kwh": 0.34}]}')
+L = timezone(timedelta(hours=1))
+NIGHT = datetime(2026, 10, 30, 23, 0, tzinfo=L).astimezone(timezone.utc)
+CHOICE = {"a": (True, "leftover_solar", False),
+          "b": (True, "cheap_hours", False)}
+FC_TODAY, FC_TOMORROW = "sensor.fc_today", "sensor.fc_tomorrow"
+TARIFF_REFRESH_S = m.TARIFF_REFRESH_S
+
+
+def opts(cost, *, arb=False, sensors=True):
+    o = dict(rp.options(True, arb, 2))
+    o.update(cycle_cost_threshold_eur=cost, static_profile=PROFILE)
+    if sensors:
+        o.update(pv_forecast_entity=FC_TODAY,
+                 pv_forecast_tomorrow_entity=FC_TOMORROW)
+    return o
+
+
+def dynamic_points(start):
+    """A dynamic day-ahead shape, 0.16 .. 0.28 (gap 0.12), 15-minute points."""
+    out, t = [], start.replace(minute=0, second=0, microsecond=0)
+    for _ in range(48 * 4):
+        h = brussels(t).hour + brussels(t).minute / 60
+        p = 0.22 + 0.06 * math.cos((h - 19) / 24 * 2 * math.pi)
+        out.append(PricePoint(start=brussels(t), eur_per_kwh=round(p, 4),
+                              provisional=False))
+        t += timedelta(minutes=15)
+    return out
+
+
+def sensor(kwh, at):
+    return {"state": f"{kwh}", "attributes": {"unit_of_measurement": "kWh"},
+            "last_updated": at.isoformat(), "last_reported": at.isoformat()}
+
+
+def forecast_mode(mode, t, now):
+    """What the two forecast sensors read: 'fresh', 'stale', 'gone', or a
+    function of the simulated seconds that returns one of those."""
+    if callable(mode):
+        mode = mode(t)
+    if mode == "gone":
+        return {"state": "unavailable", "attributes": {}}
+    at = now if mode == "fresh" else now - timedelta(hours=5)
+    return at
+
+
+def take(c, now):
+    """What Home and the Batteries screen say now, and Home's mirror of the
+    gate (it reads the trade switch, so ask it as a site that has it on next
+    to the modes)."""
+    keep = c.o
+    c.o = dict(keep, arbitrage_enabled=True)
+    try:
+        mirror, why = homeview.trade_verdict(c, c.fresh_tariff_plan(now), now)
+    finally:
+        c.o = keep
+    return dict(home=homeview.build_plan(c, now, False, True),
+                cards=homeview.battery_rows(c, False, True),
+                mirror=mirror, mirror_why=why)
+
+
+def drive(o, *, fc="fresh", points=None, minutes=20, tick=5.0,
+          house_w=300.0, soc0=None, snap_at=()):
+    """-> (controller, rows). `points`: a feed-shaped plan injected every
+    cycle (no task); else the static profile via the real tariff task."""
+    store = rp._Store()
+    for u, (use, mode, sell) in CHOICE.items():
+        for k, val in (("pack_use", use), ("pack_mode", mode),
+                       ("pack_sell", sell)):
+            store.data[unit_key(f"inverter-{u}", k)] = val
+    rows = []
+    snaps = {}
+
+    class H(rp.Hass):
+        async def state(self, e):
+            now = NIGHT + timedelta(seconds=self.t)
+            if fc is None:
+                return None
+            at = forecast_mode(fc, self.t, now)
+            if isinstance(at, dict):
+                return at
+            return sensor(0.0 if e == FC_TODAY else 12.0, at)
+
+    async def go():
+        hass = H(("a", "b"), lambda t: house_w, soc0 or {"a": 40.0, "b": 40.0})
+        tmp = tempfile.mkdtemp(prefix="t24w-")
+        c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
+                       peak_db_path=os.path.join(tmp, "tariff.db"),
+                       price_history_path=os.path.join(tmp, "ph.json"))
+        for i in c.inverters:
+            i.dev_min, i.dev_max = -5000.0, 5000.0
+        c.auto = True
+        # OPT-27: a sensor that is missing is covered for up to 3 h by its last
+        # fresh reading. This file is about what the plan does when the
+        # forecast IS lost, so it runs with a hold that never covers
+        # (test_opt27.py tests the cover).
+        c.fc_hold = _NoHold()
+        real_dt, real_hv = m.datetime, homeview.datetime
+        clock = [NIGHT]
+
+        class _DT(real_dt):
+            @classmethod
+            def now(cls, tz=None):
+                return clock[0] if tz is None else clock[0].astimezone(tz)
+
+        m.datetime = homeview.datetime = _DT
+        pts = None if points is None else points
+        task = None
+        if pts is None:
+            task = asyncio.create_task(c.run_tariff_refresh())
+        try:
+            t = 0.0
+            while t < minutes * 60:
+                now = NIGHT + timedelta(seconds=t)
+                hass.t = t
+                clock[0] = now
+                if pts is not None:
+                    c.tariff_plan = TariffPlan(
+                        PriceRead.series(pts, PriceProduct.DAY_AHEAD,
+                                         "generic_dayahead", now), None,
+                        "provider")
+                    c.tariff_at = now
+                elif t == 0.0 or t % TARIFF_REFRESH_S == 0.0:
+                    # The task's own 30 min wait is wall clock, so the
+                    # simulated clock restarts it: one refresh per period.
+                    if task is not None and t > 0.0:
+                        task.cancel()
+                        try:
+                            await task
+                        except asyncio.CancelledError:
+                            pass
+                        task = asyncio.create_task(c.run_tariff_refresh())
+                    for _ in range(500):
+                        if c.tariff_plan is not None and (
+                                c.tariff_at is not None and c.tariff_at >= now):
+                            break
+                        await asyncio.sleep(0)
+                imp, exp = split_signed(hass.grid())
+                c.p1.submit(make_sample("ha_signed", imp, exp, phases=1,
+                                        ingest_ts=now,
+                                        ingest_mono=time.monotonic()))
+                await c.read_inputs(now_mono=t)
+                await c.cycle()
+                hass.advance(tick, 10.0)
+                rp_ = c.mode_runs
+                rows.append(dict(
+                    t=t, now=now, fc_none=c.solar_fc is None,
+                    runs_on=None if rp_ is None else rp_.on,
+                    reason=None if rp_ is None else rp_.reason,
+                    roles=dict(c.mode_tick.roles) if c.mode_tick else {},
+                    why=None if c.mode_tick is None else c.mode_tick.why,
+                    charging=hass.plants["b"].p < -200.0,
+                    soc_b=hass.plants["b"].soc,
+                    cheap_end=None if rp_ is None or rp_.cheap is None
+                    else rp_.cheap.end))
+                if t in snap_at:
+                    snaps[t] = take(c, now)
+                t += tick
+            last = take(c, clock[0])
+            c.home_plan, c.cards = last["home"], last["cards"]
+            c.mirror, c.mirror_why = last["mirror"], last["mirror_why"]
+            c.snaps = snaps
+        finally:
+            if task is not None:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+            m.datetime, homeview.datetime = real_dt, real_hv
+        return c
+
+    return asyncio.run(go()), rows
+
+
+def why_of(c, name):
+    card = first((b for b in c.cards if b["name"] == name), f"card {name}")
+    return card["why_key"]
+
+
+# --------------------------------------------------------------------------- #
+print("1. the rule")
+NW = frozenset({Uncertainty.NO_WEATHER})
+check("modes on with a forecast read: no doubt", arbitrage.weather_uncertainty(
+    True, object()) == frozenset())
+check("modes on with no forecast (None): the doubt", arbitrage.weather_uncertainty(
+    True, None) == NW)
+check("modes off, forecast or not: the doubt, as before",
+      arbitrage.weather_uncertainty(False, object()) == NW
+      and arbitrage.weather_uncertainty(False, None) == NW)
+
+# --------------------------------------------------------------------------- #
+print("\n2. day/night 0.34 / 0.26 (gap 0.08), night period")
+c1, r1 = drive(opts(0.07), fc="fresh")
+l1 = nth(r1, -1, "last cycle")
+print(f"    forecast read, cost 0.07: mode_runs on={l1['runs_on']} "
+      f"reason={l1['reason']}; B charging {sum(r['charging'] for r in r1)} of "
+      f"{len(r1)}; Why A {why_of(c1, A)} B {why_of(c1, B)}")
+check("with a forecast at cost 0.07 the cheap run is planned (needed 0.07 < "
+      "0.08) and the Cheap hours battery charges in the night period",
+      present(l1) and not l1["fc_none"] and l1["runs_on"] is True
+      and sum(r["charging"] for r in r1) > len(r1) // 2
+      and l1["roles"].get(B) == modetrade.CHARGE)
+for label, mode in (("no forecast sensor reads", "gone"),
+                    ("a stale forecast", "stale")):
+    c, rr = drive(opts(0.07), fc=mode)
+    ll = nth(rr, -1, "last cycle")
+    print(f"    {label}, cost 0.07: on={ll['runs_on']} reason={ll['reason']}; "
+          f"B charging {sum(r['charging'] for r in rr)}; Why A "
+          f"{why_of(c, A)} B {why_of(c, B)}")
+    check(f"{label}: the same cost needs 0.105 > 0.08, so not_worth and "
+          f"'Prices differ too little', no grid charge",
+          present(ll) and ll["fc_none"] and ll["runs_on"] is False
+          and ll["reason"] == "not_worth"
+          and why_of(c, A) == "no_spread" and why_of(c, B) == "no_spread"
+          and not any(r["charging"] for r in rr))
+c0, r0 = drive(opts(0.07, sensors=False), fc=None)
+check("no forecast sensor configured at all: not_worth too (as 0.19.0)",
+      present(nth(r0, -1)) and r0[-1]["runs_on"] is False)
+c2, r2 = drive(opts(0.10), fc="fresh")
+check("at the shipped cost 0.10 even a forecast does not make 0.08 enough "
+      "(needs 0.10): still not_worth, honestly",
+      present(nth(r2, -1)) and r2[-1]["runs_on"] is False
+      and r2[-1]["reason"] == "not_worth")
+
+# --------------------------------------------------------------------------- #
+print("\n3. a dynamic day, gap 0.12, cost 0.10")
+pts = dynamic_points(NIGHT - timedelta(hours=1))
+cd, rd = drive(opts(0.10), fc="fresh", points=pts)
+cn, rn = drive(opts(0.10), fc="gone", points=pts)
+_ld, _ln = nth(rd, -1, "last cycle"), nth(rn, -1, "last cycle")
+print(f"    with forecast: on={_ld['runs_on']} reason={_ld['reason']}; "
+      f"without: on={_ln['runs_on']} reason={_ln['reason']}")
+check("with a forecast the run plan is on (needs 0.10 < 0.12)",
+      present(nth(rd, -1)) and rd[-1]["runs_on"] is True
+      and why_of(cd, A) != "no_spread")
+check("without one it is not_worth (needs 0.15 > 0.12) and says so",
+      present(nth(rn, -1)) and rn[-1]["runs_on"] is False
+      and rn[-1]["reason"] == "not_worth"
+      and why_of(cn, B) == "no_spread")
+
+# --------------------------------------------------------------------------- #
+print("\n4. the forecast going and coming mid-run (a run under way keeps its gap)")
+CUT = 600.0                      # 10 min in
+SOC = {"a": 40.0, "b": 60.0}     # B's cheap run is then about 2 h
+
+
+def going(t):
+    return "fresh" if t < CUT else "gone"
+
+
+def coming(t):
+    return "gone" if t < CUT else "fresh"
+
+
+def flap(n_reads):
+    """Unavailable for `n_reads` forecast reads (60 s apart) from CUT."""
+    return lambda t: "gone" if CUT <= t < CUT + 60.0 * n_reads else "fresh"
+
+
+MID, AFTER = 3000.0, 7800.0
+cg, rg = drive(opts(0.07), fc=going, minutes=135, soc0=SOC,
+               snap_at=(MID, AFTER))
+cc, rc = drive(opts(0.07), fc=coming, minutes=25)
+_end = nth([r["cheap_end"] for r in rg if r["cheap_end"] is not None], 0,
+           "the cheap run's end")
+_end_t = (_end - NIGHT).total_seconds() if present(_end) else 1e9
+lost = [r for r in rg if r["fc_none"]]
+print(f"    going: cheap run ends at t={_end_t:.0f} s; forecast lost from "
+      f"t={lost[0]['t'] if lost else None}")
+check("going: the run planned with the forecast ends before the snapshot "
+      "taken after it (the scenario is long enough)",
+      present(_end) and CUT + 300.0 < _end_t < AFTER - 300.0 and bool(lost)
+      and lost[0]["t"] - CUT <= 60.0)
+check("going: the forecast read is lost mid-run and the run under way KEEPS "
+      "its gap: the plan stays on and B keeps charging, cycle after cycle, "
+      "until B is full or the run ends",
+      all(r["runs_on"] is True and (r["roles"].get(B) == modetrade.CHARGE
+                                    or r["soc_b"] >= 94.0)
+          for r in rg if r["fc_none"] and r["t"] < _end_t - 60.0)
+      and all(r["charging"] or r["soc_b"] >= 94.0 for r in rg
+              if 60.0 <= r["t"] < _end_t - 60.0)
+      and max(r["soc_b"] for r in rg if r["fc_none"]) >= 90.0)
+check("going: from the run's end the wider gap is back: the next run is "
+      "not_worth (needs 0.105 at 0.07), no new run, and no grid charge",
+      all(r["runs_on"] is False and r["reason"] == "not_worth"
+          for r in rg if r["t"] >= _end_t + 30.0)
+      and not any(r["charging"] for r in rg if r["t"] >= _end_t + 60.0))
+_sm, _sa = cg.snaps.get(MID), cg.snaps.get(AFTER)
+check("going, Home agrees mid-run: its mirror still allows, the Batteries "
+      "screen says it charges from the grid, and Home does not say the gap "
+      "is too small",
+      _sm is not None and _sm["mirror"] is not None
+      and first((b for b in _sm["cards"] if b["name"] == B),
+                "a card")["why_key"] == "grid_charge"
+      and not any("price gap is too small" in ln
+                  for ln in _sm["home"]["lines"]))
+check("going, Home agrees after the run: its mirror refuses, the Batteries "
+      "screen says 'differ too little' and Home says the gap is too small",
+      _sa is not None and _sa["mirror"] is None
+      and first((b for b in _sa["cards"] if b["name"] == B),
+                "a card")["why_key"] == "no_spread"
+      and any("price gap is too small" in ln for ln in _sa["home"]["lines"]))
+for n in (1, 2):
+    cf, rf = drive(opts(0.07), fc=flap(n), minutes=30, soc0=SOC,
+                   snap_at=(CUT + 30.0,))
+    gone = [r for r in rf if r["fc_none"]]
+    print(f"    flap, {n} read(s) lost: {len(gone)} cycles without a "
+          f"forecast; B charging in {sum(r['charging'] for r in rf)} of "
+          f"{len(rf)}")
+    check(f"flap: the forecast is unavailable for {n} read(s) mid-run: the "
+          f"plan stays on and B charges without a break (no stop, no "
+          f"restart)",
+          bool(gone) and all(r["runs_on"] is True for r in rf)
+          and all(r["charging"] and r["roles"].get(B) == modetrade.CHARGE
+                  for r in rf if r["t"] >= 60.0))
+    sf = cf.snaps.get(CUT + 30.0)
+    check(f"flap, {n} read(s): Home agrees while the read is lost (mirror "
+          f"allows, Batteries 'charges from the grid')",
+          sf is not None and sf["mirror"] is not None
+          and first((b for b in sf["cards"] if b["name"] == B),
+                    "a card")["why_key"] == "grid_charge")
+
+
+def flips(rows):
+    """Cycles where the forecast read changed, and whether the plan and the
+    charge gate changed in that very cycle."""
+    out = []
+    for i in range(1, len(rows)):
+        if rows[i]["fc_none"] != rows[i - 1]["fc_none"]:
+            out.append((i, rows[i]["t"], rows[i]["runs_on"],
+                        rows[i]["charging"], rows[i - 1]["charging"]))
+    return out
+
+
+fcm = flips(rc)
+print(f"    coming: forecast read arrives at cycle/t {fcm}")
+check("coming (no run under way before): not_worth until the read is back, "
+      "then on in the same cycle, and the battery charges",
+      len(fcm) == 1 and fcm[0][1] - CUT <= 60.0 and fcm[0][2] is True
+      and all(r["runs_on"] is False for r in rc if r["fc_none"])
+      and all(r["runs_on"] is True for r in rc if not r["fc_none"])
+      and any(r["charging"] for r in rc if r["t"] >= fcm[0][1] + 40.0))
+
+# --------------------------------------------------------------------------- #
+print("\n5. Home agrees with control")
+CASES = (("forecast, cost 0.07", c1, r1, True),
+         ("no forecast, cost 0.07", *drive(opts(0.07), fc="gone"), False),
+         ("dynamic, forecast", cd, rd, True),
+         ("dynamic, no forecast", cn, rn, False))
+for label, cx, rx, on in CASES:
+    last = nth(rx, -1, "last cycle")
+    hp = cx.home_plan
+    mirror_ok = cx.mirror is not None
+    print(f"    {label}: control on={last['runs_on']}; Home mirror "
+          f"{'allows' if mirror_ok else 'refuses'} ({cx.mirror_why}); "
+          f"lines {hp['lines'][:1]}; Why B {why_of(cx, B)}")
+    check(f"{label}: Home's mirror of the gate allows exactly when control "
+          f"plans", present(last) and mirror_ok is on
+          and last["runs_on"] is on)
+    check(f"{label}: the Batteries screen and the Home line say the gap is "
+          f"too small exactly when control does",
+          (why_of(cx, B) == "no_spread") is (not on)
+          and any("price gap is too small" in ln for ln in hp["lines"])
+          is (not on))
+    if label.startswith("dynamic"):
+        continue    # its cheap run is tomorrow morning: not on today's chart
+    check(f"{label}: Home draws a grid charge block exactly when control "
+          f"charges", any(r["kind"] == "grid" for r in hp["runs"]) is on)
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print(f"  - {f}")
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_ux54_dst.py

@@ -0,0 +1,296 @@
+"""UX-54: the Forecast tab on the two clock-change days.
+`python3 test_ux54_dst.py`
+
+The tab walks local hours (`dayplan._hour_slices()` in `dayview` and
+`daycurve`, `SolarToday`'s hour keys). On the spring change a loop that steps
+on the wall clock never ends (SAFETY-123), and a tab request runs on the
+event loop control runs on. Graded here, every call under a hard time limit
+that the add-on's own `except Exception` cannot swallow (`Hang` is a
+`BaseException`), and a memory limit:
+
+1. The limit itself: a tab build that never returns is stopped and reported,
+   through `forecast_payload()`'s `except Exception`.
+2. `Controller.forecast_payload()` at every quarter of 27-29 March 2027 and
+   30 October-1 November 2027, modes on (Leftover solar and Cheap hours,
+   with a forecast and a house profile: the level curve) and modes off, in
+   the no-tzdata zone (`tariff._EUTimezone`) and, where the host has tzdata,
+   in ZoneInfo Europe/Brussels: it returns, `ok`, each day has 23 / 24 / 25
+   hours with the local hour labels of that day, every level inside floor
+   and ceiling, every block inside its day.
+3. `SolarToday` keeps the two 02:00 hours of the autumn change apart.
+
+Mutating what this file grades? Read MUTATION.md first (stale bytecode).
+"""
+
+import logging
+import os
+import resource
+import signal
+import sys
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "tools"))
+logging.disable(logging.WARNING)
+
+import ux54_scenarios as S                                        # noqa: E402
+import app.main as M                                              # noqa: E402
+from app import arbitrage, dayplan, dayview, homeview, solarfc    # noqa: E402
+from app import tariff                                            # noqa: E402
+from app.daycurve import SolarToday                               # noqa: E402
+
+UTC = timezone.utc
+fails = []
+LIMIT_S = 10.0          # one call; a build takes well under a second
+try:                    # a loop that appends without end must not take the host
+    resource.setrlimit(resource.RLIMIT_AS, (3 << 29, resource.getrlimit(
+        resource.RLIMIT_AS)[1]))
+except (ValueError, OSError):
+    pass
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+class Hang(BaseException):
+    """A call ran over LIMIT_S. Not an `Exception`: `forecast_payload()`
+    catches every `Exception` and would turn it into `{"ok": False}`."""
+
+
+def _alarm(*_a):
+    raise Hang()
+
+
+def limited(fn, *a, **k):
+    """`fn(*a, **k)`, or `Hang` when it takes more than LIMIT_S seconds or
+    runs out of memory."""
+    signal.signal(signal.SIGALRM, _alarm)
+    signal.setitimer(signal.ITIMER_REAL, LIMIT_S)
+    try:
+        return fn(*a, **k)
+    except MemoryError:
+        raise Hang() from None
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+
+
+# --------------------------------------------------------------------------- #
+# The clock and the zone
+# --------------------------------------------------------------------------- #
+NOW = [datetime(2027, 1, 1, tzinfo=UTC)]
+
+
+class FakeDT(datetime):
+    @classmethod
+    def now(cls, tz=None):
+        return NOW[0].astimezone(tz) if tz else NOW[0].replace(tzinfo=None)
+
+
+for _mod in (M, homeview, dayview):         # what reads the wall clock
+    _mod.datetime = FakeDT
+
+TZ_MODULES = (tariff, dayplan, homeview, solarfc)
+
+
+class zone:
+    """`BILLING_TZ` is `tz` in every module that holds it, in the block."""
+
+    def __init__(self, tz):
+        self.tz = tz
+
+    def __enter__(self):
+        self.was = [m.BILLING_TZ for m in TZ_MODULES]
+        for m in TZ_MODULES:
+            m.BILLING_TZ = self.tz
+
+    def __exit__(self, *_a):
+        for m, tz in zip(TZ_MODULES, self.was):
+            m.BILLING_TZ = tz
+
+
+ZONES = [("no tzdata (_EUTimezone)", tariff._EUTimezone())]
+try:
+    from zoneinfo import ZoneInfo
+    _bru = ZoneInfo("Europe/Brussels")
+    if datetime(2026, 7, 1, tzinfo=UTC).astimezone(_bru).hour == 2:
+        ZONES.append(("ZoneInfo Europe/Brussels", _bru))
+except Exception:                                   # noqa: BLE001
+    pass
+if len(ZONES) == 1:
+    print("    no tzdata on this host: ZoneInfo is not graded here")
+
+# The local days (UTC midnight-to-midnight instants are not used: the days
+# are known by their dates) and their hour labels.
+SPRING, AUTUMN = (2027, 3, 28), (2027, 10, 31)
+WINDOWS = (((2027, 3, 27), SPRING, (2027, 3, 29)),
+           ((2027, 10, 30), AUTUMN, (2027, 11, 1)))
+
+
+def labels_of(ymd):
+    if ymd == SPRING:
+        return ["00:00", "01:00"] + [f"{h:02d}:00" for h in range(3, 24)]
+    if ymd == AUTUMN:
+        return ["00:00", "01:00", "02:00", "02:00"] + [
+            f"{h:02d}:00" for h in range(3, 24)]
+    return [f"{h:02d}:00" for h in range(24)]
+
+
+def next_ymd(ymd):
+    d = datetime(*ymd) + timedelta(days=1)
+    return (d.year, d.month, d.day)
+
+
+def day_start_utc(ymd):
+    """Local midnight of `ymd` in UTC (CET before the change, CEST after it;
+    midnight is never inside a change)."""
+    summer = (2027, 3, 28) < ymd < (2027, 10, 31) or ymd == (2027, 10, 31)
+    if ymd == SPRING:
+        summer = False
+    return datetime(*ymd, tzinfo=UTC) - timedelta(hours=2 if summer else 1)
+
+
+# --------------------------------------------------------------------------- #
+print("1. the time limit cannot be swallowed")
+# --------------------------------------------------------------------------- #
+check("`Hang` is a BaseException and not an Exception",
+      issubclass(Hang, BaseException) and not issubclass(Hang, Exception))
+c0 = limited(S.make, "off",
+             datetime(2027, 1, 12, 11, 0, 5, tzinfo=UTC))
+_real_build = dayview.build
+
+
+def _spin(*_a, **_k):
+    while True:
+        pass
+
+
+dayview.build = _spin
+try:
+    NOW[0] = datetime(2027, 1, 12, 11, 0, 5, tzinfo=UTC)
+    got = limited(c0.forecast_payload, "en")
+except Hang:
+    got = "stopped"
+finally:
+    dayview.build = _real_build
+check("a tab build that never returns is stopped by the limit and reported, "
+      f"not turned into a page answer by forecast_payload() ({got!r})",
+      got == "stopped")
+
+# --------------------------------------------------------------------------- #
+print("\n2. the tab at every quarter of the change days")
+# --------------------------------------------------------------------------- #
+Q = timedelta(minutes=15)
+SCENARIOS = (("modes on", "dynamic", (55.0, 40.0)),
+             ("modes off", "off", (55.0, 40.0)))
+
+
+def wrong(out, ymd, floor_, ceil_):
+    """What is wrong with one build, or None."""
+    if not out.get("ok") or len(out.get("days") or []) != 2:
+        return "not ok"
+    for k, day in enumerate(out["days"]):
+        exp = labels_of((ymd, next_ymd(ymd))[k])
+        hrs = day["hours"]
+        if day["length_h"] != len(exp):
+            return f"day {k}: length {day['length_h']}"
+        if [h["label"] for h in hrs] != exp:
+            return f"day {k}: labels"
+        if any(abs(h["end_h"] - h["start_h"] - 1.0) > 1e-6
+               or abs(h["start_h"] - j) > 1e-6 for j, h in enumerate(hrs)):
+            return f"day {k}: hour spans"
+        for b in day["batteries"]:
+            if any(not floor_ - 1e-6 <= v <= ceil_ + 1e-6
+                   or not -1e-6 <= h <= len(exp) + 1e-6
+                   for h, v in b["levels"]):
+                return f"day {k}: level {b['name']}"
+            if any(not 0.0 <= r["start_h"] <= r["end_h"] <= len(exp) + 1e-6
+                   for r in b["blocks"]):
+                return f"day {k}: block {b['name']}"
+    return None
+
+
+def walk(scn, soc):
+    """`(builds, with a curve, stopped, wrong)` over every quarter of the
+    six local days; the first call stopped by the limit ends the walk."""
+    builds, curves, bad = 0, 0, []
+    for window in WINDOWS:
+        for ymd in window:
+            a = day_start_utc(ymd)
+            z = day_start_utc(next_ymd(ymd))
+            t = a + timedelta(seconds=5)
+            try:
+                NOW[0] = t
+                c = limited(S.make, scn, t, soc=soc)
+                floor_, ceil_ = arbitrage.soc_bounds(c.o)
+                while t < z:
+                    NOW[0] = t
+                    c.tariff_at = t
+                    if c.modes_on:
+                        limited(c._mode_roles, t, None)
+                    limited(c.solar_today.add, t, 1500.0)
+                    out = limited(c.forecast_payload, "en")
+                    builds += 1
+                    curves += any(len(b["levels"]) > 1
+                                  for d in out.get("days") or []
+                                  for b in d["batteries"])
+                    why = wrong(out, ymd, floor_, ceil_)
+                    if why:
+                        bad.append((t.isoformat(), why))
+                    t += Q
+            except Hang:
+                return builds, curves, t.isoformat(), bad
+    return builds, curves, None, bad
+
+
+for zname, tz in ZONES:
+    with zone(tz):
+        for label, scn, soc in SCENARIOS:
+            builds, curves, stopped, bad = walk(scn, soc)
+            print(f"    {zname}, {label}: {builds} builds ({curves} with a "
+                  f"level curve), stopped at {stopped}, {len(bad)} wrong "
+                  f"{bad[:3]}")
+            check(f"{zname}, {label}: the tab returns at every quarter of "
+                  "27-29 March and 30 October-1 November 2027 (under "
+                  f"{LIMIT_S:g} s each), and each day has its 23, 24 or 25 "
+                  "hours, labelled, levels inside floor and ceiling, blocks "
+                  "inside the day",
+                  stopped is None and not bad
+                  and builds == (96 + 92 + 96) + (96 + 100 + 96)
+                  and (curves == builds if scn == "dynamic" else not curves))
+
+# --------------------------------------------------------------------------- #
+print("\n3. measured solar keeps the two autumn 02:00 hours apart")
+# --------------------------------------------------------------------------- #
+for zname, tz in ZONES:
+    with zone(tz):
+        s = SolarToday()
+        a = day_start_utc(AUTUMN)            # 00:00 CEST = 22:00 UTC
+        t = a
+        while t <= a + timedelta(hours=4):
+            # 1 kW in the first 02:00 hour (00:00-01:00 UTC), 3 kW in the
+            # second (01:00-02:00 UTC), nothing else
+            w = 1000.0 if a + timedelta(hours=2) <= t < a + timedelta(
+                hours=3) else 3000.0 if a + timedelta(hours=3) <= t < a + \
+                timedelta(hours=4) else 0.0
+            limited(s.add, t, w)
+            t += timedelta(minutes=1)
+        now = a + timedelta(hours=4, minutes=30)
+        sl = [x for x in limited(dayplan._hour_slices, a, now)
+              if x[2] == 2]
+        got = [None if x is None else round(x, 2) for x in
+               (limited(s.kwh, x[0], x[1], now) for x in sl)]
+        print(f"    {zname}: the two 02:00 hours {got}")
+        check(f"{zname}: two 02:00 slices, about 1 kWh and 3 kWh, each in "
+              "its own hour", len(sl) == 2 and got[0] is not None
+              and got[1] is not None and abs(got[0] - 1.0) < 0.06
+              and abs(got[1] - 3.0) < 0.06)
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED")
+    sys.exit(1)
+print("all passed")

goodwe_controller/tools/ux54_scenarios.py

@@ -0,0 +1,281 @@
+"""UX-54: controllers in a known situation, for test_ux54.py and the browser
+proof (`scratch/UX-54/dev/demo54.py`). Real `Controller`, readings set by hand,
+no Home Assistant. `make(name, now)` returns one; the names are in `SCENARIOS`.
+
+owner     modes on, both batteries Solar first, a day/night tariff, a forecast
+          from three state-only sensors (Forecast.Solar's shape), a house
+          profile (the owner's site 2026-10-26)
+dynamic   modes on, A Leftover solar and B Cheap hours, 15-minute prices with a
+          cheap night and a dear evening, a dark day (a grid charge is due)
+sunny     as dynamic, a sunny day (the sun fills A, no grid charge)
+periods   as dynamic with a Solcast-shaped forecast (an hourly split)
+off       modes off, arbitrage on, the same prices
+learning  modes on, a forecast, and no house profile yet
+nofc      modes on, no forecast sensor set
+stale     modes on, a sensor set that gives no forecast now
+notomorrow  as owner, today's forecast only
+cycle     as dynamic, battery A waiting for its monthly cycle
+"""
+
+import asyncio
+import json
+import math
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, HERE)
+
+from app import dayplan, packmode, solarfc                       # noqa: E402
+from app.main import Controller                                   # noqa: E402
+from app.peakguard import PeakDecision                            # noqa: E402
+from app.price import PricePoint, PriceProduct, PriceRead, brussels  # noqa
+from app.static_tariff import TariffPlan, static_plan             # noqa: E402
+from app.store import unit_key                                    # noqa: E402
+
+UTC = timezone.utc
+SCENARIOS = ("owner", "dynamic", "sunny", "periods", "off", "learning",
+             "nofc", "stale", "notomorrow", "cycle")
+
+INV = [{"name": "inverter-a", "setpoint_entity": "number.a",
+        "soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
+        "max_w": 5000, "capacity_kwh": 15.36},
+       {"name": "inverter-b", "setpoint_entity": "number.b",
+        "soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
+        "max_w": 4600, "capacity_kwh": 20.48}]
+
+BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+        "meter_source": "off", "max_w": 9600, "shadow_mode": "off",
+        "maintenance_enabled": False, "arbitrage_enabled": True,
+        "cycle_cost_threshold_eur": 0.10, "pv_entity": "sensor.pv",
+        "inverters": INV}
+FC1 = "sensor.energy_production_today_remaining"
+FCT1 = "sensor.energy_production_tomorrow"
+
+DN = {"periods": [{"name": "day", "from": "07:00", "to": "22:00",
+                   "days": "all", "eur_per_kwh": 0.2801},
+                  {"name": "night", "from": "22:00", "to": "07:00",
+                   "days": "all", "eur_per_kwh": 0.2333}]}
+
+
+class Store:
+    fresh = False
+
+    def __init__(self):
+        self.data = {}
+
+    def set(self, k, v):
+        self.data[k] = v
+
+    def get(self, k, d=None):
+        return self.data.get(k, d)
+
+    def set_time(self, k, v):
+        self.data[k] = v.isoformat()
+
+    def get_time(self, k):
+        v = self.data.get(k)
+        return None if v is None else datetime.fromisoformat(v)
+
+
+class Pub:
+    enabled = False
+
+    def publish(self, _v):
+        pass
+
+    def close(self):
+        pass
+
+
+class Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def number(self, _e, invert=False):
+        return None
+
+    async def state(self, _e):
+        return None
+
+    async def set_number(self, _e, _v):
+        return True
+
+    async def call(self, *_a):
+        return True
+
+    async def states(self):
+        return []
+
+
+def day0_of(now):
+    return solarfc._bounds(now)[0]
+
+
+def quarters(now, price_of, days=2):
+    """`days` days of 15-minute prices from local midnight; `price_of(h)`."""
+    d0 = day0_of(now)
+    pts = []
+    for i in range(96 * days):
+        t = d0 + timedelta(minutes=15 * i)
+        pts.append(PricePoint(brussels(t), price_of((i % 96) / 4.0), False))
+    return TariffPlan(PriceRead.series(tuple(pts), PriceProduct.DAY_AHEAD,
+                                       "generic_dayahead", now), None,
+                      "provider")
+
+
+def dyn_price(h):
+    if 1.0 <= h < 5.0:
+        return 0.08
+    if 11.0 <= h < 15.0:
+        return 0.14
+    if 17.0 <= h < 21.0:
+        return 0.34
+    return 0.20
+
+
+def profile(now, *, day=600.0, evening=1800.0, night=350.0):
+    """A house profile with three full days: the net use per local hour."""
+    shape = {h: (night if h < 6 or h >= 22 else 900.0 if h < 9
+                 else day if h < 17 else evening) for h in range(24)}
+    d = brussels(now).date()
+    return dayplan.HouseProfile(
+        {(d - timedelta(days=k)).isoformat():
+         {str(h): w for h, w in shape.items()} for k in (1, 2, 3)})
+
+
+def sensor(entity, kwh, now, *, periods=None, unit="kWh"):
+    """A forecast sensor's state, as Home Assistant gives it."""
+    attrs = {"unit_of_measurement": unit}
+    if periods:
+        attrs["wh_period"] = periods
+    return {"entity_id": entity, "state": f"{kwh:.3f}", "attributes": attrs,
+            "last_updated": now.isoformat(),
+            "last_reported": now.isoformat()}
+
+
+def bell_periods(now, day_kwh, *, tomorrow=False):
+    """An hourly split (Open-Meteo's `wh_period`) of a bell, for `now`'s day."""
+    d0 = day0_of(now) + (timedelta(days=1) if tomorrow else timedelta(0))
+    out = {}
+    for h in range(24):
+        a = solarfc._bell(h + 1.0) - solarfc._bell(float(h))
+        out[(d0 + timedelta(hours=h)).isoformat()] = round(
+            a * day_kwh * 1000.0, 1)
+    return out
+
+
+def left_today(now, day_kwh):
+    """What the integration says is left today at `now` (state only)."""
+    d0 = day0_of(now)
+    h = (now - d0).total_seconds() / 3600.0
+    return day_kwh * (1.0 - solarfc._bell(h))
+
+
+def forecast(now, today_kwh, tomorrow_kwh, *, split=False, members=1,
+             tomorrow=True):
+    """A `solarfc.Forecast` through `read_sum()`, as the controller reads it.
+    `today_kwh` is the whole day's sun; the sensors say what is left."""
+    left = left_today(now, today_kwh)
+    ts = [(f"{FC1}_{i}", sensor(
+        f"{FC1}_{i}", left / members, now,
+        periods=(bell_periods(now, today_kwh / members) if split else None)))
+        for i in range(members)]
+    tm = [(f"{FCT1}_{i}", sensor(
+        f"{FCT1}_{i}", tomorrow_kwh / members, now,
+        periods=(bell_periods(now, tomorrow_kwh / members, tomorrow=True)
+                 if split else None)))
+        for i in range(members)] if tomorrow else []
+    fc, why, _gaps = solarfc.read_sum(ts, tm, now)
+    return fc
+
+
+def measure(c, now, peak_w):
+    """The solar this site made today until `now`, one reading a minute."""
+    d0 = day0_of(now)
+    t = d0
+    while t <= now:
+        h = (t - d0).total_seconds() / 3600.0
+        c.solar_today.add(t, peak_w * math.sin(math.pi * (h - 6.0) / 14.0)
+                          if 6.0 <= h < 20.0 else 0.0)
+        t += timedelta(minutes=1)
+
+
+def make(name, now, *, soc=(55.0, 40.0), modes=("solar_first",
+                                                  "solar_first")):
+    """The controller of scenario `name` at `now` (UTC), its cycle run once."""
+    assert name in SCENARIOS, name
+    opts = dict(BASE)
+    plan = quarters(now, dyn_price)
+    sun_today, sun_tomorrow = 18.0, 16.0
+    members, split, tomorrow = 1, False, True
+    if name == "owner":
+        opts.update(battery_modes_enabled=True,
+                    pv_forecast_entities=[f"{FC1}_{i}" for i in range(3)],
+                    pv_forecast_tomorrow_entities=[f"{FCT1}_{i}"
+                                                   for i in range(3)],
+                    static_profile=json.dumps(DN), arbitrage_enabled=False)
+        plan = static_plan(opts, day0_of(now), day0_of(now) + timedelta(
+            hours=48), now=now)
+        members = 3
+    elif name in ("dynamic", "sunny", "periods", "learning", "stale",
+                  "cycle"):
+        opts.update(battery_modes_enabled=True, pv_forecast_entity=FC1,
+                    pv_forecast_tomorrow_entity=FCT1)
+        modes = ("leftover_solar", "cheap_hours")
+        if name == "dynamic":
+            sun_today, sun_tomorrow = 3.0, 3.0
+        if name == "periods":
+            split = True
+            sun_today, sun_tomorrow = 6.0, 6.0
+        if name == "cycle":
+            opts.update(maintenance_enabled=True)
+    elif name == "off":
+        opts.update(battery_modes_enabled=False, arbitrage_enabled=True)
+    elif name == "nofc":
+        opts.update(battery_modes_enabled=True)
+        modes = ("leftover_solar", "cheap_hours")
+    elif name == "notomorrow":
+        opts.update(battery_modes_enabled=True, pv_forecast_entity=FC1,
+                    static_profile=json.dumps(DN), arbitrage_enabled=False)
+        plan = static_plan(opts, day0_of(now), day0_of(now) + timedelta(
+            hours=48), now=now)
+        tomorrow = False
+    if name == "sunny":
+        sun_today, sun_tomorrow = 40.0, 40.0
+    if name not in ("nofc", "off", "stale") and \
+            opts.get("battery_modes_enabled"):
+        # TARIFF-24: with a forecast the gap needed is the cycle cost, not
+        # 1.5 x it. These scenarios were written for the old gate (0.15 at
+        # the shipped 0.10), so they keep it: the cost is 0.15.
+        opts["cycle_cost_threshold_eur"] = 0.15
+    c = Controller(opts, Hass(), Store(), Pub(), stop=asyncio.Event())
+    c.auto = True
+    for i, inv in enumerate(c.inverters):
+        inv.soc, inv.batt, inv.last_write = soc[i], 0.0, 0.0
+        inv.dev_min, inv.dev_max = -5000.0, 5000.0
+        if opts.get("battery_modes_enabled"):
+            c.store.data[unit_key(inv.name, packmode.MODE_KEY)] = modes[i]
+    c.grid, c.pv_w = 300.0, 0.0
+    c.tariff_plan, c.tariff_at = plan, now
+    c.peak_guard = PeakDecision(engaged=False, floor_w=None, ceiling_w=7000.0,
+                                ceiling_from="cap", projected_w=800.0)
+    c.arb_headroom_w = 6000.0
+    if name not in ("nofc", "off", "stale") and \
+            opts.get("battery_modes_enabled"):
+        c.solar_fc = forecast(now, sun_today, sun_tomorrow, split=split,
+                              members=members, tomorrow=tomorrow)
+        c.solar_fc_why = None
+        if name != "learning":
+            c.house_profile = profile(now)
+    if name in ("owner", "dynamic", "sunny", "periods", "learning",
+                "notomorrow", "cycle"):
+        measure(c, now, 7000.0 if name != "dynamic" else 2500.0)
+    if opts.get("battery_modes_enabled"):
+        c.tariff_at = now
+        c._mode_roles(now, None)
+    return c