@@ -34,6 +34,8 @@
     "demand_falling": "Demand — the battery is expected to discharge to cover house load; no charging or exporting is scheduled this slot.",
     "demand_steady": "Demand — battery level is expected to stay steady; no charging or exporting is scheduled this slot.",
     "hold_for_car": "Hold for car — the battery is prevented from discharging while the car charges; house load beyond what solar covers comes from the grid instead.",
+    # First half of a split slot held for a car - worded like the demand_before_export_* codes below
+    "hold_for_car_before_export": "Until {split_time}, the battery is prevented from discharging while the car charges.",
     # Used for the first half of a split slot where the export window only starts partway through -
     # deliberately worded without the "nothing is scheduled this slot" clause of the plain demand
     # reasons above, which would contradict the export reason sitting alongside it in the same slot.
@@ -1103,9 +1105,13 @@ def get_charge_rate_kw(self, charge_window_n, minute_start, minute_relative_star
         )
         return dp2(charge_rate_now_curve * MINUTE_WATT / 1000.0)
 
-    def publish_html_plan(self, pv_forecast_minute_step, pv_forecast_minute_step10, load_minutes_step, load_minutes_step10, end_record, publish=True, prediction=None):
+    def publish_html_plan(self, pv_forecast_minute_step, pv_forecast_minute_step10, load_minutes_step, load_minutes_step10, end_record, publish=True, prediction=None, car_hold_minutes=None):
         """
         Publish the current plan in HTML format
+
+        car_hold_minutes, when given, is the set of plan minutes whose recorded status was "Hold for car":
+        the Yesterday actual-history table shows measured SoC, so its car icon comes from what happened
+        rather than from the model (see plan_row_holding_for_car()).
         """
         html = ""
         plan_debug = self.plan_debug
@@ -1321,14 +1327,9 @@ def import_rate_color(rate):
             else:
                 soc_sym = "&searr;"
 
-            # Mirrors the discharge hold execute.py applies for a live "Hold for car" status and
-            # prediction.py enforces during the plan itself (car charging slot active, car not
-            # allowed to draw from the battery, charge windows in use) - so the plan explains the
-            # same held SoC that a non-read-only user would see labelled "Hold for car" live.
-            # car_charging_hold_active() also gates on car capacity the same way execute.py and
-            # prediction.py do, so a car that's already full does not show the hold reason for a
-            # slot it no longer actually holds the battery for (Copilot review on #5147).
-            holding_for_car = self.set_charge_window and (not self.car_charging_from_battery) and self.car_charging_hold_active(minute_start, minute_end)
+            # The discharge hold for a charging car, so the row explains a held SoC with the same "Hold for
+            # car" execute.py shows live (#5147 review)
+            holding_for_car = self.plan_row_holding_for_car(minute_start, minute_end, prediction, car_hold_minutes)
 
             state = "&#128663;" if holding_for_car else soc_sym
             state_color = "#FFFFFF"
@@ -1462,13 +1463,13 @@ def import_rate_color(rate):
                         # #5147). Same "car icon replaces the trend arrow/reason" convention as the
                         # whole-row case above, so this takes priority over the trend below rather
                         # than being shown alongside it.
-                        holding_for_car_segment = self.set_charge_window and (not self.car_charging_from_battery) and self.car_charging_hold_active(minute_start, start)
+                        holding_for_car_segment = self.plan_row_holding_for_car(minute_start, start, prediction, car_hold_minutes)
 
                         soc_change_this = self.predict_soc_best.get(max(start - self.minutes_now, 0), 0.0) - self.predict_soc_best.get(minute_relative_start, 0.0)
                         split_time_str = (self.midnight_utc + timedelta(minutes=start)).strftime("%H:%M")
                         if holding_for_car_segment:
                             state = "&#128663;"
-                            reason_parts.append({"code": "hold_for_car", "params": {}})
+                            reason_parts.append({"code": "hold_for_car_before_export", "params": {"split_time": split_time_str}})
                         # Same near-flat tolerance as the whole-slot demand arrow above - testing
                         # soc_change_this >= 0 first would make the steady case unreachable and
                         # render a flat pre-window period as rising
