fix(output): don't flag a History slot for a warning in an edge it doesn't trust

The slot reconstruction ignores the first or last five minutes of a slot
when they don't hold one state, as that is the previous (or next) slot's
status lagging the boundary. The warning flag scanned the whole slot, so a
warning that lagged in with that leftover flagged a slot whose shown state
was rebuilt without those minutes. Warnings in an untrusted edge are now
dropped along with the status they arrived with.

Also notes why a warning is held across a recorder gap: it is held with
the same forward-filled status the slot's state is rebuilt from.

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

Author: chalfontchubby

apps/predbat/output.py

@@ -3571,7 +3571,10 @@ def calculate_yesterday(self):
                     status = status.split(",")[0].strip()
                 predbat_status[minute] = status
                 if warning:
-                    # predbat_status is keyed by minutes ago; plan-minute m is (minutes_now + end_record - m) ago
+                    # predbat_status is keyed by minutes ago; plan-minute m is (minutes_now + end_record - m) ago.
+                    # minute_data_state() holds each recorded status until the next one, so across a gap in
+                    # the recorder the warning is held along with the state it arrived with - the flag
+                    # stays with the state the slot shows, which is rebuilt from the same held value.
                     status_warnings[minutes_now + end_record - minute] = warning
             # The car icon on this table follows the recorded "Hold for car" status, as its SoC is measured.
             # predbat_status is keyed by minutes ago; plan-minute m is (minutes_now + end_record - m) ago.
@@ -3592,6 +3595,12 @@ def calculate_yesterday(self):
                 tally_start = 0 if len(set(slot_statuses[:edge_minutes])) == 1 else edge_minutes
                 tally_end = self.plan_interval_minutes if len(set(slot_statuses[-edge_minutes:])) == 1 else self.plan_interval_minutes - edge_minutes
 
+                # A warning in an edge window the tally does not trust came in with the previous (or
+                # next) slot's leftover status, so it must not flag this slot either - the flag names
+                # a problem that ran alongside the minutes this slot's state was rebuilt from.
+                for slot_offset in list(range(0, tally_start)) + list(range(tally_end, self.plan_interval_minutes)):
+                    status_warnings.pop(minute + slot_offset, None)
+
                 charge_start_minute = None
                 charge_end_minute = None
                 export_start_minute = None

apps/predbat/tests/test_calculate_yesterday.py

@@ -2399,6 +2399,28 @@ def _warning_for_one_hour(stamp):
         print("ERROR: the warning should flag plan minutes {}-{} exactly, got {} minutes from {} to {}".format(warning_start, warning_end - 1, len(flagged), min(flagged) if flagged else None, max(flagged) if flagged else None))
         failed = True
 
+    # A warning that lags two minutes into the next slot, behind the previous slot's state, is that
+    # slot's leftover: the next slot's state is rebuilt without those minutes, so its flag is too.
+    lag_slot = 16 * 60
+
+    def _warning_lags_into_next_slot(stamp):
+        plan_minute = int((stamp - plan_start).total_seconds() // 60)
+        if lag_slot - 30 <= plan_minute < lag_slot:
+            return [(0, "Charging, " + warning)]
+        if plan_minute == lag_slot:
+            return [(0, "Charging, " + warning), (120, "Exporting")]
+        return [(0, "Exporting")]
+
+    captured = _reconstruct_windows_from_status(my_predbat, _warning_lags_into_next_slot)
+    flagged = set((captured.get("status_warnings") or {}).keys())
+    if flagged != set(range(lag_slot - 30, lag_slot)):
+        print(
+            "ERROR: a warning lagging into the next slot's edge should flag only the slot it belongs to ({}-{}), got {} minutes from {} to {}".format(
+                lag_slot - 30, lag_slot - 1, len(flagged), min(flagged) if flagged else None, max(flagged) if flagged else None
+            )
+        )
+        failed = True
+
     # A clean run is not flagged
     captured = _reconstruct_windows_from_status(my_predbat, lambda stamp: [(0, "Exporting")])
     if captured.get("status_warnings"):