One more bugfix for the day. Previously, the compiler handled constant lists in rule heads in a special way that’s very fast at runtime, but uses O(n) temporary variables. It builds the list from the front, unifying the elements with the query arguments one by one. This is good for making rules like (perform [put $Obj #on $Supporter]) very efficient (it can stop building the list as soon as something doesn’t match), but there are only so many registers available to put temporaries in, so really big lists can exhaust those registers and crash the compiler.
So now, if a constant list in a rule head is sufficiently long (at least 10 elements if the rule is called with unbound parameters, 20 elements if not), it will be compiled the same way as constant lists in rule bodies. This builds the list starting from the end, which means it can’t short-circuit the comparison (comparisons have to start from the front), but it only uses O(1) registers.
See this thread for the symptoms, and this thread for the causes. I don’t expect this to come up often—list literals with 10 or more elements aren’t common—but it causes no harm in the more usual case, and anything that keeps the compiler from crashing is an improvement in my book!