@@ -1330,7 +1330,6 @@ def fetch_sensor_data(self, save=True):
         if self.import_today:
             self.cost_today_sofar, self.carbon_today_sofar = self.today_cost(self.import_today, self.export_today, self.car_charging_energy, self.load_minutes, save=save)
 
-
         if self.load_minutes and not self.load_forecast_only and not self.load_forecast_history:
             # Apply modal filter to historical data. Skipped for days_previous_auto: the weighted-bucket
             # forecast deliberately ignores missing-data buckets, so the gap-filling/padding the modal filter
 
@@ -5475,6 +5475,44 @@ def car_solar_surplus_kwh(self, start, end, load_step, rate_kw=None):
             total += surplus * overlap / step
         return total
 
+    def car_solar_reserved_for_car(self, load_step, car_n=0):
+        """
+        Surplus the car needs from the slots it will actually be present for, in kWh
+
+        The battery-priority hold assumes the car can catch up later, which is only true while the car
+        is going to be there. Mark the afternoon away and the morning becomes the car's last chance,
+        so banking it for a battery that has the whole day to fill is the wrong way round - and at a
+        100% priority level the car would never see a solar window at all.
+
+        Returns what the car still needs, capped by what the present slots can actually deliver, so
+        the hold gives up exactly that much and no more. Zero when no away time is set, which leaves
+        the everyday behaviour untouched.
+
+        Args:
+        - load_step: house load forecast, as used for the surplus calculation
+        - car_n: which car
+
+        Returns:
+        - float: kWh to keep back for the car, 0.0 when there is nothing to reserve
+        """
+        if not self.manual_car_away_times or car_n >= self.num_cars:
+            return 0.0
+        needed = self.car_charging_limit[car_n] - self.car_charging_soc[car_n]
+        if needed <= 0:
+            return 0.0
+        available = 0.0
+        rate_limit = self.car_charging_rate[car_n] * self.plan_interval_minutes / 60.0
+        start_minute = int(self.minutes_now / self.plan_interval_minutes) * self.plan_interval_minutes
+        for minute in range(start_minute, self.minutes_now + self.forecast_minutes, self.plan_interval_minutes):
+            slot_start = max(minute, self.minutes_now)
+            slot_end = minute + self.plan_interval_minutes
+            if slot_end <= slot_start or self.car_slot_is_away(slot_start, slot_end):
+                continue
+            available += min(self.car_solar_surplus_kwh(slot_start, slot_end, load_step), rate_limit)
+            if available >= needed:
+                return needed
+        return min(needed, available)
+
     def plan_car_charging_solar_windows(self, load_step=None):
         """
         Find the slots where forecast solar is worth diverting to the car
@@ -5515,6 +5553,11 @@ def plan_car_charging_solar_windows(self, load_step=None):
         # the pack as the held surplus fills it. Walking it forward means "full enough" is judged at the
         # time of each slot rather than from the SoC right now, so a pack that gets there mid-morning
         # releases the car mid-morning rather than holding all day.
+        # Surplus the car can only get from the slots it will be present for. The hold below gives up
+        # exactly this much, so away time moves the car's charge earlier instead of removing it: the
+        # battery still has the rest of the day, the car does not.
+        reserved_for_car = self.car_solar_reserved_for_car(load_step)
+        given_to_car = 0.0
         battery_priority_kwh = self.soc_max * min(max(self.car_charging_solar_battery_soc, 0), 100) / 100.0
         battery_estimate = self.soc_kw
         start_minute = int(self.minutes_now / self.plan_interval_minutes) * self.plan_interval_minutes
@@ -5534,7 +5577,7 @@ def plan_car_charging_solar_windows(self, load_step=None):
             # The battery gets the surplus until it is predicted to reach the configured level. What it
             # cannot physically take in the slot is not held back - that would strand surplus that the
             # car could have used and the grid will otherwise buy at the midday rate.
-            if battery_estimate < battery_priority_kwh:
+            if battery_estimate < battery_priority_kwh and given_to_car >= reserved_for_car:
                 to_battery = min(
                     surplus_kwh,
                     battery_priority_kwh - battery_estimate,
@@ -5553,6 +5596,8 @@ def plan_car_charging_solar_windows(self, load_step=None):
                 continue
             # Price the slot at the export rate: solar sent to the car is not bought, it is export
             # given up, so that is its real cost and what the plan should show
+            # Count what this window hands over, so the hold resumes once the car's reserved share is met
+            given_to_car += min(surplus_kwh, self.car_charging_rate[0] * (slot_end - slot_start) / 60.0) if self.num_cars else 0.0
             windows.append({"start": minute, "end": slot_end, "average": export_rate, "solar": True, "power_kw": dp2(power_kw)})
 
         if slot_count:
 
@@ -20,8 +20,8 @@
 makes that testable: it drives the load forecast directly instead of through the fixture's history.
 """
 
-from const import PREDICT_STEP
-from utils import dp2
+from const import PREDICT_STEP, EXPORT_MODE_TARGET
+from utils import dp2, export_mode_of
 from tests.test_infra import reset_inverter, reset_rates, update_rates_import, update_rates_export
 from prediction import Prediction
 
