OPT-34 round 3: the latch ends on time, with the run, with the mode, and with the night

- F1: an expired latch is dropped whatever the run state; plan_targets() and the
  store loader ignore one that has ended (no stale latch after a restart).
- F2: the "charge goes on" line only while a cheap run is on.
- F3: a battery that is off or no longer Leftover solar leaves the latch.
- F4: a run carries the latch on only if it starts by the bell start (06:00
  local) after the latch began (manager's call, 2026-10-31).
Tests: test_opt34 scenarios stale/stale_live and part 5; test_modes_p4 asks at a
moment inside the latch.

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

goodwe_controller/app/main.py

@@ -221,18 +221,29 @@ CHARGE_LATCH_GRACE_S = 900.0
 FORECAST_READ_S = 60.0
 
 
-def _load_latch(data):
-    """`(until, {name: level %})` from the store, or None if it is not a
-    well-formed latch (OPT-34)."""
+def _load_latch(data, now=None):
+    """`(until, {name: level %}, born)` from the store, or None if it is not a
+    well-formed latch or has ended (OPT-34)."""
     try:
         until = datetime.fromisoformat(data["until"])
+        born = datetime.fromisoformat(data.get("born") or data["until"])
         levels = {str(n): float(v) for n, v in data["levels"].items()}
     except (TypeError, KeyError, ValueError, AttributeError):
         return None
-    if until.tzinfo is None or not levels or not all(
+    if until.tzinfo is None or born.tzinfo is None or not levels or not all(
             math.isfinite(v) and 0.0 <= v <= 100.0 for v in levels.values()):
         return None
-    return until, levels
+    if now is not None and now >= until:
+        return None
+    return until, levels, born
+
+
+def _night_limit(born):
+    """OPT-34: a run that starts after this cannot carry the latch on: the
+    first bell start (`solarfc.BELL_FROM_H`, local) after `born`."""
+    d0, d1 = solarfc._bounds(born)
+    bell = solarfc._bell_start(d0)
+    return bell if bell > born else solarfc._bell_start(d1)
 
 
 def why_raised(resolution, claims) -> bool:
@@ -1028,7 +1039,8 @@ class Controller:
         self._plan_targets = None
         # OPT-34: `(until, {name: level %})` of a night charge under way.
         self._charge_latch = _load_latch(
-            (getattr(store, "data", None) or {}).get(CHARGE_LATCH_KEY))
+            (getattr(store, "data", None) or {}).get(CHARGE_LATCH_KEY),
+            datetime.now(timezone.utc))
         self.house_profile = None
         if self.fc_entity is not None:
             self.house_profile = dayplan.HouseProfile(
@@ -2384,10 +2396,12 @@ class Controller:
         of a night charge that has started (OPT-34): it keeps that level."""
         if self.solar_fc is None:
             lt = self._charge_latch
-            return None if lt is None else dict(lt[1])
+            if lt is None or datetime.now(timezone.utc) >= lt[0]:
+                return None
+            return dict(lt[1])
         return self._plan_targets
 
-    def _latch_charge(self, now, runs, targets) -> None:
+    def _latch_charge(self, now, runs, targets, packs=None) -> None:
         """OPT-34, once per cycle after `modetrade.decide()`. A night grid
         charge that has started keeps its planned level when the forecast goes
         mid-charge (the kept figure ends and the sensors are still silent).
@@ -2400,15 +2414,26 @@ class Controller:
         is none, `plan_targets()` gives the latched levels, so the charge goes
         on to them, and `weather_held()` keeps the narrow price gap. The latch
         lasts through every cheap run on and one price slot after the last
-        (`CHARGE_LATCH_GRACE_S`); a charge that never started has none."""
+        (`CHARGE_LATCH_GRACE_S`), but a run is carried on only if it starts
+        by the bell start of the night the latch began in (`_night_limit()`;
+        the run under way then finishes). It is dropped when `now` passes its
+        end whatever the run state, and a battery that is off or no longer in
+        a mode with a planned level (`packs`) leaves it. A charge that never
+        started has none."""
         old = lt = self._charge_latch
         tick = self.mode_tick
         run = None if runs is None else runs.cheap
         in_run = run is not None and run.holds(now)
-        until = None if run is None else run.end + timedelta(
-            seconds=CHARGE_LATCH_GRACE_S)
-        if lt is not None and not in_run and now >= lt[0]:
+        grace = timedelta(seconds=CHARGE_LATCH_GRACE_S)
+        if lt is not None and now >= lt[0]:
             lt = None
+        if lt is not None and packs is not None:
+            ok = {p.name for p in packs
+                  if p.use and p.mode in packmode.PLAN_CHARGE_MODES}
+            lv = {n: v for n, v in lt[1].items() if n in ok}
+            lt = (lt[0], lv, lt[2]) if lv else None
+        # A run may carry the latch on only if it starts by the night's bell.
+        carry = in_run and (lt is None or run.start <= _night_limit(lt[2]))
         if in_run and self.solar_fc is not None:
             # Rebuilt from the plan: a battery already latched follows its
             # level up or down whatever its role this tick (a fresh figure may
@@ -2419,14 +2444,20 @@ class Controller:
             if tick is not None and tick.action == modetrade.CHARGE:
                 lv.update({n: float(tg[n]) for n, r in tick.roles.items()
                            if r == modetrade.CHARGE and n in tg})
-            lt = (max(until, lt[0]) if lt is not None else until, lv) \
-                if lv else None
-        elif lt is not None and in_run:
-            lt = (max(lt[0], until), lt[1])
+            if not lv:
+                lt = None
+            elif lt is None:
+                lt = (run.end + grace, lv, now)
+            else:
+                lt = (max(run.end + grace, lt[0]) if carry else lt[0], lv,
+                      lt[2])
+        elif lt is not None and carry:
+            lt = (max(lt[0], run.end + grace), lt[1], lt[2])
         if lt != old:
             self._charge_latch = lt
             self.store.set(CHARGE_LATCH_KEY, None if lt is None else {
-                "until": lt[0].isoformat(), "levels": lt[1]})
+                "until": lt[0].isoformat(), "levels": lt[1],
+                "born": lt[2].isoformat()})
 
     def _mode_roles(self, now, maint_results):
         """OPT-11 P3: each battery's role and range this tick. Grid charging
@@ -2500,7 +2531,7 @@ class Controller:
             blocked=self._charge_blocked_q == quarter,
             done_charge=done_c, done_sell=done_s, targets=targets,
             draining=any(r.phase == DRAIN for r in maint_results or ()))
-        self._latch_charge(now, runs, targets)
+        self._latch_charge(now, runs, targets, packs)
         # A charge the guard or the headroom stopped stays off this period.
         # OPT-15: only a MEASURED stop latches; the first unmeasured headroom
         # (None) in a quarter stops this tick only, so a gap cannot cost the