@@ -2685,29 +2685,44 @@ def get_car_charging_planned(self):
             # streak's original evidence rather than collapsing onto the slot just confirmed.
             streak_anchor = self.car_charging_now_streak_last_read[car_n]
 
+            # A transient HA "unknown"/"unavailable" reading (tristate None) is no evidence either
+            # way, not a confirmed stop - ending the streak on it would drop confirmation after a
+            # sensor hiccup or restart even though the car may still be charging throughout. Only a
+            # real negative reading (tristate False) ends the streak; None falls through the same as
+            # a True read inside the guard window.
+            charging_now_tristate = self.get_car_charging_now_tristate(car_n)
+
             if slot_reading_confirms:
                 self.car_charging_now_confirmed_slots[car_n].add(current_slot_start)
                 self.car_charging_now_streak_last_read[car_n] = current_slot_start
-            elif not charging_now:
+            elif charging_now_tristate is False:
                 # Clearing the anchor too skips the backfill, so nothing is confirmed on the strength
                 # of a streak this read just ended.
                 streak_anchor = None
                 self.car_charging_now_streak_last_read[car_n] = None
-            # The third case (True inside the guard window) intentionally falls through untouched.
+            # The remaining cases (True inside the guard window, or an unknown/unavailable reading)
+            # intentionally fall through untouched.
             # Corollary worth knowing: if a streak has lapsed and every subsequent positive read lands
             # inside the guard window, no new streak starts and "started" silently behaves as
             # "none" for that car. It needs replans to have all but stopped for a whole slot, so
             # it is unlikely at the ~15s poll cadence, and it fails safe (under-trusting, not over-).
 
             # Confirm every slot from the anchor to now, so slots no replan happened to land in are
-            # still covered. Idempotent.
+            # still covered. Idempotent. streak_anchor here is deliberately the *previous* cycle's
+            # anchor (read above, before slot_reading_confirms could reassign it) - a fresh read this
+            # cycle still wants the gap since that old anchor backfilled (Test 3: resuming a streak at
+            # slot 4 must retroactively confirm slots 2 and 3 too). What must NOT happen is the
+            # cap-exceeded branch clobbering an anchor this cycle just (re-)set: a streak that had
+            # already lapsed past the rollover cap, followed by a fresh confirming read this cycle,
+            # would otherwise immediately wipe the anchor slot_reading_confirms just wrote, discarding
+            # the fresh confirm it was supposed to record (Copilot review on #5110).
             if streak_anchor is not None:
                 slots_since_anchor = (current_slot_start - streak_anchor) // 30
                 if 0 <= slots_since_anchor <= CAR_CHARGING_NOW_STREAK_MAX_ROLLOVER_SLOTS:
                     # + 30 rather than + 1: range()'s stop is exclusive and a step is a whole slot.
                     for backfill_slot in range(streak_anchor, current_slot_start + 30, 30):
                         self.car_charging_now_confirmed_slots[car_n].add(backfill_slot)
-                else:
+                elif not slot_reading_confirms:
                     # Cap exceeded with no fresh evidence - lapse the streak, but leave slots already
                     # confirmed while it was valid alone.
                     self.car_charging_now_streak_last_read[car_n] = None
 
@@ -199,6 +199,38 @@ def reset_streak_state():
     if not failed:
         print("Test 7 passed - streak correctly lapses beyond the rollover cap with no fresh read")
 
