@@ -2221,6 +2221,50 @@ def parse_window(start_str, end_str):
                 active_mode = SIGENERGY_ACTIVE_MODE_CHARGE
                 charge_power_kw = charge_rate_w / 1000.0
                 charge_priority_type = "PV"
+        elif charge_rate_w == 0:
+            # No window is active, so the only thing left that can distinguish demand from a
+            # freeze export is the rates Predbat has written. Predbat expresses Freeze Export as
+            # "demand mode, but with charging disabled": execute.py turns the forced-export window
+            # off (adjust_force_export(False)) and calls adjust_charge_rate(0), because SIGCLOUD
+            # declares has_timed_pause False and charge_discharge_with_rate False, so that zero is
+            # the only lever it has left. The freeze_export branch above is therefore never
+            # reached from a planned freeze - export_enable is already False by the time we run -
+            # and the command came out identical to plain demand, which routes the surplus PV a
+            # freeze exists to export into the battery instead (GH#4761).
+            #
+            # This is the same inference fox.py, deye.py and sunsynk.py make from the same
+            # entities, for the same reason - see fox.py's freeze_export_requested(). Unlike those,
+            # a zero charge rate is read as a freeze here without also requiring a non-zero export
+            # rate. Their guard exists because their rate entities are published at 0, so all-zero
+            # is an absence of a plan rather than a plan; the Sigenergy rate controls default to
+            # the battery maximum instead (_control_info), so a zero only ever arrives by Predbat
+            # deliberately writing one.
+            duration_min = 720
+            if export_rate_w > 0:
+                # Charging disabled, discharging still allowed - a plain freeze export.
+                # Self-Consumption Grid is the right mode for it: surplus PV serves the load, then
+                # sells to the grid rather than charging the battery, while the battery still
+                # discharges to serve the house when solar is short. charge_power_kw is
+                # deliberately left None: the API documents it as bidirectional ("max energy
+                # storage charging/discharging power"), so zeroing it here would also stop the
+                # battery serving the house, which is a freeze CHARGE, not a freeze export.
+                new_mode = "freeze_export"
+                active_mode = SIGENERGY_ACTIVE_MODE_SELF_GRID
+            else:
+                # Both rates zero: a freeze export with a discharge hold on top. execute.py writes
+                # the export rate to 0 for a car-charging or iBoost hold (no timed pause on
+                # SIGCLOUD, so the rate is again the only lever), and the freeze export leaves the
+                # charge rate at 0 alongside it. Rare in practice - a car held off the battery is
+                # being charged from solar or grid - but reachable, and Self-Consumption Grid
+                # would be wrong for it because that mode lets the battery discharge to serve the
+                # house, which is exactly what the hold forbids.
+                #
+                # Plain self-consumption with the bidirectional power pinned to 0 expresses both
+                # halves at once: no charging from the PV surplus and no discharging to the hold,
+                # the same lever the freeze_charge branch above already uses to hold SoC flat.
+                new_mode = "freeze_export_hold"
+                active_mode = SIGENERGY_ACTIVE_MODE_SELF
+                charge_power_kw = 0
         else:
             duration_min = 720
             new_mode = "eco"
 
@@ -19,6 +19,7 @@
     SIGENERGY_ACTIVE_MODE_CHARGE,
     SIGENERGY_ACTIVE_MODE_DISCHARGE,
     SIGENERGY_ACTIVE_MODE_SELF,
+    SIGENERGY_ACTIVE_MODE_SELF_GRID,
     SIGENERGY_CODE_IN_OTHER_VPP,
     SIGENERGY_CODE_SYSTEM_PENDING_REVIEW,
     SIGENERGY_LOG_REDACT_KEYS,
