fix(output): narrow #4445 to the Chrg/HoldChrg decision, keep displaying the predicted SoC

Decide Chrg vs HoldChrg from the real charge_limit_best, but keep the
Limit cell, the reason text and state_target on the window's predicted
end-of-window SoC, which is what docs/predbat-plan-card.md says the
Limit column shows and what #4445's agreed fix direction asked for.

Showing the instruction instead made every window that clip_charge_slots
raises to a full charge read 100% while the plan only expects it to
reach a lower SoC. This restores get_charge_export_text and the
plan_debug bracket order (predicted, then limit) to their main
behaviour, and reworks the tests: the SoC-between-target-and-limit case
fails on main with HoldChrg, a real hold still shows HoldChrg, and the
plan_debug cell and text summary show the predicted SoC.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: chalfontchubby

apps/predbat/output.py

@@ -852,20 +852,11 @@ def get_charge_export_text(self, minutes_now, charge_window_n, export_window_n):
             else:
                 text = "force exporting to {}% for the next {}".format(target_export, self.duration_string(self.export_window_best[export_window_n]["end"] - minutes_now))
         elif charge_window_n >= 0:
-            limit = self.charge_limit_best[charge_window_n]
-            target_charge = calc_percent_limit(limit, self.soc_max)
-            predicted = self.charge_window_best[charge_window_n].get("target", limit)
-            predicted_percent = calc_percent_limit(predicted, self.soc_max)
-            # Report the real instruction sent to the inverter (charge_limit_best), not the window's
-            # predicted-achievable SoC (plan.py's "target"), which would show a full-rate charge as a
-            # lower, partial one (issue #4445). Where the window can't reach the limit in time, the
-            # achievable SoC is still shown alongside it, so that information (the point of PR #2358)
-            # isn't confined to plan_debug.
-            target_suffix = "" if predicted_percent == target_charge else " (predicted {}%)".format(predicted_percent)
-            if limit == self.reserve:
-                text = "freeze charging to {}%{} for the next {}".format(target_charge, target_suffix, self.duration_string(self.charge_window_best[charge_window_n]["end"] - minutes_now))
+            target_charge = calc_percent_limit(self.charge_window_best[charge_window_n].get("target", self.charge_limit_best[charge_window_n]), self.soc_max)
+            if self.charge_limit_best[charge_window_n] == self.reserve:
+                text = "freeze charging to {}% for the next {}".format(target_charge, self.duration_string(self.charge_window_best[charge_window_n]["end"] - minutes_now))
             else:
-                text = "charging to {}%{} for the next {}".format(target_charge, target_suffix, self.duration_string(self.charge_window_best[charge_window_n]["end"] - minutes_now))
+                text = "charging to {}% for the next {}".format(target_charge, self.duration_string(self.charge_window_best[charge_window_n]["end"] - minutes_now))
         else:
             charge_window_n = self.get_next_charge_window(minutes_now)
             export_window_n = self.get_next_export_window(minutes_now)
@@ -1432,15 +1423,20 @@ def import_rate_color(rate):
                 if "target" in self.charge_window_best[charge_window_n]:
                     target = self.charge_window_best[charge_window_n]["target"]
 
-                limit_percent = calc_percent_limit(limit, self.soc_max)
+                # Classify Chrg vs HoldChrg against the real instruction (charge_limit_best), but display the
+                # window's predicted end-of-window SoC ("target", from plan.py), which is what the Limit column
+                # documents. Classifying against the prediction showed a full-rate charge that can't finish
+                # within the window as HoldChrg whenever the row's SoC sat above that prediction (issue #4445).
+                instruction_percent = calc_percent_limit(limit, self.soc_max)
+                limit_percent = calc_percent_limit(target, self.soc_max)
                 if limit > 0.0:
                     if self.is_freeze_charge(limit):
                         state = "FrzChrg→"
                         state_color = "#EEEEEE"
                         raw_state = "FrzChrg"
                         limit_percent = soc_percent
                         reason_parts.append({"code": "freeze_charge", "params": {"rate": rate_text_import, "threshold": "{:.2f}".format(import_cost_threshold)}})
-                    elif limit_percent <= soc_percent_min_window:
+                    elif instruction_percent <= soc_percent_min_window:
                         state = "HoldChrg&rarr;"
                         state_color = "#34DBEB"
                         raw_state = "HoldChrg"
@@ -1463,7 +1459,7 @@ def import_rate_color(rate):
                     show_limit = str(limit_percent)
                     had_state = True
                     if plan_debug:
-                        show_limit += " ({})".format(str(calc_percent_limit(target, self.soc_max)))
+                        show_limit += " ({})".format(str(calc_percent_limit(limit, self.soc_max)))
                     raw_state_target = str(limit_percent)
             else:
                 if export_window_n >= 0:

apps/predbat/tests/test_plan_why_reason.py

@@ -416,65 +416,59 @@ def render(car_hold_minutes=None):
         print("ERROR: HoldChrg rendered text unexpected: {}".format(_render(row, templates)))
         failed = True
 
-    # --- Test 2b: a genuine full-rate charge must not misclassify as HoldChrg just because the
-    # window's "target" (plan.py's predicted end-of-window SoC) sits below the real charge_limit_best -
-    # this is the #4445 regression: a charge that can't complete within one window previously showed
-    # HoldChrg -> target% instead of Chrg -> limit% ---
-    print("Test Chrg reason is not hidden by a target below the real limit (#4445)")
+    # --- Test 2b: #4445 - a full-rate charge that can't finish within the window carries a "target"
+    # (plan.py's predicted end-of-window SoC) below the real charge_limit_best. Chrg vs HoldChrg must be
+    # decided from the real limit, while the Limit cell, reason and state_target keep showing the
+    # predicted SoC, as docs/predbat-plan-card.md describes the Limit column ---
+    print("Test Chrg vs HoldChrg is decided by the real limit, with the predicted SoC displayed (#4445)")
     my_predbat.charge_window_best[0]["target"] = 6.0  # predicted to only reach 60% (6kWh of 10kWh soc_max) by window end