+    # Test 7b: a fresh confirming read must actually stick even when the *previous* cycle's anchor
+    # (still on record when this cycle starts) is already more than the rollover cap behind the new
+    # slot - it must not be wiped in the same cycle by the rollover-cap check comparing the fresh
+    # anchor against that now-superseded old one (Copilot review on #5110). Distinct from Test 7:
+    # there the lapse and the eventual read are two separate cycles; here both the stale-old-anchor
+    # comparison and the fresh confirming read happen in the SAME get_car_charging_planned() call.
+    print("*** Test 7b: a fresh read whose own old anchor is already past the cap still re-anchors ***")
+    reset_streak_state()
+    my_predbat.minutes_now = 8 * 60  # 08:00 - slot 480, a genuine positive read to establish an anchor
+    my_predbat.args["car_charging_now"] = "yes"
+    my_predbat.get_car_charging_planned()
+    old_anchor_7b = my_predbat.car_charging_now_streak_last_read[0]
+    if old_anchor_7b != 480:
+        print("ERROR: setup assumption broken - expected an anchor at slot 480, got {}".format(old_anchor_7b))
+        failed = True
+
+    # Jump straight to a slot comfortably beyond the rollover cap from slot 480, in one single call -
+    # the old anchor (480) is now stale enough that, uncorrected, the cap check would clear it, but
+    # this same cycle's own reading independently confirms and re-anchors the current slot.
+    fresh_slot = old_anchor_7b + (CAR_CHARGING_NOW_STREAK_MAX_ROLLOVER_SLOTS + 5) * 30
+    my_predbat.minutes_now = fresh_slot  # start of the slot - plenty of time left, passes the confirm guard
+    my_predbat.get_car_charging_planned()  # car_charging_now is still "yes"
+
+    if fresh_slot not in my_predbat.car_charging_now_confirmed_slots[0]:
+        print("ERROR: slot {} should be confirmed by this cycle's own fresh positive read".format(fresh_slot))
+        failed = True
+    if my_predbat.car_charging_now_streak_last_read[0] != fresh_slot:
+        print("ERROR: the fresh read should have re-anchored the streak at slot {}, got {}".format(fresh_slot, my_predbat.car_charging_now_streak_last_read[0]))
+        failed = True
+    if not failed:
+        print("Test 7b passed - a fresh read survives even when its own old anchor was already past the cap")
+
     # Test 8: old slots (more than a day behind the current slot) are pruned so the set cannot grow
     # unbounded on a long-running install.
     print("*** Test 8: stale confirmed slots are pruned ***")
@@ -296,6 +328,41 @@ def reset_streak_state():
     else:
         print("Test 11 passed")
 
+    # Test 12: a transient HA "unknown"/"unavailable" reading is not evidence of a stop - it must
+    # fall through the same as a guard-failing True read, leaving an active streak intact, rather
+    # than being treated as a negative edge (Copilot review on #5110). A real sensor genuinely goes
+    # "unknown" for a few seconds around an HA restart while the car may still be charging throughout.
+    print("*** Test 12: an unknown/unavailable reading does not end an active streak ***")
+    reset_streak_state()
+    my_predbat.minutes_now = 9 * 60  # 09:00 - slot 540, a genuine positive read starts the streak
+    my_predbat.args["car_charging_now"] = "yes"
+    my_predbat.get_car_charging_planned()
+    if my_predbat.car_charging_now_streak_last_read[0] != 540:
+        print("ERROR: setup assumption broken - expected an anchor at slot 540, got {}".format(my_predbat.car_charging_now_streak_last_read[0]))
+        failed = True
+
+    my_predbat.minutes_now = 9 * 60 + 30  # 09:30 - next slot (570), sensor now reporting "unknown"
+    my_predbat.args["car_charging_now"] = "unknown"
+    my_predbat.get_car_charging_planned()
+
+    if my_predbat.car_charging_now_streak_last_read[0] != 540:
+        print("ERROR: an unknown/unavailable reading should not have moved or cleared the streak anchor, got {}".format(my_predbat.car_charging_now_streak_last_read[0]))
+        failed = True
+    if 570 not in my_predbat.car_charging_now_confirmed_slots[0]:
+        print("ERROR: slot 570 should still have been backfilled by the still-active streak despite the unknown reading")
+        failed = True
+
+    # A genuine negative edge afterwards must still end the streak normally - "unknown" only
+    # suspends judgement, it does not disable the mechanism.
+    my_predbat.minutes_now = 10 * 60  # 10:00 - slot 600
+    my_predbat.args["car_charging_now"] = "no"
+    my_predbat.get_car_charging_planned()
+    if my_predbat.car_charging_now_streak_last_read[0] is not None:
+        print("ERROR: a genuine False reading after an unknown one should still end the streak, got anchor {}".format(my_predbat.car_charging_now_streak_last_read[0]))
+        failed = True
+    if not failed:
+        print("Test 12 passed - unknown/unavailable readings are ignored, real negative edges still end the streak")
+
     if not failed:
         print("**** All car_charging_now_confirmed_slots tests PASSED ****")
     else:
 
@@ -764,6 +764,70 @@ def run_rate_add_io_slots_tests(my_predbat):
     failed |= run_rate_add_io_slots_test("test41_sub_30min_interval_slot_decides_its_own_admission", my_predbat, slots_41, True, 12, expected_rates_41, confirmed=False)
     my_predbat.plan_interval_minutes = 30
 