@@ -3165,6 +3166,18 @@ def yesterday_reconstruct_car_slots(self, end_record, yesterday_load_step, minut
                         load_value = yesterday_load_step.get(minute, 0)
                         yesterday_load_step[minute] = max(load_value - subtract_amount, 0)
 
+    def plan_row_holding_for_car(self, minute_start, minute_end, prediction=None, car_hold_minutes=None):
+        """
+        Whether a plan row (or a split row's pre-export segment) shows the battery held for a charging car.
+
+        With car_hold_minutes (the Yesterday actual-history table, whose SoC is measured) it is whether any
+        minute's recorded status was "Hold for car". Otherwise it is the hold the model assumes: charge
+        windows in use, the car not allowed to draw from the battery, and car_charging_hold_active().
+        """
+        if car_hold_minutes is not None:
+            return any(minute in car_hold_minutes for minute in range(minute_start, minute_end))
+        return bool(self.set_charge_window and (not self.car_charging_from_battery) and self.car_charging_hold_active(minute_start, minute_end, prediction))
+
     def calculate_yesterday(self):
         """
         Calculate the base plan for yesterday
@@ -3430,13 +3443,17 @@ def calculate_yesterday(self):
         self.predict_metric_best = cost_yesterday_array
 
         # Fake charge/export windows based on previous predbat status
+        car_hold_minutes = set()
         if predbat_status_data:
             predbat_status = minute_data_state(predbat_status_data[0], 2, self.now_utc, "state", "last_updated")
             for minute in predbat_status:
                 status = predbat_status[minute]
                 if "," in status:
                     # If there are multiple statuses take the first one
                     predbat_status[minute] = status.split(",")[0].strip()
+            # 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.
+            car_hold_minutes = {minutes_now + end_record - minutes_ago for minutes_ago, status in predbat_status.items() if status.lower() == "hold for car"}
             # Ignore the first and last edge_minutes of each slot when they don't hold one state
             # throughout - Predbat's reported status can lag a slot boundary by a minute or two while
             # it catches up to a replan, and that leftover from the previous (or next) slot must not
@@ -3542,7 +3559,9 @@ def calculate_yesterday(self):
 
         # Simulate yesterday with actual charge/export windows
         self.forecast_minutes = end_record + minutes_now
-        plan_html_yesterday, plan_json_yesterday = self.publish_html_plan(yesterday_pv_step, yesterday_pv_step, yesterday_load_step, yesterday_load_step, end_record + minutes_now, publish=False, prediction=self.prediction)
+        plan_html_yesterday, plan_json_yesterday = self.publish_html_plan(
+            yesterday_pv_step, yesterday_pv_step, yesterday_load_step, yesterday_load_step, end_record + minutes_now, publish=False, prediction=self.prediction, car_hold_minutes=car_hold_minutes
+        )
         self.forecast_minutes = end_record
 
         # Restore state
 
@@ -5781,34 +5781,41 @@ def plan_car_charging(self, car_n, low_rates):
         plan = self.sort_window_by_time(plan)
         return plan
 
-    def car_charging_hold_active(self, minute_start, minute_end):
-        """
-        True if a car with a planned charging slot covering this window still wants the battery
-        held - i.e. matches execute.py's real "Hold for car" gate (lines 596-601), not just "is
-        there a positive-kwh planned slot here".
-
-        execute.py only holds while car_charging_soc[car_n] < car_charging_limit[car_n]: once a
-        car has reached its target, execute.py stops holding for it even though its planned slot
-        may still show positive kwh (that kwh is the amount originally planned, not adjusted once
-        the car finishes early). prediction.py's own simulation does the same thing internally -
-        car_load_scale is clamped to car_charging_limit[car_n] - car_soc[car_n], floored at 0 -
-        so a full car draws no simulated load and the battery is not actually held for it either.
-        Mirroring only the "positive planned kwh" half of that here would show the hold_for_car
-        icon/reason for a slot where neither execute.py nor the plan simulation is actually
-        holding (Copilot review on #5147).
-
-        Like execute.py, this checks car_charging_soc/car_charging_limit once per car (the current
-        live values at plan-render time), not a per-minute simulated SoC - car_charge_slot_kwh()'s
-        per-minute window overlap is enough to know a car is relevant to this window; whether that
-        car is already full is a single live fact, not something that changes minute to minute
-        within one render.
+    def car_charging_hold_active(self, minute_start, minute_end, prediction=None):
+        """
+        True if the plan holds the battery for a car during this window: a car that is not yet full
+        has a slot with energy overlapping it.
+
+        Follows the model the plan row was drawn from, so the car icon matches the held SoC that model
+        predicts. With a prediction (e.g. Yesterday's baseline) that is its own car slots, limit and SoC.
+        Without one it is what the live plan's prediction is given: car_charging_slots_model(), which adds a car
+        reporting car_charging_now outside its plan (#5245), and car_charging_limit_model where set,
+        which uncaps a car charging now (#5245) and, with octopus_intelligent_consider_full off, a car
+        with Octopus Intelligent slots (#4967).
+
+        That matches execute.py's hold for a car charging now, which ignores the modelled car SoC. For
+        a slot-only hold execute.py still stops once car_charging_soc reaches car_charging_limit, so on
+        the #4967 uncapped path the plan can show a hold that execute.py skips for a car it believes
+        full - the plan's flat SoC assumes the hold, and the icon explains that SoC (#5147 review).
+
+        The full check uses the SoC once per car at render time, while prediction.py clamps per minute, so
+        a car the model fills part-way through the plan keeps its icon on later slots that still carry kWh.
+        Rare in practice: planned slots are sized to the car's limit.
         """
         if self.num_cars == 0:
             return False
+        if prediction is not None:
+            car_slots = prediction.car_charging_slots
+            car_limit = prediction.car_charging_limit
+            car_soc = prediction.car_charging_soc
+        else:
+            car_slots = self.car_charging_slots_model()
+            car_limit = self.car_charging_limit_model if self.car_charging_limit_model is not None else self.car_charging_limit
+            car_soc = self.car_charging_soc
         for car_n in range(self.num_cars):
-            if self.car_charging_soc[car_n] >= self.car_charging_limit[car_n]:
+            if car_soc[car_n] >= car_limit[car_n]:
                 continue
-            for window in self.car_charging_slots[car_n]:
+            for window in car_slots[car_n]:
                 if window["start"] < minute_end and window["end"] > minute_start and window.get("kwh", 0) > 0:
                     return True
         return False
 
@@ -1524,6 +1524,64 @@ def _capture_publish_html_plan(*args, **kwargs):
     return failed
 
 
+def _test_recorded_hold_for_car_minutes(my_predbat, failed):
+    """The actual-history table's car icon comes from the recorded "Hold for car" status (#5147 review).
+
+    That table shows measured SoC, so the car icon must follow what happened rather than the model.
+    calculate_yesterday() passes publish_html_plan() the plan minutes whose status was "Hold for car",
+    mapped from minutes-ago the same way as the charge/export reconstruction: plan-minute m is
+    (1800 - m) minutes ago here. Holds for plan-minutes 1205-1209, deliberately off-centre in its slot.
+    """
+    print("calculate_yesterday: Test - recorded Hold for car minutes are passed to the actual-history table (#5147)")
+    now_utc = _setup_base(my_predbat)
+    prefix = my_predbat.prefix
+
+    start = now_utc - timedelta(minutes=1800)
+    status_points = []
+    for step in range(0, 1800, 5):
+        stamp = start + timedelta(minutes=step)
+        status_points.append({"state": "Hold for car" if 1205 <= step < 1210 else "Demand", "last_updated": stamp.strftime("%Y-%m-%dT%H:%M:%S+00:00"), "attributes": {"p/kWh": "0.0"}})
+    status_hist = [status_points]
+
+    def _history_with_one_hold(entity_id, days=30, required=True, tracked=True):
+        """Return the recorded history calculate_yesterday() asks for, with one short Hold for car."""
+        if entity_id == prefix + ".cost_today":
+            return _make_constant_history(100.0, now_utc)
+        elif entity_id == prefix + ".soc_kw_h0":
+            return _make_constant_history(5.0, now_utc)
+        elif entity_id == prefix + ".status":
+            return status_hist
+        return None
+
+    captured = {}
+
+    def _capture_publish_html_plan(*args, **kwargs):
+        """Record the car_hold_minutes the actual-history table is rendered with."""
+        captured["car_hold_minutes"] = kwargs.get("car_hold_minutes")
+        return ("", "{}")
+
+    my_predbat.step_data_history = _make_mock_step_data(my_predbat.pv_today)
+    my_predbat.get_history_wrapper = _history_with_one_hold
+    my_predbat.plan_write_debug = lambda *a, **kw: ("", "{}")
+    my_predbat.publish_html_plan = _capture_publish_html_plan
+    original_run_pred = my_predbat.run_prediction
+    my_predbat.run_prediction = lambda *a, **kw: _make_mock_run_prediction([])(my_predbat, *a, **kw)
+
+    my_predbat.calculate_yesterday()
+
+    hold = captured.get("car_hold_minutes")
+    if hold is None:
+        print("ERROR: the actual-history table was rendered without car_hold_minutes")
+        failed = True
+    elif hold != set(range(1205, 1210)):
+        print("ERROR: recorded Hold for car at plan-minutes 1205-1209 mapped to {}".format(sorted(hold)[:10]))
+        failed = True
+
+    _restore_methods(my_predbat, original_run_pred)
+    my_predbat.savings_last_updated = None
+    return failed
+
+
 def _test_more_active_slot_status(my_predbat, failed):
     """Unit tests for the slot-status collapse rule (#4843).
 
@@ -2194,6 +2252,7 @@ def test_calculate_yesterday(my_predbat):
     failed = _test_yesterday_slot_is_exporting(my_predbat, failed)
     failed = _test_cross_charging_reconstructed_as_both_windows(my_predbat, failed)
     failed = _test_slot_status_read_at_the_right_minute(my_predbat, failed)
+    failed = _test_recorded_hold_for_car_minutes(my_predbat, failed)
     failed = _test_mixed_slot_keeps_most_active_state(my_predbat, failed)
     failed = _test_more_active_slot_status(my_predbat, failed)
     failed = _test_short_export_inside_a_freeze_slot(my_predbat, failed)