@@ -719,6 +719,7 @@ xticks
 yaxis
 yaxistooltip
 yday
+yearless
 ylabel
 YOURSERIAL
 yuanzhi
 
@@ -15,7 +15,7 @@
 import time
 import uuid
 import traceback
-from utils import calc_percent_limit, export_mode_of, export_target_of, export_power_of
+from utils import calc_percent_limit, export_mode_of, export_target_of, export_power_of, localize_yearless_window
 from const import EXPORT_MODE_FREEZE, EXPORT_MODE_IDLE
 import pytz as _pytz
 
@@ -433,36 +433,17 @@ def _refresh_ev_windows(self):
         with datetime strings in ``"%m-%d %H:%M:%S"`` format (produced by output.py).
 
         Datetimes are localized using ``self.local_tz`` so comparisons respect the component
-        timezone and DST transitions.  Year boundaries are handled: if a parsed start is more
-        than 23 hours in the past *and the window has already ended* (i.e. the plan was built on
-        Dec 31 and contains Jan 1 windows), the year is bumped forward - a still-active long
-        window is left alone even if its start is over 23 hours old (#269).  Similarly, if end
-        falls before start after localization the end year is incremented to handle windows that
-        straddle midnight
-        on New Year's Eve.
+        timezone and DST transitions.  Year boundaries are handled by
+        ``utils.localize_yearless_window()`` - see its docstring for how a window that straddles
+        New Year (#269), or is simply read back after ``now`` has itself rolled over into a new
+        year, is anchored correctly either way.
         """
         planned = self.get_state_wrapper(f"binary_sensor.{self.prefix}_car_charging_slot", attribute="planned") or []
         now = datetime.datetime.now(self.local_tz)
-        current_year = now.year
         windows = []
         for w in planned:
             try:
-                start_naive = datetime.datetime.strptime(w["start"], "%m-%d %H:%M:%S").replace(year=current_year)
-                end_naive = datetime.datetime.strptime(w["end"], "%m-%d %H:%M:%S").replace(year=current_year)
-                start_dt = self.local_tz.localize(start_naive)
-                end_dt = self.local_tz.localize(end_naive)
-                # If start is far in the past the plan crossed a year boundary (Dec 31 → Jan 1).
-                # Only treat it that way if the window has also finished - a still-active long
-                # window (end still ahead of now) legitimately started that long ago and must not
-                # be shifted a year forward, or _should_ev_charge_now() stops seeing it as current
-                # and the charger is told to stop mid-window (#269).
-                if start_dt < now - datetime.timedelta(hours=23) and end_dt < now:
-                    start_dt = start_dt.replace(year=start_dt.year + 1)
-                    end_dt = end_dt.replace(year=end_dt.year + 1)
-                elif end_dt < start_dt:
-                    # end crossed into the new year but start did not (e.g. 23:30 → 00:30)
-                    end_dt = end_dt.replace(year=end_dt.year + 1)
-                windows.append((start_dt, end_dt))
+                windows.append(localize_yearless_window(w["start"], w["end"], "%m-%d %H:%M:%S", now, self.local_tz))
             except (KeyError, ValueError):
                 continue
         self._ev_windows = windows
 
@@ -28,6 +28,7 @@
 from const import TIME_FORMAT_HA
 from component_base import ComponentBase
 from predbat_metrics import record_api_call
+from utils import localize_yearless_window
 
 GOOGLE_API_KEY = "AIzaSyC8ZeZngm33tpOXLpbXeKfwtyZ1WrkbdBY"  # cspell:disable-line
 VERSION = "1.5.1"
@@ -335,21 +336,11 @@ def refresh_car_windows(self):
         windows = []
         for window in planned:
             try:
-                start = self.local_tz.localize(datetime.datetime.strptime(window["start"], PLAN_TIME_FORMAT).replace(year=now.year))
-                end = self.local_tz.localize(datetime.datetime.strptime(window["end"], PLAN_TIME_FORMAT).replace(year=now.year))
+                # The plan carries no year - utils.localize_yearless_window() rebuilds it around
+                # now, correctly handling a window that straddles New Year (#269) either direction.
+                windows.append(localize_yearless_window(window["start"], window["end"], PLAN_TIME_FORMAT, now, self.local_tz))
             except (KeyError, TypeError, ValueError):
                 continue
-            # The plan carries no year, so rebuild it around now for windows that cross New Year.
-            # A start more than 23 hours in the past is only a rollover artifact if the window has
-            # also finished - a still-active long window (its end still ahead of now) legitimately
-            # started that long ago and must not be shifted a year forward, or should_charge_now()
-            # stops seeing it as current and the charger is told to stop mid-window (#269).
-            if start < now - timedelta(hours=23) and end < now:
-                start = start.replace(year=start.year + 1)
-                end = end.replace(year=end.year + 1)
-            elif end < start:
-                end = end.replace(year=end.year + 1)
-            windows.append((start, end))
         self.control_windows = windows
         return True
 
 
@@ -4400,25 +4400,28 @@ def test_should_charge_now_no_windows(self):
         assert gw._should_ev_charge_now() is False
 
     def test_refresh_ev_windows_year_boundary(self):
-        """Windows whose parsed start would be >23 h in the past get their year bumped."""
+        """A window genuinely dated the prior calendar year (Dec 31) is anchored to it, not now.year."""
         import datetime as dt_mod
+        from unittest.mock import patch
 
         gw = self._make_gateway()
-        now = dt_mod.datetime.now(gw.local_tz)
-        # Simulate a Jan 1 window parsed with current_year when now is Dec 31
-        # by injecting a planned entry whose start, parsed with the current year, is 30 h in the past
-        stale = now - dt_mod.timedelta(hours=30)
-        future_end = stale + dt_mod.timedelta(hours=2)
-        # Format as MM-DD HH:MM:SS — these will be parsed with current year and end up in the past
-        planned = [{"start": stale.strftime("%m-%d %H:%M:%S"), "end": future_end.strftime("%m-%d %H:%M:%S"), "kwh": 5.0, "average": 20.0, "cost": 1.0}]
+        # A plan built Dec 31 that ran a window into the small hours of Jan 1, read back just after
+        # midnight on Jan 1 - now.year already sees the new year, so the Dec 31 half of the window
+        # must anchor to the *previous* year, not now.year (Copilot review on #5120: naively using
+        # now.year for both ends previously put a Dec 31 start a year in the future here).
+        fixed_now = dt_mod.datetime(2027, 1, 1, 0, 15, 0, tzinfo=gw.local_tz)
+        planned = [{"start": "12-31 23:30:00", "end": "01-01 01:30:00", "kwh": 5.0, "average": 20.0, "cost": 1.0}]
         gw.get_state_wrapper = lambda entity, attribute=None: planned if attribute == "planned" else "on"
 
-        gw._refresh_ev_windows()
+        with patch("gateway.datetime") as mock_dt:
+            mock_dt.datetime.now.return_value = fixed_now
+            gw._refresh_ev_windows()
 
         assert len(gw._ev_windows) == 1
         start_dt, end_dt = gw._ev_windows[0]
-        # After year bump, start should be in the future (next year)
-        assert start_dt > now
+        assert start_dt.year == 2026, f"Dec 31 start should anchor to the previous year, got {start_dt}"
+        assert end_dt.year == 2027, f"Jan 1 end should anchor to the current year, got {end_dt}"
+        assert start_dt <= fixed_now < end_dt, "now (00:15 Jan 1) should fall inside the window"
 
     def test_refresh_ev_windows_long_active_not_shifted(self):
         """A still-active window whose start is over 23h old is not mistaken for a year rollover (#269)."""
 
@@ -0,0 +1,85 @@
+# -----------------------------------------------------------------------------
+# Predbat Home Battery System
+# Copyright Trefor Southwell 2026 - All Rights Reserved
+# This application maybe used for personal use only and not for commercial use
+# -----------------------------------------------------------------------------
+# fmt off
+# pylint: disable=consider-using-f-string
+# pylint: disable=line-too-long
+# pylint: disable=attribute-defined-outside-init
+
+from datetime import datetime
+import pytz
+from utils import localize_yearless_window
+
+TIME_FORMAT = "%m-%d %H:%M:%S"
+LONDON = pytz.timezone("Europe/London")
+
+
+def test_localize_yearless_window(my_predbat=None):
+    """
+    Test utils.localize_yearless_window() - anchoring a "%m-%d %H:%M:%S" start/end pair (as
+    output.py's car_charging_slot "planned" attribute publishes them, with no year) onto a real
+    year close to `now`, including the New Year boundary case that motivated it (#269, and the
+    Copilot review on #5120 that found the original gateway.py/ohme.py heuristic could anchor a
+    still-current window a year in the future once `now` had itself rolled into January).
+    """
+    failed = False
+    print("**** Testing localize_yearless_window ****")
+
+    # Test 1: an ordinary same-day window, nowhere near a year boundary
+    now = LONDON.localize(datetime(2026, 6, 15, 14, 0, 0))
+    start, end = localize_yearless_window("06-15 13:00:00", "06-15 15:00:00", TIME_FORMAT, now, LONDON)
+    if (start.year, end.year) != (2026, 2026) or not (start <= now < end):
+        print(f"ERROR: Test 1 (ordinary window) failed - got start={start} end={end}")
+        failed = True
+
+    # Test 2: a window straddling New Year's Eve into New Year's Day, read while it's still
+    # underway on Dec 31 - both ends belong to the same current year
+    now = LONDON.localize(datetime(2026, 12, 31, 23, 45, 0))
+    start, end = localize_yearless_window("12-31 23:30:00", "01-01 01:30:00", TIME_FORMAT, now, LONDON)
+    if start.year != 2026 or end.year != 2027 or not (start <= now < end):
+        print(f"ERROR: Test 2 (NYE window, read before midnight) failed - got start={start} end={end}")
+        failed = True
+
+    # Test 3: the same window, but read back once `now` has itself rolled over into January - the
+    # Dec 31 half must anchor to the *previous* year, not now.year, or the window is pushed a full
+    # year into the future and stops covering `now` at all (Copilot review on #5120)
+    now = LONDON.localize(datetime(2027, 1, 1, 0, 15, 0))
+    start, end = localize_yearless_window("12-31 23:30:00", "01-01 01:30:00", TIME_FORMAT, now, LONDON)
+    if start.year != 2026 or end.year != 2027 or not (start <= now < end):
+        print(f"ERROR: Test 3 (NYE window, read after midnight rollover) failed - got start={start} end={end}")
+        failed = True
+
+    # Test 4: a still-active long window whose start is genuinely a couple of days old, nowhere
+    # near a year boundary - must not be shifted a year in either direction (#269)
+    now = LONDON.localize(datetime(2026, 6, 16, 23, 5, 0))
+    start, end = localize_yearless_window("06-14 00:10:00", "06-17 02:00:00", TIME_FORMAT, now, LONDON)
+    if start.year != 2026 or end.year != 2026 or not (start <= now < end):
+        print(f"ERROR: Test 4 (long active window) failed - got start={start} end={end}")
+        failed = True
+
+    # Test 5: a midnight-crossing window with no year-boundary involvement at all (e.g. 23:00-00:30
+    # in mid-June) - end must land on the following calendar day, same year, without needing the
+    # New Year handling to fire
+    now = LONDON.localize(datetime(2026, 6, 15, 23, 30, 0))
+    start, end = localize_yearless_window("06-15 23:00:00", "06-16 00:30:00", TIME_FORMAT, now, LONDON)
+    if (start.year, end.year) != (2026, 2026) or end.day != 16 or not (start <= now < end):
+        print(f"ERROR: Test 5 (ordinary midnight-crossing window) failed - got start={start} end={end}")
+        failed = True
+
+    # Test 6: an unparseable time string raises ValueError, same as the underlying strptime - the
+    # gateway.py/ohme.py callers rely on this to skip a malformed planned entry rather than crash
+    try:
+        localize_yearless_window("not-a-date", "06-15 15:00:00", TIME_FORMAT, now, LONDON)
+        print("ERROR: Test 6 (unparseable string) should have raised ValueError")
+        failed = True
+    except ValueError:
+        pass
+
+    if not failed:
+        print("**** All localize_yearless_window tests PASSED ****")
+    else:
+        print("**** Some localize_yearless_window tests FAILED ****")
+
+    return failed
@@ -283,6 +283,7 @@ def test_ohme(my_predbat=None):
         ("control_enable", _test_ohme_control_enable_rules, "ohme_control enable rules"),
         ("control_windows", _test_ohme_control_window_parsing, "control window parsing"),
         ("control_midnight", _test_ohme_control_window_year_rollover, "control windows across new year"),
+        ("control_midnight_after", _test_ohme_control_window_year_rollover_after_midnight, "control window across new year, read back after midnight has rolled over"),
         ("control_long_active", _test_ohme_control_window_long_active_not_shifted, "long active window not mistaken for a rollover"),
         ("control_startup", _test_ohme_control_waits_for_plan, "control waits for a published plan"),
         ("control_edges", _test_ohme_control_edge_triggered, "control only acts on transitions"),
@@ -1758,6 +1759,29 @@ def _test_ohme_control_window_year_rollover(my_predbat=None):
     return 0
 
 
+def _test_ohme_control_window_year_rollover_after_midnight(my_predbat=None):
+    """A Dec 31 -> Jan 1 window read back once now has itself rolled into January (Copilot review on #5120)"""
+    print("**** Running test_ohme_control_window_year_rollover_after_midnight ****")
+
+    tz = pytz.timezone("Europe/London")
+    # Same window as the new year's eve test above, but now is read a little after midnight, once
+    # the clock has already ticked into January. Naively anchoring both start and end to now.year
+    # previously put the Dec 31 start a full year in the future (next Dec 31) rather than the
+    # actual previous one, so should_charge_now() stopped seeing the still-active window at all.
+    now = tz.localize(datetime.datetime(2027, 1, 1, 0, 15, 0))
+    window = {"start": "12-31 23:30:00", "end": "01-01 01:30:00", "kwh": 7.0}
+    api = _ohme_control_api(windows=[window], now=now)
+
+    api.refresh_car_windows()
+    start, end = api.control_windows[0]
+    assert start.year == 2026, f"Dec 31 start should anchor to the previous year, got {start}"
+    assert end.year == 2027, f"Jan 1 end should anchor to the current year, got {end}"
+    assert api.should_charge_now() is True, "Expected to still be charging at 00:15 on new year's day"
+
+    print("PASS: new year window handled after midnight rollover")
+    return 0
+
+
 def _test_ohme_control_window_long_active_not_shifted(my_predbat=None):
     """Test a still-active window whose start is over 23 hours old is not mistaken for a New Year rollover (#269)"""
     print("**** Running test_ohme_control_window_long_active_not_shifted ****")
 
@@ -46,6 +46,7 @@
 from tests.test_fetch_config_options import test_fetch_config_options
 from tests.test_multi_inverter import run_inverter_multi_tests
 from tests.test_window2minutes import test_window2minutes
+from tests.test_localize_yearless_window import test_localize_yearless_window
 from tests.test_hass_watcher import test_hass_watcher
 from tests.test_new_install_detection import test_new_install_detection
 from tests.test_history_attribute import test_history_attribute
@@ -446,6 +447,7 @@ def main():
         ("rate_export_max_forward_calc", test_rate_export_max_forward_calc, "Rate export max forward calc tests", False),
         ("window_sort", run_window_sort_tests, "Window sort tests", False),
         ("window2minutes", test_window2minutes, "Window to minutes tests", False),
+        ("localize_yearless_window", test_localize_yearless_window, "Year-anchoring for %m-%d planned window strings, including New Year boundary", False),
         ("hass_watcher", test_hass_watcher, "Standalone-mode file watcher tests (#4397/#4396)", False),
         ("new_install_detection", test_new_install_detection, "New-install misdetection tests (Bug B, #4397/#4396, #3259, #3306)", False),
         ("compute_metric", run_compute_metric_tests, "Compute metric tests", False),
 
@@ -1611,6 +1611,42 @@ def window2minutes(start, end, minutes_now):
     return compute_window_minutes(start, end, minutes_now)
 
 
+def localize_yearless_window(start_str, end_str, time_format, now, local_tz):
+    """
+    Parse a "%m-%d %H:%M:%S"-style start/end pair (no year, as output.py's car_charging_slot
+    "planned" attribute publishes them) into a year-anchored, tz-aware (start, end) pair close to
+    `now`, correctly handling a window that straddles New Year.
+
+    Naively assuming `now.year` for both breaks in two ways right around New Year: a still-active
+    long window whose start is genuinely >23h in the past (e.g. it began on Dec 31 and now is Jan 1)
+    must not be shifted a year forward just because it's old, or callers stop seeing it as current
+    mid-window (#269); and a window recorded around Dec 31 but read back once `now` has itself
+    rolled over to the following January would otherwise anchor its start a full year in the future
+    rather than the previous Dec 31 it actually meant, throwing the elapsed-time comparison off
+    entirely rather than merely off by a year in the expected direction.
+
+    Handles both directions the same way instead of a directional heuristic: each of start/end is
+    independently anchored to whichever of now.year-1/now.year/now.year+1 places it closest to
+    `now`, so a >6-month gap in either direction is corrected before start/end are ever compared to
+    each other or to `now`. This also gets a window that straddles New Year right without any
+    further correction: anchoring start (Dec 31) and end (Jan 1) independently to whichever side of
+    the boundary is closest to `now` always leaves end on the later calendar date of the pair,
+    since the two are only ever a few hours apart while the anchoring tolerance is ~6 months.
+
+    Raises ValueError via strptime if either string doesn't match `time_format` - callers already
+    wrap this in a try/except for that (KeyError/TypeError/ValueError), as they did before this was
+    extracted from gateway.py/ohme.py duplicating the same logic.
+    """
+
+    def closest_year(naive):
+        candidates = (naive.replace(year=now.year + delta) for delta in (-1, 0, 1))
+        return local_tz.localize(min(candidates, key=lambda dt: abs(local_tz.localize(dt) - now)))
+
+    start_dt = closest_year(datetime.strptime(start_str, time_format))
+    end_dt = closest_year(datetime.strptime(end_str, time_format))
+    return start_dt, end_dt
+
+
 def minutes_since_midnight(now, midnight):
     """
     Compute minutes from midnight to now, floored to a PREDICT_STEP boundary