@@ -2068,9 +2068,12 @@
         "has_time_window": False,
         "support_charge_freeze": True,
         # "Feed-in first"/freeze export mode does not hold SoC flat on FoxESS - PV above the
-        # export limit still charges the battery instead of being clipped (#4207) - matching
-        # FoxCloud's entry below, which was already correctly set False for the same hardware.
-        "support_discharge_freeze": False,
+        # export limit still charges the battery instead of being clipped (#4207). That's now
+        # correctly modelled (prediction.py's freeze branch, gated on
+        # inverter_can_charge_during_export) rather than treated as a reason to disable freeze
+        # outright, so this can stay True - see FoxCloud's entry below for the same hardware via
+        # a different connection method.
+        "support_discharge_freeze": True,
         "has_idle_time": False,
         "can_span_midnight": True,
         "charge_discharge_with_rate": False,
@@ -2099,7 +2102,8 @@
         "write_and_poll_sleep": 2,
         "has_time_window": False,
         "support_charge_freeze": True,
-        "support_discharge_freeze": False,
+        # See FoxESS's entry above - same hardware, correctly modelled rather than disabled (#4207).
+        "support_discharge_freeze": True,
         "has_idle_time": False,
         "can_span_midnight": False,
         "charge_discharge_with_rate": False,
@@ -2438,6 +2442,7 @@
     "pause_start_time": {"type": "sensor_list", "sensor_type": "none|string", "modify": True, "entries": "num_inverters"},
     "pause_end_time": {"type": "sensor_list", "sensor_type": "none|string", "modify": True, "entries": "num_inverters"},
     "inverter_limit": {"type": "sensor_list", "sensor_type": "float", "modify": False, "zero": False, "entries": "num_inverters"},
+    "inverter_can_charge_during_export": {"type": "boolean"},
     "pv_ac_limit": {"type": "float", "zero": True},
     "inverter_limit_charge": {"type": "sensor_list", "sensor_type": "integer", "modify": False, "zero": False, "entries": "num_inverters"},
     "inverter_limit_charge_dc": {"type": "sensor_list", "sensor_type": "integer", "modify": False, "zero": False, "entries": "num_inverters"},
 