+    print("\n**** Test 42: exclude_dynamic_io_slots strips a feed-side discount rate_add_io_slots() never trusted ****")
+    # rate_add_io_slots() only overlays a discount for minutes it explicitly adds to trusted_dynamic_
+    # minutes. A real Intelligent tariff can hand back an already-discounted rate straight from the
+    # feed for a future out-of-window minute (flagged via io_adjusted) that rate_add_io_slots() never
+    # even visited this cycle - exclude_dynamic_io_slots() is what has to catch and undo that one.
+    # "planned" is a deliberate no-op for this function (old pre-#4516 behaviour), so use "none" -
+    # the strictest level, and the only one that actually walks io_adjusted below.
+    my_predbat.trust_future_dynamic_iog_slots = "none"
+    saved_io_adjusted_42 = dict(my_predbat.io_adjusted)
+    my_predbat.trusted_dynamic_minutes = set()  # nothing trusted this cycle
+    rates_42 = {minute: 10.0 for minute in range(-96 * 60, max(my_predbat.forecast_minutes, 3 * 24 * 60))}
+    for minute in range(840, 870):  # 14:00-14:30, well outside the 23:30-05:30 fixed window
+        rates_42[minute] = 4.0
+        my_predbat.io_adjusted[minute] = True
+    result_rates_42 = my_predbat.exclude_dynamic_io_slots(rates_42)
+    for minute in range(840, 870):
+        if result_rates_42.get(minute) != my_predbat.rate_max_base:
+            print("ERROR: untrusted feed-discounted minute {} should be restored to rate_max_base ({}), got {}".format(minute, my_predbat.rate_max_base, result_rates_42.get(minute)))
+            failed = True
+        if minute in my_predbat.io_adjusted:
+            print("ERROR: untrusted feed-discounted minute {} should have its io_adjusted marker cleared".format(minute))
+            failed = True
+    my_predbat.io_adjusted = saved_io_adjusted_42
+
+    print("\n**** Test 43: exclude_dynamic_io_slots preserves a feed-side discount rate_add_io_slots() did trust ****")
+    my_predbat.trust_future_dynamic_iog_slots = "none"
+    saved_io_adjusted_43 = dict(my_predbat.io_adjusted)
+    rates_43 = {minute: 10.0 for minute in range(-96 * 60, max(my_predbat.forecast_minutes, 3 * 24 * 60))}
+    for minute in range(840, 870):
+        rates_43[minute] = 4.0
+        my_predbat.io_adjusted[minute] = True
+    my_predbat.trusted_dynamic_minutes = set(range(840, 870))  # this cycle already trusted these minutes
+    result_rates_43 = my_predbat.exclude_dynamic_io_slots(rates_43)
+    for minute in range(840, 870):
+        if result_rates_43.get(minute) != 4.0:
+            print("ERROR: trusted feed-discounted minute {} should keep its 4.0 rate, got {}".format(minute, result_rates_43.get(minute)))
+            failed = True
+        if minute not in my_predbat.io_adjusted:
+            print("ERROR: trusted feed-discounted minute {} should keep its io_adjusted marker".format(minute))
+            failed = True
+    my_predbat.io_adjusted = saved_io_adjusted_43
+    my_predbat.trusted_dynamic_minutes = set()
+
+    print("\n**** Test 44: exclude_dynamic_io_slots leaves a fixed-window minute alone even when untrusted ****")
+    # 02:00 is inside the guaranteed-cheap 23:30-05:30 window - that discount comes from the tariff
+    # itself, not a reclaimable dispatch, so it must survive regardless of trust_future_dynamic_iog_slots.
+    my_predbat.trust_future_dynamic_iog_slots = "none"
+    saved_io_adjusted_44 = dict(my_predbat.io_adjusted)
+    rates_44 = {minute: 10.0 for minute in range(-96 * 60, max(my_predbat.forecast_minutes, 3 * 24 * 60))}
+    fixed_window_minute_44 = 26 * 60  # 02:00 the following day relative to midnight_utc_26, well ahead of minutes_now=600
+    for minute in range(fixed_window_minute_44, fixed_window_minute_44 + 30):
+        rates_44[minute] = 4.0
+        my_predbat.io_adjusted[minute] = True
+    my_predbat.trusted_dynamic_minutes = set()
+    result_rates_44 = my_predbat.exclude_dynamic_io_slots(rates_44)
+    for minute in range(fixed_window_minute_44, fixed_window_minute_44 + 30):
+        if result_rates_44.get(minute) != 4.0:
+            print("ERROR: fixed-window minute {} should keep its 4.0 rate regardless of trust, got {}".format(minute, result_rates_44.get(minute)))
+            failed = True
+        if minute not in my_predbat.io_adjusted:
+            print("ERROR: fixed-window minute {} should keep its io_adjusted marker".format(minute))
+            failed = True
+    my_predbat.io_adjusted = saved_io_adjusted_44
+
     # Restore original state
     my_predbat.trust_future_dynamic_iog_slots = saved_trust_dynamic
     my_predbat.octopus_intelligent_limit_future_slots = saved_limit_future_slots