I tried to address most of the above in the more detailed write-up I linked to. I didn't want to spam out a message that was too long, and the link provided a good way to get syntax highlighting etc.
The code that is available in the linked github repository now treats lookups and sets in fastlocals the same way it does for global and module level namespaces. I changed the behavior so that it does not affect variables stored in a dictionary. If you have one of these "cloaking" variables in a dict, you will get the actual variable before __getself__ or __setself__ is called. This makes it behave the same way as it would in say a list. Only looking up a variable by name causes these methods to get triggered.
My current implementation does not handle slots (or closures) but that I have looked into it, but I just didn't prioritize that work. I do not believe it will not be too hard to add though. I did a little bit of "magic" (inside the new lookup) to ensure that self does not have __getself__ called on it if it is used within its own methods. That keeps the code reading the same as existing python code.
As for type, it responds to whatever py object is loaded. If a __getself__ is called then type will see the result that is returned. I have added a few (preliminary implemented) "builtins" to my demo that help address this. One is getcloaked, which will return the underlying variable if there is one, otherwise it just returns the normal python variable. This reads:
type(x) => result of x.__getself__
type(getcloaked('x')) => the cloaking type i.e. the history variable in one example
I have also added a setcloaked to ignore __setself__ and re-bind the name, cloaksset which returns if a variable implements __setself__, cloaksget which does the same for get, and iscloaking which returns if a variable implements any cloaking behavior.