@@ -434,9 +434,11 @@ def _refresh_ev_windows(self):
 
         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 (i.e. the plan was built on Dec 31 and contains Jan 1
-        windows), the year is bumped forward.  Similarly, if end falls before start after
-        localization the end year is incremented to handle windows that straddle midnight
+        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.
         """
         planned = self.get_state_wrapper(f"binary_sensor.{self.prefix}_car_charging_slot", attribute="planned") or []
@@ -449,8 +451,12 @@ def _refresh_ev_windows(self):
                 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)
-                if start_dt < now - datetime.timedelta(hours=23):
+                # 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:
 
@@ -339,8 +339,12 @@ def refresh_car_windows(self):
                 end = self.local_tz.localize(datetime.datetime.strptime(window["end"], PLAN_TIME_FORMAT).replace(year=now.year))
             except (KeyError, TypeError, ValueError):
                 continue
-            # The plan carries no year, so rebuild it around now for windows that cross New Year
-            if start < now - timedelta(hours=23):
+            # 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:
 
@@ -4420,6 +4420,28 @@ def test_refresh_ev_windows_year_boundary(self):
         # After year bump, start should be in the future (next year)
         assert start_dt > now
 
+    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)."""
+        import datetime as dt_mod
+
+        gw = self._make_gateway()
+        now = dt_mod.datetime.now(gw.local_tz)
+        # A long/flat-rate window that started well over 23h ago but has not finished yet - its
+        # end is still ahead of now, so this is a genuinely active window, not a stale one left
+        # over from a plan built before a year boundary.
+        start = now - dt_mod.timedelta(hours=30)
+        end = now + dt_mod.timedelta(hours=2)
+        planned = [{"start": start.strftime("%m-%d %H:%M:%S"), "end": end.strftime("%m-%d %H:%M:%S"), "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()
+
+        assert len(gw._ev_windows) == 1
+        start_dt, end_dt = gw._ev_windows[0]
+        # Must not be bumped a year forward, or the still-active window stops matching "now"
+        assert start_dt.year == now.year
+        assert gw._should_ev_charge_now() is True
+
     def test_apply_sends_start_on_transition(self):
         """_apply_ev_charging_state sends SetChargingProfile then RemoteStartTransaction when entering a window."""
         import asyncio
 
@@ -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_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"),
         ("control_drift", _test_ohme_control_reapplies_on_drift, "control re-applies after app changes"),
@@ -1757,6 +1758,28 @@ def _test_ohme_control_window_year_rollover(my_predbat=None):
     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 ****")
+
+    tz = pytz.timezone("Europe/London")
+    # A long/flat-rate window starting just after midnight yesterday and still running: at 23:05
+    # the next day its start is nearly 47 hours old, well past the 23 hour rollover heuristic, but
+    # its end is still ahead of now, so it must be read as genuinely active rather than shifted a
+    # year forward and dropped out of should_charge_now().
+    now = tz.localize(datetime.datetime(2026, 6, 15, 23, 5, 0))
+    window = {"start": "06-14 00:10:00", "end": "06-16 02:00:00", "kwh": 40.0}
+    api = _ohme_control_api(windows=[window], now=now)
+
+    api.refresh_car_windows()
+    start, end = api.control_windows[0]
+    assert start.year == now.year, f"Expected the still-active window's start left in the current year, got {start}"
+    assert api.should_charge_now() is True, "Expected to still be charging inside a long active window over 23 hours after its start"
+
+    print("PASS: long active window left unshifted")
+    return 0
+
+
 def _test_ohme_control_waits_for_plan(my_predbat=None):
     """Test control sends nothing until a plan has actually been published"""
     print("**** Running test_ohme_control_waits_for_plan ****")