@@ -1289,6 +1290,69 @@ async def mock_send_battery_command(sid, active_mode, duration_min, charging_pow
     return failed
 
 
+def test_sigenergy_apply_controls_freeze_export_no_window(my_predbat):
+    """Test apply_controls sends Self-Consumption Grid for a freeze export left by execute.py."""
+    failed = False
+
+    def run_case(charge_rate, export_rate):
+        """Apply controls with the given rates and no active window, returning the battery commands."""
+        api = MockSigenergyAPI()
+        system_id = "SIG001"
+        api.systems[system_id] = {"systemName": "Home", "batteryCapacity": 10.0}
+        api.devices[system_id] = [{"deviceType": "Battery", "attrMap": {"ratedChargePower": 3.0}}]
+        api.energy_flow[system_id] = {"batterySoc": 80.0}
+        # This is the control state execute.py actually leaves behind for a Freeze Export on
+        # SIGCLOUD: adjust_force_export(False) has already cleared the export window, so the
+        # only remaining signal is adjust_charge_rate(0) against a reset export rate.
+        api.controls[system_id] = {
+            "charge": {"enable": False, "start_time": "00:00:00", "end_time": "00:00:00", "target_soc": 100, "rate": charge_rate},
+            "export": {"enable": False, "start_time": "00:00:00", "end_time": "00:00:00", "target_soc": 0, "rate": export_rate},
+            "reserve": 10,
+        }
+
+        commands_sent = []
+
+        async def mock_send_battery_command(sid, active_mode, duration_min, charging_power_kw=None, **kwargs):
+            commands_sent.append(("battery_cmd", sid, active_mode, duration_min, charging_power_kw))
+            return True
+
+        api.send_battery_command = mock_send_battery_command
+
+        ok = run_async(api.apply_controls(system_id))
+        assert ok is True, "apply_controls freeze export returned True"
+        return [c for c in commands_sent if c[0] == "battery_cmd"]
+
+    # Charge rate pinned to zero with the export rate still live — a freeze export
+    bat_cmds = run_case(0, 3000)
+    assert len(bat_cmds) >= 1, "send_battery_command called for freeze export"
+    assert bat_cmds[0][2] == SIGENERGY_ACTIVE_MODE_SELF_GRID, "selfConsumption-grid sent for freeze export, got {}".format(bat_cmds[0][2])
+    # chargingPower is bidirectional on this API, so a freeze export must not cap it — that
+    # would also stop the battery serving the house, which is a freeze charge not a freeze export
+    assert bat_cmds[0][4] is None, "no charging power cap sent for freeze export, got {}".format(bat_cmds[0][4])
+
+    # Both rates zero — a freeze export with a car-charging or iBoost discharge hold on top.
+    # selfConsumption-grid would let the battery discharge to serve the house, which the hold
+    # forbids, so this is plain self-consumption with the bidirectional power pinned to zero
+    bat_cmds = run_case(0, 0)
+    assert len(bat_cmds) >= 1, "send_battery_command called for freeze export with a discharge hold"
+    assert bat_cmds[0][2] == SIGENERGY_ACTIVE_MODE_SELF, "selfConsumption sent for freeze export with a discharge hold, got {}".format(bat_cmds[0][2])
+    assert bat_cmds[0][4] == 0, "charging power pinned to 0 for freeze export with a discharge hold, got {}".format(bat_cmds[0][4])
+
+    # A discharge hold on its own, with charging still allowed, is not a freeze and must not be
+    # capped — the bidirectional power cannot express "charge allowed, discharge blocked"
+    bat_cmds = run_case(3000, 0)
+    assert len(bat_cmds) >= 1, "send_battery_command called for a discharge hold alone"
+    assert bat_cmds[0][2] == SIGENERGY_ACTIVE_MODE_SELF, "selfConsumption sent for a discharge hold alone, got {}".format(bat_cmds[0][2])
+    assert bat_cmds[0][4] is None, "no charging power cap sent for a discharge hold alone, got {}".format(bat_cmds[0][4])
+
+    # A normal demand period with both rates live stays in demand
+    bat_cmds = run_case(3000, 3000)
+    assert len(bat_cmds) >= 1, "send_battery_command called for demand"
+    assert bat_cmds[0][2] == SIGENERGY_ACTIVE_MODE_SELF, "selfConsumption sent for demand, got {}".format(bat_cmds[0][2])
+
+    return failed
+
+
 # ---------------------------------------------------------------------------
 # MQTT tests
 # ---------------------------------------------------------------------------
@@ -3154,6 +3218,7 @@ def run_sigenergy_tests(my_predbat):
         ("apply_controls_eco_mode", test_sigenergy_apply_controls_eco_mode),
         ("apply_controls_deduplication", test_sigenergy_apply_controls_deduplication),
         ("apply_controls_export_mode", test_sigenergy_apply_controls_export_mode),
+        ("apply_controls_freeze_export_no_window", test_sigenergy_apply_controls_freeze_export_no_window),
         ("publish_mqtt_success", test_sigenergy_publish_mqtt_success),
         ("redact", test_sigenergy_redact),
         ("publish_mqtt_redacts_token", test_sigenergy_publish_mqtt_redacts_token),