Unless and until we get to efficient homomorphic compute, these measures will only ever be security via obscurity.
replies(1):
Either you implement it with security features hidden from the device holder, in which case it will always be broken eventually, or you guarantee the capabilities with mathematics - in which case a security break cannot happen even if the physical machine's description is completely public.
There are certainly layers to this that I'm missing, but I think homomorphic compute is the only unbreakable answer to secure compute in general.
The issue here, of the key holder leaking the key, also seems impossible to work around in general, since the requirements are: 1) there exists someone who can sign code. 2) that person cannot screw up (e.g. leak the key) and allow the wrong code to be signed. These are pretty contradictory requirements, that no amount of crypto can fix. Ultimately it is a social problem not a technical one; there is no full technical definition of misusing a key. There are things that can help - like HSMs, splitting the key between multiple parties, having better methods of revoking and replacing compromised keys (hard without network access and an unwillingness to brick old devices). Not the same domain, but AACS is an interesting example of a system somewhat resiliant to key compromise.
I'm not sure if it's possible (given that there's overlap with public key/private key encryption it may be), but I think that if you could produce a homomorphic computer capable of plain text export, this would be a resolvable problem.