-    my_predbat.predict_soc_best = _flat_soc(my_predbat, 2.0)  # 20%, well below the 80% limit
-    _, raw_plan = render()
-    row = _get_row(raw_plan, minutes_now)
-    if row is None or _codes(row) != ["charge_low_rate"]:
-        print("ERROR: #4445 Chrg reasons unexpected: {}".format(row and _codes(row)))
-        failed = True
-    elif row["reasons"][0]["params"].get("target_percent") != 80:
-        print("ERROR: #4445 Chrg should classify against the real limit (80), not target: {}".format(row["reasons"][0]["params"]))
-        failed = True
-    elif "Charging up to 80" not in _render(row, templates):
-        print("ERROR: #4445 Chrg rendered text unexpected: {}".format(_render(row, templates)))
-        failed = True
 
-    # The reported #4445 symptom itself: with the SoC already above the predicted target but still
-    # below the real limit, classifying against the target showed HoldChrg -> 60% for a window that is
-    # really charging towards 80%
+    # The reported symptom: the SoC is already above the predicted 60% but below the real 80% limit, so
+    # classifying against the prediction showed HoldChrg for a window that is really charging
     my_predbat.predict_soc_best = _flat_soc(my_predbat, 7.0)  # 70%, between the 60% target and the 80% limit
     _, raw_plan = render()
     row = _get_row(raw_plan, minutes_now)
     if row is None or _codes(row) != ["charge_low_rate"]:
         print("ERROR: #4445 SoC between target and limit should show Chrg, not HoldChrg: {}".format(row and _codes(row)))
         failed = True
-    elif row["reasons"][0]["params"].get("target_percent") != 80:
-        print("ERROR: #4445 SoC between target and limit should report the real limit (80): {}".format(row["reasons"][0]["params"]))
+    elif row["reasons"][0]["params"].get("target_percent") != 60:
+        print("ERROR: #4445 Chrg reason should show the predicted SoC (60): {}".format(row["reasons"][0]["params"]))
         failed = True
-    elif row["state"] != "Chrg" or row["state_target"] != "80":
+    elif row["state"] != "Chrg" or row["state_target"] != "60":
         print("ERROR: #4445 SoC between target and limit state unexpected: {} -> {}".format(row["state"], row["state_target"]))
         failed = True
+    elif "Charging up to 60" not in _render(row, templates):
+        print("ERROR: #4445 Chrg rendered text unexpected: {}".format(_render(row, templates)))
+        failed = True
 
-    # With plan_debug on, the Limit cell shows the real limit with the predicted end-of-window SoC in brackets
+    # With plan_debug on, the Limit cell shows the predicted SoC with the real limit in brackets
     plan_debug_saved = my_predbat.plan_debug
     my_predbat.plan_debug = True
     html, _ = render()
     my_predbat.plan_debug = plan_debug_saved
-    if "80 (60)" not in html:
-        print("ERROR: #4445 plan_debug Limit cell should read '80 (60)' (limit, then predicted SoC)")
+    if "60 (80)" not in html:
+        print("ERROR: #4445 plan_debug Limit cell should read '60 (80)' (predicted SoC, then limit)")
         failed = True
-    del my_predbat.charge_window_best[0]["target"]
 
-    # --- Test 2c: get_charge_export_text has the same #4445 fix, and keeps surfacing the
-    # predicted-achievable SoC (PR #2358's original point) alongside the real limit when they diverge ---
-    print("Test get_charge_export_text shows the real limit, with the predicted SoC noted when it diverges")
-    text = my_predbat.get_charge_export_text(minutes_now, 0, -1)
-    if "charging to 80%" not in text or "predicted" in text:
-        print("ERROR: get_charge_export_text with no target divergence unexpected: {}".format(text))
+    # A real hold still classifies as HoldChrg: the SoC is at or above the real limit
+    my_predbat.predict_soc_best = _flat_soc(my_predbat, 9.0)  # 90%, above the 80% limit
+    _, raw_plan = render()
+    row = _get_row(raw_plan, minutes_now)
+    if row is None or _codes(row) != ["hold_charge_at_target"]:
+        print("ERROR: #4445 SoC above the real limit should still show HoldChrg: {}".format(row and _codes(row)))
         failed = True
 
-    my_predbat.charge_window_best[0]["target"] = 6.0  # predicted to only reach 60% (6kWh of 10kWh soc_max) by window end
+    # --- Test 2c: get_charge_export_text reports the predicted SoC too, falling back to the limit ---
+    print("Test get_charge_export_text shows the predicted SoC, or the limit when there is no prediction")
     text = my_predbat.get_charge_export_text(minutes_now, 0, -1)
-    if "charging to 80%" not in text or "predicted 60%" not in text:
-        print("ERROR: get_charge_export_text with a diverging target unexpected: {}".format(text))
+    if "charging to 60%" not in text:
+        print("ERROR: get_charge_export_text with a predicted target unexpected: {}".format(text))
         failed = True
     del my_predbat.charge_window_best[0]["target"]
+    text = my_predbat.get_charge_export_text(minutes_now, 0, -1)
+    if "charging to 80%" not in text:
+        print("ERROR: get_charge_export_text with no predicted target unexpected: {}".format(text))
+        failed = True
 
     # --- Test 3: FrzChrg ---
     print("Test FrzChrg reason")