OPT-23, OPT-28: the day plan counts the sun right, and the night charge covers the expensive-hour shortfall

OPT-23: a state-only forecast is read from now for every span
(Forecast.between since=), so the plan's per-hour sun adds up to the day's
figure, today and tomorrow. Hourly splits are unchanged. The Forecast tab
reads spans the same way.

OPT-28: a Leftover solar battery buys, from the floor, the sum over the
expensive hours of max(0, house - trust x sun), / EFF. Several Leftover
solar batteries hold it together by capacity, the ceiling passes the rest
on, and what none can hold is said (Plan.uncovered_kwh). Home's grid block,
the Batteries line and the mode help (EN + NL) say the level, what it
covers, and that Leftover solar buys only what the sun will not give.

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

goodwe_controller/app/dayplan.py

@@ -7,20 +7,31 @@ turns the level into permission to charge from the grid; main.py rebuilds the
 plan with the price runs (at most every 15 minutes) and keeps a level unless
 it moves by `HYST_KWH` or `HYST_FRAC` (`hold()`).
 
-The sums (OPT-11-design section 1, "Excess solar", with the owner's answers):
+The sums (OPT-11-design section 1, "Excess solar", with the owner's answers;
+OPT-28 for the second):
 * `sun`: trust x the solar the house will not use, between now and the
   expensive run the cheap run is for, x the charge efficiency:
   `trust x sum_h max(0, forecast_h - house_h) x EFF`.
 * Solar first batteries take it first, up to the ceiling. What is left is
   shared by the Leftover solar batteries by their room.
+* `short` (OPT-28): what the house draws in the expensive run that the sun
+  will not give, `sum_h max(0, house_h - trust x forecast_h)` over every
+  hour of the run, early morning and evening. The Leftover solar batteries
+  hold it together: `short / EFF` above the floor, shared by capacity, and
+  a battery that reaches the ceiling passes the rest to the others. What
+  all of them cannot hold (`Plan.uncovered_kwh`) is not bought: the grid
+  carries it at the dear price.
 * Cheap hours only ignores the plan and fills to the ceiling, as in P3 and
   the design (section 1). Skipping the sun's share cost money in the replay
   (PR #156 review: 29.72 against 29.41 EUR on real 2026 prices).
-* A Leftover solar battery charges only up to what the house will draw from
-  it in the expensive runs before the next cheap run, less its share:
-  `min(ceiling, floor + house use / EFF) - share`. So it buys only the
+* A Leftover solar battery charges from the grid up to the level it needs
+  for its part of `short`, less its share of the sun before the run:
+  `min(ceiling, floor + its part / EFF) - share`. So it buys only the
   shortfall, not up to the ceiling.
 * Solar first never charges from the grid (owner, 2026-09-29).
+* A state-only forecast is read from now for every span (`Forecast.between`
+  `since=`, OPT-23), so the hours add up to the day's figure.
+DECISIONS/OPT-23-28-the-night-charge-covers-the-dear-hours.md has the record.
 
 The house profile is the add-on's own measurement, grid + battery power, per
 local hour, over the last `PROFILE_DAYS` days; the estimate for an hour is the
@@ -31,7 +42,7 @@ control decision.
 """
 
 import statistics
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 
 from .packmode import LEFTOVER_SOLAR, SOLAR_FIRST
@@ -154,6 +165,11 @@ class Plan:
     targets: dict               # name -> level % (Leftover solar only)
     need_kwh: dict              # name -> kWh from the grid (0: none)
     share_kwh: dict             # name -> kWh of solar counted for it
+    # OPT-28: the expensive hours' shortfall, the part of it each battery
+    # covers, and what no battery can hold. All kWh on the house's side.
+    short_kwh: float = 0.0
+    cover_kwh: dict = field(default_factory=dict)
+    uncovered_kwh: float = 0.0
 
 
 def _hour_slices(t0, t1):
@@ -171,6 +187,31 @@ def _hour_slices(t0, t1):
     return out
 
 
+def _spread(amount, room, weight):
+    """Share `amount` over the keys of `room` by `weight`, none past its
+    room, what one cannot take passed to the others. Returns `(taken,
+    left)`: what each took and what none could."""
+    got = {k: 0.0 for k in room}
+    left = float(amount)
+    live = {k for k, r in room.items() if r > 1e-9 and weight.get(k, 0) > 0}
+    while left > 1e-9 and live:
+        total = sum(weight[k] for k in live)
+        used, full = 0.0, set()
+        for k in sorted(live):
+            part = left * weight[k] / total
+            free = room[k] - got[k]
+            if part >= free - 1e-9:
+                part = free
+                full.add(k)
+            got[k] += part
+            used += part
+        left -= used
+        if not full:
+            break
+        live -= full
+    return got, max(0.0, left)
+
+
 def _room(p, to_pct):
     if p.capacity_kwh is None or p.soc is None:
         return 0.0
@@ -194,7 +235,7 @@ def plan(forecast, house, runs, now, packs, *, trust_pct, floor_pct,
     trust = max(0.0, min(1.0, float(trust_pct) / 100.0))
     sun = fc_sum = 0.0
     for s, e, h in _hour_slices(now, until.start):
-        pv = forecast.between(s, e)
+        pv = forecast.between(s, e, since=now)
         if pv is None:
             return None             # the span reaches a day with no forecast
         hrs = (e - s).total_seconds() / 3600.0
@@ -212,30 +253,40 @@ def plan(forecast, house, runs, now, packs, *, trust_pct, floor_pct,
     rooms = {p.name: _room(p, ceiling_pct) for p in price}
     total_room = sum(rooms.values())
 
-    # What the house draws in the expensive runs from the one this plan is
-    # for until the next cheap run (or a day), from the profile.
+    # OPT-28: what the house draws in the expensive runs, from the one this
+    # plan is for until the next cheap run (or a day), that the sun will not
+    # give. An hour with sun is read at no less than the night base, as the
+    # sun sum above reads it (the profile is net of the sun the house used);
+    # an hour without is read as measured. A run hour with no forecast counts
+    # no sun.
     horizon = until.start + timedelta(hours=24)
-    use_kwh = 0.0
+    short = 0.0
     for g in runs.give:
         if g.start < until.start or g.start >= horizon:
             continue
         for s, e, h in _hour_slices(g.start, g.end):
-            use_kwh += max(0.0, house_w(h)) * (
-                e - s).total_seconds() / 3600.0 / 1000.0
+            pv = forecast.between(s, e, since=now) or 0.0
+            w = max(0.0, house_w(h))
+            if pv > 0.0:
+                w = max(w, base_w)
+            short += max(0.0, w * (e - s).total_seconds() / 3.6e6
+                         - trust * pv)
     caps = {p.name: float(p.capacity_kwh) for p in price}
-    cap_sum = sum(caps.values()) or 1.0
+    span = max(0.0, float(ceiling_pct) - float(floor_pct))
+    held, left = _spread(short / EFF,
+                         {n: span / 100.0 * c for n, c in caps.items()},
+                         caps)
 
-    targets, need, share = {}, {}, {}
+    targets, need, share, cover = {}, {}, {}, {}
     for p in price:
         sh = excess * rooms[p.name] / total_room if total_room > 0 else 0.0
         sh_pct = sh / caps[p.name] * 100.0
-        want = use_kwh * caps[p.name] / cap_sum / EFF
-        top = min(float(ceiling_pct),
-                  float(floor_pct) + want / caps[p.name] * 100.0)
+        top = float(floor_pct) + held[p.name] / caps[p.name] * 100.0
         level = max(0.0, top - sh_pct)
         targets[p.name] = round(level, 2)
         need[p.name] = round(_room(p, level), 3)
         share[p.name] = round(sh, 3)
+        cover[p.name] = round(held[p.name] * EFF, 3)
     if sun < sf_room:
         verdict = DARK
     elif any(v > 0.05 for v in need.values()):
@@ -243,7 +294,8 @@ def plan(forecast, house, runs, now, packs, *, trust_pct, floor_pct,
     else:
         verdict = SUNNY
     return Plan(verdict, round(sun, 3), round(fc_sum, 3), until.start,
-                targets, need, share)
+                targets, need, share, round(short, 3), cover,
+                round(left * EFF if price else 0.0, 3))
 
 
 def hold(old: dict | None, new: dict, capacity: dict) -> dict: