You are pretty much doing what call/cc does, and so could
straightforwardly rewrite the functions that cause scripts to freeze
to capture the current continuation and schedule an event to resume
this continuation when needed. So something like:

(define (say-stop message)
(call/cc (lambda (k)
(%say-stop message k))))

This might be worth trying and might perform well enough, but Guile's
call/cc is fairly slow and heavyweight as it must copy the entire C
stack.

The amount of the stack that needs copying could be reduced, though, by putting a continuation barrier (scm_c_with_continuation_barrier) in the C code shortly before it calls out to Guile.

Personally, I'd try the continuation approach. I did something just like this for a dayjob-related project, where a key objective was to make the Scheme scripts as friendly-looking as possible to non-Scheme people. I used continuations to make it possible to write a script as a sequence of apparently synchronous operations that were really asynchronous (i.e. send a request somewhere, and wait for an asynchronous response). It can be done in such a way that the call/cc is hidden down in the infrastructure, and script-writers never need to see it.

A complication in my case was that the C code was sensitive to unusual return patterns. So I also needed to use a continuation to protect the C code; I can provide more detail about that if needed.

Regards,
Neil