@@ -461,6 +461,64 @@ def test_solar_battery_priority_level(my_predbat):
     return failed
 
 
+def test_away_moves_solar_earlier(my_predbat):
+    """Away time makes the battery-priority hold yield, so the car charges while it is still here.
+
+    The hold assumes the car can catch up later, which stops being true the moment the afternoon is
+    marked away - and at a 100% priority level the car would otherwise never see a solar window at
+    all. Reported from a live system: marking the afternoon away made the car charge from the grid
+    at 30p instead of moving to the morning sun.
+    """
+    print("  - test_away_moves_solar_earlier")
+    failed = False
+    setup_car(my_predbat, car_kwh=30.0, ready_ahead=1200, rate=7.0, house_kw=1.0)
+    reset_rates(my_predbat, 30.0, 5.0)
+    my_predbat.car_charging_solar = True
+    my_predbat.soc_max = 27.0
+    my_predbat.soc_kw = 0.0
+    my_predbat.battery_rate_max_charge = 10.0 / 60.0
+    my_predbat.battery_rate_max_scaling = 1.0
+    my_predbat.car_charging_solar_battery_soc = 100
+    set_pv(my_predbat, 8.0, start_offset=120, length=480)
+    low_rates = [{"start": my_predbat.minutes_now + 30 * n, "end": my_predbat.minutes_now + 30 * (n + 1), "average": 30.0} for n in range(40)]
+    update_rates_import(my_predbat, low_rates)
+
+    my_predbat.manual_car_away_times = []
+    baseline = [slot for slot in my_predbat.plan_car_charging(0, low_rates) if slot.get("solar")]
+    if not baseline:
+        print("ERROR: expected some solar charging with no away markers")
+        return True
+    baseline_first = baseline[0]["start"] - my_predbat.minutes_now
+
+    # Mark the afternoon away - the car's remaining chances are all in the morning
+    my_predbat.manual_car_away_times = [my_predbat.minutes_now + m for m in range(300, 600, 30)]
+    plan = my_predbat.plan_car_charging(0, low_rates)
+    solar = [slot for slot in plan if slot.get("solar")]
+
+    if not solar:
+        print("ERROR: away time removed solar charging entirely instead of moving it earlier")
+        failed = True
+    else:
+        moved_to = solar[0]["start"] - my_predbat.minutes_now
+        if moved_to >= baseline_first:
+            print("ERROR: solar should start earlier than {} once the afternoon is away, got {}".format(baseline_first, moved_to))
+            failed = True
+
+    for slot in plan:
+        if my_predbat.car_slot_is_away(slot["start"], slot["end"]):
+            print("ERROR: planned a slot the car is away for: {}-{}".format(slot["start"], slot["end"]))
+            failed = True
+
+    # With no away time set the hold is untouched, which is the everyday case
+    my_predbat.manual_car_away_times = []
+    if my_predbat.car_solar_reserved_for_car(my_predbat.car_solar_load_forecast()) != 0.0:
+        print("ERROR: nothing should be reserved for the car when no away time is set")
+        failed = True
+
+    my_predbat.car_charging_solar_battery_soc = 0
+    return failed
+
+
 def test_solar_windows_ignore_ready_time(my_predbat):
     """Solar windows run to the forecast horizon, so a morning ready time does not exclude daylight."""
     print("  - test_solar_windows_ignore_ready_time")
@@ -531,7 +589,9 @@ def run_car_export_tradeoff(my_predbat, export_rate, from_battery, car_kwh=8.0):
     my_predbat.optimise_all_windows(result[0], result[8])
 
     final = my_predbat.run_prediction(my_predbat.charge_limit_best, my_predbat.charge_window_best, my_predbat.export_window_best, my_predbat.export_limits_best, False, end_record=end_record, save="best")
-    exported = bool(my_predbat.export_limits_best) and my_predbat.export_limits_best[0] < 100
+    # Export limits are a packed structure since #5047, so ask the accessor rather than comparing the
+    # raw value - a tuple is not less than 100, and reading it as one silently reports "did not export"
+    exported = bool(my_predbat.export_limits_best) and export_mode_of(my_predbat.export_limits_best[0]) == EXPORT_MODE_TARGET
     return exported, final[1] + final[2]
 
 
@@ -600,6 +660,7 @@ def run_car_solar_tests(my_predbat):
         "car_charging_now",
         "car_charging_solar",
         "car_charging_solar_excess",
+        "manual_car_away_times",
         "car_charging_solar_battery_soc",
         "battery_rate_max_charge",
         "battery_rate_max_scaling",
@@ -622,6 +683,7 @@ def run_car_solar_tests(my_predbat):
         failed |= test_solar_slot_size_follows_surplus(my_predbat)
         failed |= test_solar_slot_capped_by_charger(my_predbat)
         failed |= test_solar_battery_priority_level(my_predbat)
+        failed |= test_away_moves_solar_earlier(my_predbat)
         if failed:
             return failed
         failed |= test_car_export_tradeoff(my_predbat)