UX-54 round 3: tomorrow's blocks last as long as control acts, give blocks checked at run start

- Tomorrow's grid block is drawn to where control stops charging. A cheap run
  is sized for all batteries together; a slower one is still below
  `charge_to()` when it ends and control plans the next cheap slots. The tab
  asks `modetrade.energy()` and `priceruns.plan()` with the packs at the
  curve's level and extends the run, so the curve charges as long.
- Each battery's block ends where it is at its own level (grid) or at the
  floor (give). The curve puts a point where a battery reaches its charge
  level inside a step.
- `homeview.mode_runs(ahead=f, rp=...)` reads each block at the level the
  curve has when it starts, with Home's own filter and MIN_KWH: no give block
  at the floor, no grid block at the planned level. Home never passes either.
- `no_tomorrow` names the hour from `solarfc.BELL_FROM_H`, where the curve
  stops.
- test_ux54.py part 7 compares control (`_mode_roles()` every 15 minutes) with
  the tab with no tolerance, and adds the cloudy / floor case.

No decision, command, timing or option key changes.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Bdqr7PiaHcBnzPituu2yTC

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

@@ -17,13 +17,24 @@ battery's expected level with its blocks. It follows the add-on, as Home does
   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=True` (Home never passes it): a charge is read from the floor, a give
-  from the ceiling, and a block is drawn wherever the plan and the gate have a
-  run. A grid block is then dropped where control will not take it: the curve's
-  level when the run starts is asked of `modetrade.chargers()`, the cycle's own
-  test. The gate (`mode_gate`, UX-53) is not bypassed. Control, checked every
-  15 minutes through tomorrow (`test_ux54.py` part 7), gives and charges where
-  the tab has a block.
+  `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.
+- **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 (the curve puts a point
+  there), and a give block where it reaches the floor (a step end, within the
+  0.1 % the tab shows). Control, walked every 15 minutes through tomorrow
+  (`test_ux54.py` part 7, no tolerance), charges and gives in exactly the
+  quarters the tab has a block.
 - **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
@@ -60,12 +71,17 @@ is `SolarToday.add()` after the solar read, in a `try`, in memory.
 
 - 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. Control may also
-  charge longer than a block when a slower battery is still short at its end.
+  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 the 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