fix(execute): resolve multi-inverter status from all inverters, not just the last one processed (#4466)

* fix(execute): resolve multi-inverter status from all inverters, not just the last one processed

execute_plan()'s headline status was a single variable overwritten once per
inverter in the loop, so the dashboard silently showed whichever inverter
happened to be processed last - hiding real disagreement between inverters,
including genuine cross-charging (one inverter charging while another
discharges at the same time), which gcoan confirmed is a real, known
phenomenon on multi-inverter Sigenergy/GivEnergy-style systems.

Track each inverter's own final core state in status_per_inverter (keyed by
id, so an inverter passing through multiple assignments in its own
processing still just keeps its own last value). After the loop, resolve
one headline via resolve_multi_inverter_status(): if inverters disagree
across the charge/export divide, surface it as "Cross-charging" rather than
picking one side arbitrarily; if they only disagree on sub-state within the
same side (e.g. one still Charging, another already Hold charging), show
the most active one, since that's what the fleet is actually still doing
overall.

Extracted as a small pure function for direct unit testing rather than
needing to drive execute_plan()'s full branching to construct genuine
multi-inverter disagreement scenarios.

Three existing execute.py tests (charge_imbalance2, charge_freeze_imb1,
charge_freeze_imb4) asserted the old "last inverter wins" artifact as if it
were correct (e.g. "Hold charging" when one inverter was actually still
charging toward target) - updated to assert the corrected, more informative
aggregate instead.

Fixes #4446

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(execute): include each inverter's own state in the status tooltip

Follow-on to the #4446 headline fix. The status_extra text (the "detail"
attribute on predbat.status, shown as the tooltip/more-info text) already
concatenated each inverter's SoC->target numerically for multi-inverter
setups ("target 80%-40% / 60%-40%") but didn't say which state each entry
belonged to. Prefix each entry with that inverter's own state
("target Charging 80%-40% / Hold charging 60%-40%") - reuses the existing
append pattern and status_per_inverter/status values already computed for
the #4446 fix, no new machinery. Single-inverter setups are unaffected.

Added assert_status_extra to the shared execute test harness and locked in
real values for charge_imbalance2 and charge_freeze_imb1, which already
exercise genuine multi-inverter disagreement.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs: document the new Cross-charging status

gcoan asked on #4466 for the new multi-inverter Cross-charging status
(introduced by resolve_multi_inverter_status()) to be documented alongside
the other predbat.status values.

* fix(execute): don't let a Charging/Exporting fleet state suppress the iBoost hold status text

status_hold_iboost was only ever set inside the same guard (status not in
["Exporting", "Charging"]) that gates the actual discharge-pause actions, so
the annotation could never be recorded once any inverter's status reached
Charging/Exporting. Split the guard so it still gates the pause/reserve
actions but the status text update always runs, matching the pattern already
used by the car-holding block just above it.

* fix(execute): keep the iBoost hold status text and Calibration headline correct on multi-inverter fleets

The final commit of this PR decoupled the "Hold for iBoost" status annotation
from the pause action it describes - the annotation became a sibling of the
inner discharge-hold guard instead of nested inside it, so it could now fire
whenever the outer iBoost condition held, regardless of whether a pause
actually happened this cycle. Re-nest it so the annotation stays coupled to
boostHolding actually firing.

Also fixes resolve_multi_inverter_status() so a Calibration break correctly
overrides any stale core state an earlier-processed inverter left in
status_per_inverter, matching what the function's own docstring already
claimed but didn't implement.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(output): recognise Cross-charging as export activity in the yesterday-plan reconstruction

