The RTSJ Spec says:

For purposes of scoped memory reference counting, the following are treated as execution contexts:

• RealtimeThread objects that have been started and have not terminated,
• AsyncEventHandler objects that are currently in a released state,
• AsyncEvent objects that are bound to happenings,
• Timer objects that have been started and have not been destroyed,
• other schedulable objects that control an execution engine

I think the most common way to keep a scope "open" is to leave a waiting real-time thread in it. A waiting async event handler would work equally well, but if an AEH is forced to wait, it is little different from a thread. An async event bound to a happening would work nicely, but not many people use happenings, and those who do take them too seriously to bind one to an async event that intentionally does nothing.

A one-shot timer, however, is a nice fit for the job. It even has a nice side effect. By setting its duration to a time longer than the scope should stay open, the developer has a chance to give it an AEH that reports the error ("Someone forgot to unpin this scope!") and maybe tries to recover from the error.

• To pin a scope, enter the scope, create a one-shot and start it.
• Save a reference to the one-shot in the scoped memory's portal
• To unpin the scope, get a reference to the timer from the portal and invoke its destroy() method.

Here's a program that demonstrates these steps.