@@ -871,12 +871,6 @@ def run_prediction(self, charge_limit, charge_window, export_window, export_limi
             # Count load
             load_kwh += load_yesterday
 
-            # discharge freeze, reset charge rate by default
-            if set_export_freeze:
-                # Freeze mode
-                if (export_window_active) and export_limit_now < 100.0 and (set_export_freeze and (export_limit_now == 99.0 or set_export_freeze_only)):
-                    charge_rate_now = battery_rate_min  # 0
-
             # Set discharge during charge?
             if charge_window_active:
                 if not set_discharge_during_charge:
@@ -1066,6 +1060,36 @@ def run_prediction(self, charge_limit, charge_window, export_window, export_limi
                         pv_in_period = pv_compare / step * charge_time_remains
                         potential_import = min((charge_rate_now_curve * charge_time_remains) - pv_in_period, (charge_limit_n - soc))
                         metric_keep += max(potential_import * import_rate, 0)
+            elif set_export_freeze and export_window_active and export_limit_now < 100.0 and (export_limit_now == 99.0 or set_export_freeze_only):
+                # Freeze - the battery is not actively discharged to help export, but genuine PV
+                # surplus beyond what load+export_limit can absorb still charges it on some
+                # inverters rather than being clipped (#4207) - e.g. FoxESS "Feed-in First"
+                # prioritises load, then export, then the battery. Only the genuine overflow is
+                # charged (not the full charge rate), so freeze still holds SoC flat whenever the
+                # export limit alone can absorb all the surplus - matching the equivalent recapture
+                # logic in the force export branch above, just without any active discharge.
+                battery_draw = 0
+                pv_ac = pv_now * inverter_loss_ac
+                pv_dc = 0
+
+                diff = get_diff(battery_draw, pv_dc, pv_ac, load_yesterday, inverter_loss, inverter_loss_recp)
+                if diff < 0 and abs(diff) > export_limit and self.inverter_can_charge_during_export:
+                    over_limit = abs(diff) - export_limit
+                    if inverter_hybrid:
+                        charge_rate_now_curve_dc = (
+                            get_charge_rate_curve_cached(soc, battery_rate_max_charge_dc, soc_max, battery_rate_max_charge_dc, battery_charge_power_curve_tuple, battery_rate_min, battery_temperature, battery_temperature_charge_curve_tuple)
+                            * battery_rate_max_scaling
+                        )
+                        charge_rate_now_curve_dc_step = charge_rate_now_curve_dc * step
+                        battery_draw = max(-over_limit * inverter_loss_recp, -battery_to_max, -charge_rate_now_curve_dc_step)
+                    else:
+                        battery_draw = max(-over_limit * inverter_loss, -battery_to_max, -charge_rate_now_curve_step)
+
+                    if battery_draw < 0:
+                        pv_dc = min(abs(battery_draw), pv_now)
+                        pv_ac = (pv_now - pv_dc) * inverter_loss_ac
+
+                battery_state = "fz+" if battery_draw < 0 else "fz~"
             else:
                 # ECO Mode
                 pv_ac = pv_now * inverter_loss_ac
@@ -1088,9 +1112,8 @@ def run_prediction(self, charge_limit, charge_window, export_window, export_limi
                     # Battery draw is only subject to inverter limit for the AC part
                     if inverter_hybrid:
                         charge_rate_now_dc = battery_rate_max_charge_dc
-                        # Freeze mode
-                        if set_export_freeze and export_window_active and export_limit_now < 100.0 and (export_limit_now == 99.0 or set_export_freeze_only):
-                            charge_rate_now_dc = battery_rate_min  # 0
+                        # Freeze windows are handled by their own elif branch above and never reach
+                        # here - no need to zero the charge rate for them in this branch.
 
                         charge_rate_now_curve_dc = (
                             get_charge_rate_curve_cached(soc, charge_rate_now_dc, soc_max, battery_rate_max_charge_dc, battery_charge_power_curve_tuple, battery_rate_min, battery_temperature, battery_temperature_charge_curve_tuple)
 
@@ -43,7 +43,7 @@
 // falling back. Bumping makes the loader reject it and use the Python engine, which is the whole
 // point of the check.
 #define PK_ABI_VERSION 4
-#define PK_PARITY_REVISION 6
+#define PK_PARITY_REVISION 7
 #define PK_MAX_CARS 8
 #define PK_RUN_EVERY 5 // const.py RUN_EVERY
 
@@ -905,13 +905,6 @@ static int32_t pk_run_one(const ContextStore *store, const PkScenario *s, PkResu
             }
         }
 
-        // Discharge freeze - prediction.py:764-768
-        if (c->set_export_freeze) {
-            if (export_window_active && export_limit_now < 100.0 && (c->set_export_freeze && (export_limit_now == 99.0 || c->set_export_freeze_only))) {
-                charge_rate_now = battery_rate_min; // 0
-            }
-        }
-
         // Set discharge during charge - prediction.py:770-775
         if (charge_window_active) {
             if (!c->set_discharge_during_charge) {
@@ -1059,6 +1052,31 @@ static int32_t pk_run_one(const ContextStore *store, const PkScenario *s, PkResu
                     metric_keep += std::max(potential_import * import_rate, 0.0);
                 }
             }
+        } else if (c->set_export_freeze && export_window_active && export_limit_now < 100.0 && (export_limit_now == 99.0 || c->set_export_freeze_only)) {
+            // Freeze - not an active discharge, but genuine PV surplus beyond what
+            // load+export_limit can absorb still charges the battery on some inverters rather
+            // than being clipped (#4207) - mirrors the recapture logic in the force export
+            // branch above, without any active discharge. prediction.py's matching elif.
+            battery_draw = 0;
+            pv_ac = pv_now * inverter_loss_ac;
+            pv_dc = 0;
+
+            const double diff_freeze = get_diff(battery_draw, pv_dc, pv_ac, load_yesterday, inverter_loss, inverter_loss_recp);
+            if (diff_freeze < 0 && std::fabs(diff_freeze) > export_limit && c->inverter_can_charge_during_export) {
+                const double over_limit = std::fabs(diff_freeze) - export_limit;
+                if (inverter_hybrid) {
+                    const double charge_rate_now_curve_dc = rate_curve(soc, battery_rate_max_charge_dc, battery_rate_max_charge_dc, c->temp_charge_cap[k], c->charge_curve, soc_max, battery_rate_min) * battery_rate_max_scaling;
+                    const double charge_rate_now_curve_dc_step = charge_rate_now_curve_dc * step;
+                    battery_draw = std::max({-over_limit * inverter_loss_recp, -battery_to_max, -charge_rate_now_curve_dc_step});
+                } else {
+                    battery_draw = std::max({-over_limit * inverter_loss, -battery_to_max, -charge_rate_now_curve_step});
+                }
+
+                if (battery_draw < 0) {
+                    pv_dc = std::min(std::fabs(battery_draw), pv_now);
+                    pv_ac = (pv_now - pv_dc) * inverter_loss_ac;
+                }
+            }
         } else {
             // ECO Mode - prediction.py:951-997
             pv_ac = pv_now * inverter_loss_ac;
@@ -1075,11 +1093,9 @@ static int32_t pk_run_one(const ContextStore *store, const PkScenario *s, PkResu
                 battery_draw = std::min({diff, discharge_rate_now_curve_step, inverter_limit, battery_to_min});
             } else {
                 if (inverter_hybrid) {
-                    double charge_rate_now_dc = battery_rate_max_charge_dc;
-                    // Freeze mode - prediction.py:973-975
-                    if (c->set_export_freeze && export_window_active && export_limit_now < 100.0 && (export_limit_now == 99.0 || c->set_export_freeze_only)) {
-                        charge_rate_now_dc = battery_rate_min; // 0
-                    }
+                    const double charge_rate_now_dc = battery_rate_max_charge_dc;
+                    // Freeze windows are handled by their own else-if branch above and never
+                    // reach here - no need to zero the charge rate for them in this branch.
                     // Note: Python passes the un-rounded soc for the DC-rate lookup here
                     const double charge_rate_now_curve_dc = rate_curve(soc, charge_rate_now_dc, battery_rate_max_charge_dc, c->temp_charge_cap[k], c->charge_curve, soc_max, battery_rate_min) * battery_rate_max_scaling;
                     const double charge_rate_now_curve_dc_step = charge_rate_now_curve_dc * step;
 
@@ -32,7 +32,7 @@
 
 # Expected ABI/parity revisions of the shared library (see prediction_kernel.cpp)
 KERNEL_ABI_VERSION = 4
-KERNEL_PARITY_REVISION = 6
+KERNEL_PARITY_REVISION = 7
 
 # Maximum number of cars supported by the kernel (PK_MAX_CARS in prediction_kernel.cpp)
 KERNEL_MAX_CARS = PREDBAT_MAX_CARS