Cross-charging (#4466) contains "charging" but not "exporting" as a string,
so calculate_yesterday()'s slot classification silently dropped the export
half of a genuine cross-charging minute, showing it as plain charging only.
Add yesterday_slot_is_exporting() and use it at both the search and the
window-building call sites.

Also clarifies (no behaviour change) that find_charge_curve()'s exact-match
status checks deliberately exclude Cross-charging minutes from curve
learning - another inverter is drawing/feeding power at the same time, so
the sample isn't a clean single-inverter reading. And tightens the
Cross-charging doc entry, which described it as both inverters "genuinely"
charging/exporting when it also fires for two merely-holding sub-states
(Hold charging + Hold exporting) with no current actually flowing.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* test: cover both #4466 fixes through their real integration paths

Both fixes were previously only covered at the extracted-function level
(resolve_multi_inverter_status / yesterday_slot_is_exporting), which proves
the helper's logic but not that the surrounding code actually reaches it.
Add the two integration cases and verify each genuinely fails when its fix
is reverted:

- execute: "calibration_after_charging_inverter" drives execute_plan() with a
  real two-inverter fleet where inverter 0 reaches Charging before inverter 1
  enters calibration and breaks the loop. Without the fix the headline
  resolves back to the stale "Charging". Needed per-inverter escape hatches
  (in_calibration_array and the immediate-target/isCharging asserts) because
  the break leaves the fleet genuinely half-processed - the test now documents
  that real state rather than papering over it.

- calculate_yesterday: a full "Cross-charging" status history must rebuild both
  charge AND export windows. Captured from inside a publish_html_plan mock,
  since the reconstructed windows only exist between the fake-window block and
  the restore at the end of the function. Without the fix the export side comes
  back empty.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Trefor Southwell <48591903+springfall2008@users.noreply.github.com>
Co-authored-by: Trefor Southwell <tdlj@tdlj.net>

Author: 3 people

apps/predbat/execute.py

@@ -26,6 +26,51 @@
 Execute Predbat plan
 """
 
+# Per-inverter core charge/export states, used to resolve one headline status across a multi-inverter
+# fleet instead of letting whichever inverter is processed last silently win. Precedence lists are
+# ordered most-active-first so the most informative sub-state is shown when inverters within the same
+# side disagree (e.g. one still actively Charging while another has already reached Hold charging).
+CHARGE_STATE_PRECEDENCE = ["Charging", "Freeze charging", "Hold charging"]
+EXPORT_STATE_PRECEDENCE = ["Exporting", "Freeze exporting", "Hold exporting"]
+CHARGE_SIDE_STATES = set(CHARGE_STATE_PRECEDENCE)
+EXPORT_SIDE_STATES = set(EXPORT_STATE_PRECEDENCE)
+
+
+def resolve_multi_inverter_status(status_per_inverter, current_status):
+    """Resolve one headline status across a multi-inverter fleet.
+
+    ``status_per_inverter`` holds each inverter's own final core charge/export state, keyed by
+    inverter id, as recorded during execute_plan()'s per-inverter loop - a plain dict overwrite per
+    inverter, so it correctly reflects each inverter's own last-set state even if that inverter's own
+    processing passed through more than one core-state assignment.
+
+    If inverters disagree across the charge/export divide (one genuinely charging while another
+    discharges at the same time) that's real cross-charging, not noise - surfaced explicitly rather
+    than silently showing whichever inverter happened to be processed last. If they only disagree on
+    sub-state within the same side (e.g. one still actively Charging, another already Hold charging),
+    the most active one is shown - it's the most informative and matches what the fleet is actually
+    doing overall.
+
+    Falls through to ``current_status`` unchanged when no inverter reached a core charge/export state
+    at all (pure Demand, Read-Only, Calibration, or a Hold-for-car/iBoost annotation with nothing else
+    going on) - those cases are already correct and untouched by this resolution. Calibration always
+    wins outright even if ``status_per_inverter`` holds a stale core state from an inverter processed
+    before the one that entered calibration mode, since calibration force-overrides every inverter's
+    controls and that must not be hidden behind a leftover Charging/Exporting label.
+    """
+    if current_status == "Calibration":
+        return current_status
+    states_present = set(status_per_inverter.values())
+    charge_states_present = states_present & CHARGE_SIDE_STATES
+    export_states_present = states_present & EXPORT_SIDE_STATES
+    if charge_states_present and export_states_present:
+        return "Cross-charging"
+    if charge_states_present:
+        return next(candidate for candidate in CHARGE_STATE_PRECEDENCE if candidate in charge_states_present)
+    if export_states_present:
+        return next(candidate for candidate in EXPORT_STATE_PRECEDENCE if candidate in export_states_present)
+    return current_status
+
 
 class Execute:
     """Execution mixin for applying optimised plans to physical inverters.
@@ -40,6 +85,11 @@ def execute_plan(self):
         status_hold_car = ""  # car hold status text
         status_hold_iboost = ""  # iBoost hold status text
         status_freeze_export = ""  # freeze export during demand status text
+        # Each inverter's own final core charge/export state, keyed by inverter id - used after the
+        # loop to detect genuine cross-charging (one inverter charging while another discharges at
+        # the same time) rather than silently showing whichever inverter's status happened to be
+        # set last, which hides that the fleet is fighting itself.
+        status_per_inverter = {}
 
         in_alert = self.alert_active_keep.get(self.minutes_now, 0) > 0
         in_manual_soc = self.manual_soc_keep.get(self.minutes_now, 0) > 0
@@ -198,14 +248,16 @@ def execute_plan(self):
                                 resetDischarge = False
 
                             status = "Freeze charging"
+                            status_per_inverter[inverter.id] = status
                             status_extra += " target" if inverter.id == 0 else " /"  # Append multi-inverter target SoC's together
-                            status_extra += " {}%".format(inverter.soc_percent)
+                            status_extra += " {} {}%".format(status, inverter.soc_percent)
                             self.log("Inverter {} Freeze charging with SoC {}%".format(inverter.id, inverter.soc_percent))
                         else:
                             # We can only hold charge if a) we have a way to hold the charge level on the reserve or with a pause feature
                             # and the current charge level is above the target for all inverters
                             if self.set_soc_enable and inverter.soc_percent >= inv_target_soc_percent:
                                 status = "Hold charging"
+                                status_per_inverter[inverter.id] = status
                                 self.log(
                                     "Inverter {} Hold charging as SoC {}% is above target SoC {}% (global soc target {}%) set_discharge_during_charge {}".format(
                                         inverter.id, inverter.soc_percent, dp0(inv_target_soc_percent), dp0(target_soc), self.set_discharge_during_charge
@@ -240,10 +292,11 @@ def execute_plan(self):
                                     inverter.adjust_charge_window(charge_start_time, charge_end_time, self.minutes_now)
                             else:
                                 status = "Charging"
+                                status_per_inverter[inverter.id] = status
                                 inverter.adjust_charge_window(charge_start_time, charge_end_time, self.minutes_now)
 
                             status_extra += " target" if inverter.id == 0 else " /"  # append multi-inverter target SoC's together
-                            status_extra += " {}%-{}%".format(inverter.soc_percent, inv_target_soc_percent)
+                            status_extra += " {} {}%-{}%".format(status, inverter.soc_percent, inv_target_soc_percent)
 
                         if not self.set_discharge_during_charge and resetPause:
                             # Do we discharge discharge during charge
@@ -378,8 +431,9 @@ def execute_plan(self):
                         self.isExporting_Target = int(target)
 
                         status = "Exporting"
+                        status_per_inverter[inverter.id] = status
                         status_extra += " target" if inverter.id == 0 else " /"  # append multi-inverter target SoC's together
-                        status_extra += " {}%-{}%".format(inverter.soc_percent, int(target))
+                        status_extra += " {} {}%-{}%".format(status, inverter.soc_percent, int(target))
                         # Immediate export mode
                     else:
                         inverter.adjust_force_export(False)
@@ -398,16 +452,18 @@ def execute_plan(self):
 
                             self.log("Export Freeze as exporting is now at/below target - current SoC {}kWh and target {}kWh".format(self.soc_kw, discharge_soc))
                             status = "Freeze exporting"
+                            status_per_inverter[inverter.id] = status
                             status_extra += " current SoC" if inverter.id == 0 else " /"  # append multi-inverter target SoC's together
-                            status_extra += " {}%".format(inverter.soc_percent)  # Discharge limit (99) is meaningless when Freeze Exporting so don't display it
+                            status_extra += " {} {}%".format(status, inverter.soc_percent)  # Discharge limit (99) is meaningless when Freeze Exporting so don't display it
                             isExporting = True
                             target = self.export_window_best[0].get("target", self.export_limits_best[0])
                             self.isExporting_Target = int(target)
                         else:
                             status = "Hold exporting"
+                            status_per_inverter[inverter.id] = status
                             target = self.export_window_best[0].get("target", self.export_limits_best[0])
                             status_extra += " target" if inverter.id == 0 else " /"  # append multi-inverter target SoC's together
-                            status_extra += " {}%-{}%".format(inverter.soc_percent, inverter.soc_percent)
+                            status_extra += " {} {}%-{}%".format(status, inverter.soc_percent, inverter.soc_percent)
                             self.isExporting_Target = inverter.soc_percent
                             self.log("Export Hold (Demand mode) as export is now at/below target or freeze only is set - current SoC {}kWh and target {}kWh".format(self.soc_kw, discharge_soc))
                 else:
@@ -477,25 +533,29 @@ def execute_plan(self):
 
             # iBoost running?
             boostHolding = False
-            if self.set_charge_window and self.iboost_enable and self.iboost_prevent_discharge and self.iboost_running_full and status not in ["Exporting", "Charging"]:
-                if inverter.inv_has_timed_pause:
-                    if resetPause:
-                        inverter.adjust_pause_mode(pause_discharge=True)
-                        resetPause = False
-                else:
-                    if resetDischarge:
-                        inverter.adjust_discharge_rate(0)
-                        resetDischarge = False
-                    if self.set_reserve_enable:
-                        inverter.adjust_reserve(min(inverter.soc_percent + 1, 100))
-                        resetReserve = False
-                boostHolding = True
-                self.log("Disabling battery discharge whilst iBoost is running")
-                if ("Hold for iBoost" not in status) and (status_hold_iboost == ""):
-                    if status == "Demand":
-                        status = "Hold for iBoost"
+            if self.set_charge_window and self.iboost_enable and self.iboost_prevent_discharge and self.iboost_running_full:
+                # Only pause discharge on this inverter, and only annotate the status as held for
+                # iBoost, if the fleet isn't already Charging/Exporting - pausing would conflict with
+                # that, and the annotation must stay coupled to whether a hold actually happened here.
+                if status not in ["Exporting", "Charging"]:
+                    if inverter.inv_has_timed_pause:
+                        if resetPause:
+                            inverter.adjust_pause_mode(pause_discharge=True)
+                            resetPause = False
                     else:
-                        status_hold_iboost = ", Hold for iBoost"
+                        if resetDischarge:
+                            inverter.adjust_discharge_rate(0)
+                            resetDischarge = False
+                        if self.set_reserve_enable:
+                            inverter.adjust_reserve(min(inverter.soc_percent + 1, 100))
+                            resetReserve = False
+                    boostHolding = True
+                    self.log("Disabling battery discharge whilst iBoost is running")
+                    if ("Hold for iBoost" not in status) and (status_hold_iboost == ""):
+                        if status == "Demand":
+                            status = "Hold for iBoost"
+                        else:
+                            status_hold_iboost = ", Hold for iBoost"
 
             # Reset charge/discharge rate
             if resetPause:
@@ -628,6 +688,10 @@ def execute_plan(self):
             self.count_inverter_writes[inverter.id] += inverter.count_register_writes
             inverter.count_register_writes = 0
 
+        # Resolve the headline status across all inverters rather than leaving whichever inverter was
+        # processed last to silently win.
+        status = resolve_multi_inverter_status(status_per_inverter, status)
+
         # Set the charge/discharge status information
         self.set_charge_export_status(isCharging, isExporting, not (isCharging or isExporting))
         self.isCharging = isCharging

apps/predbat/inverter.py

@@ -1152,7 +1152,11 @@ def find_charge_curve(self, discharge):
                 else:
                     search_range = range(99, 85, -1)
 
-                # Find 100% end points
+                # Find 100% end points. The exact-match checks below ("Charging" / "Exporting",
+                # "Discharging") deliberately exclude "Cross-charging" minutes - during genuine
+                # cross-charging another inverter is simultaneously drawing/feeding power at the
+                # same time, so this inverter's battery_power reading isn't a clean single-inverter
+                # charge/discharge sample and would corrupt the learned curve if included.
                 for data_point in search_range:
                     for minute in range(1, min_len):
                         # Start trigger is when the SoC just increased above the data point

apps/predbat/output.py

@@ -52,6 +52,17 @@
 }
 
 
+def yesterday_slot_is_exporting(slot_status):
+    """True when a historical ``predbat.status`` string (already lower-cased) represents export
+    activity for the "yesterday" plan reconstruction in ``calculate_yesterday()``.
+
+    Includes "cross-charging" explicitly - it genuinely straddles both sides of the fleet at once,
+    but as a string it contains "charging" and not "exporting", so a plain substring check on
+    "exporting" alone would silently drop the export half of a real cross-charging slot.
+    """
+    return "exporting" in slot_status or "cross-charging" in slot_status
+
+
 class Output:
     """Output and sensor publishing mixin.
 
@@ -3183,15 +3194,18 @@ def calculate_yesterday(self):
                     slot_status = predbat_status.get(slot_minute, "").lower()
                     real_minute = minute + slot_offset
 
-                    if "exporting" in slot_status:
+                    # Cross-charging genuinely straddles both sides - track it as both an exporting
+                    # and a charging slot (its name contains "charging" but not "exporting"), so
+                    # these are independent "if"s rather than "if/elif".
+                    if yesterday_slot_is_exporting(slot_status):
                         export_during_slot = slot_status
                         if export_start_minute is None:
                             export_start_minute = real_minute
                             if slot_offset == 5:
                                 export_start_minute -= 5
                             if charge_start_minute is not None:
                                 charge_end_minute = export_start_minute
-                    elif "charging" in slot_status:
+                    if "charging" in slot_status:
                         charge_during_slot = slot_status
                         if charge_start_minute is None:
                             charge_start_minute = real_minute
@@ -3206,7 +3220,7 @@ def calculate_yesterday(self):
                 if charge_end_minute is None and charge_start_minute is not None:
                     charge_end_minute = minute + self.plan_interval_minutes
 
-                if "exporting" in export_during_slot:
+                if yesterday_slot_is_exporting(export_during_slot):
                     # Assume exporting at this time
                     self.export_window_best.append({"start": export_start_minute, "end": export_end_minute})
                     if "freeze" in export_during_slot: