How can I cleanly distribute definitions of system functions?

Question

I have a package that redefines a system symbol, and I am struggling to find a clean solution that will ensure that those redefinitions will still work inside a parallelized environment.

The core structure of the package is of the following form:

BeginPackage["Utilities`"];
f::usage = "...";
Begin["`Private`"];
f[x_] := x;
End[];
EndPackage[];
DistributeDefinitions["Utilities`"];

(Shamelessly stolen from here, so hopefully I'm not the only one that does this.) Doing the DistributeDefinitions call in this way has several advantages:

• it does not attempt to launch new subkernels when they are not necessary
• it keeps the package definitions in some mysterious place where they are always available for any new subkernels that get launched subsequently, even if e.g. one of them crashes and gets re-launched
• it does no harm if the package is called from inside a parallelized environment (i.e. it doesn't return errors of the form "you tried to parallelize from inside a subkernel, but this is not Inception and you are not Leonardo di Caprio")

Now, I want to expand this package to redefine the workings of some system symbol. For the sake of argument, suppose that I want to modify RandomComplex in the following form:

Unprotect[RandomComplex];
RandomComplex[{range1_List, moreRanges___}, number_] :=  Transpose[
                         RandomComplex[#, number] & /@ {range1, moreRanges}]
Protect[RandomComplex];

Unfortunately, even if I do this within the BeginPackage[] and EndPackage[] calls, the redefinition does not get sent to any subkernels that get launched afterwards. Thus, suppose I write this into the code above, load the package, launch some new kernels, and then run

ParallelEvaluate[RandomComplex[{{0, 1 + I}, {0, 1 + I}}, 3]]

I will then get a bunch of error messages, because each subkernel is using the unpatched version.

How can I make sure that this redefinition gets distributed downstream, ideally in a way that preserves the advantages I mentioned above, and with the least amount of pain possible.

(In particular, I can obviously run ParallelEvaluate on the redefinition, but then it is not stable against a subkernel crash-plus-relaunch, and it will kick and scream if I Get or Needs the package from inside a parallelized environment.)