diff --git a/.github/workflows/build_release.yml b/.github/workflows/build_release.yml
index a1325101..ee935917 100644
--- a/.github/workflows/build_release.yml
+++ b/.github/workflows/build_release.yml
@@ -19,7 +19,7 @@ jobs:
     - name: configure
       run: cmake . -DCMAKE_BUILD_TYPE=Release
     - name: build
-      run: cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI Luau.Compile.CLI Luau.Ast.CLI --config Release -j 2
+      run: cmake --build . --target Luau.Repl.CLI Luau.Analyze.CLI Luau.Compile.CLI Luau.Ast.CLI Luau.Harness.CLI --config Release -j 2
     - name: pack
       if: matrix.os.name != 'windows'
       run: zip slua-${{github.event.release.tag_name}}-${{matrix.os.name}}.zip slua*
diff --git a/CLI/src/Harness.cpp b/CLI/src/Harness.cpp
index 0f085e89..497d367f 100644
--- a/CLI/src/Harness.cpp
+++ b/CLI/src/Harness.cpp
@@ -102,6 +102,8 @@ static void displayHelp(const char* argv0)
     printf("  --quanta=<usecs>: time slice per run window (default 200)\n");
     printf("  -O<n>: compile with optimization level n (default 1)\n");
     printf("  --fflags=<list>: comma-separated fast flag settings (name=true/false),\n");
+    printf("  --sync-arming: install the quanta interrupt at window start instead of\n");
+    printf("                 from the watchdog thread (the legacy resident-handler policy)\n");
 }
 
 int main(int argc, char** argv)
@@ -109,6 +111,7 @@ int main(int argc, char** argv)
     const char* script_path = nullptr;
     double quanta_usec = 200.0;
     int optimization_level = 1;
+    bool sync_arming = false;
 
     for (int i = 1; i < argc; ++i)
     {
@@ -130,6 +133,10 @@ int main(int argc, char** argv)
         {
             setLuauFlags(argv[i] + 9);
         }
+        else if (strcmp(argv[i], "--sync-arming") == 0)
+        {
+            sync_arming = true;
+        }
         else if (strncmp(argv[i], "-O", 2) == 0)
         {
             int level = atoi(argv[i] + 2);
@@ -199,6 +206,7 @@ int main(int argc, char** argv)
     HostCallbacks callbacks;
     callbacks.clockProvider = script_clock;
     callbacks.populateEnvironment = populate_environment;
+    callbacks.synchronousQuantaArming = sync_arming;
     // quantaClockProvider stays null so we exercise the engine's default
 
     Provisioner<> provisioner(callbacks);
@@ -289,6 +297,19 @@ int main(int argc, char** argv)
     double runtime = lua_clock() - start;
     fprintf(stderr, "Runtime: %f, Accum. Sleep: %f, Time Slices: %zu\n", runtime, accum_sleep, slices);
 
+    WatchdogStats wd_stats = provisioner.getQuantaWatchdog()->getStats();
+    if (wd_stats.fires > 0)
+    {
+        fprintf(
+            stderr,
+            "Watchdog fires: %llu, lateness usecs min/avg/max: %.1f/%.1f/%.1f\n",
+            (unsigned long long)wd_stats.fires,
+            wd_stats.latenessMin * 1e6,
+            wd_stats.latenessSum / (double)wd_stats.fires * 1e6,
+            wd_stats.latenessMax * 1e6
+        );
+    }
+
     if (result.status == HandlerRunStatus::Fault)
     {
         auto &fault_str = script->getExtendedFaultString().empty() ? script->getFaultString() : script->getExtendedFaultString();
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce344864..cf7f313b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -311,6 +311,10 @@ if(CMAKE_SYSTEM_NAME MATCHES "Linux|Darwin|iOS")
     target_link_libraries(osthreads INTERFACE "-lpthread")
 endif ()
 
+# ServerLua: the executor's quanta watchdog runs on a thread; PUBLIC so
+# embedders of the static library inherit the pthread requirement
+target_link_libraries(Luau.Executor PUBLIC osthreads)
+
 if(LUAU_BUILD_CLI)
     target_compile_options(Luau.Repl.CLI PRIVATE ${LUAU_OPTIONS})
     target_compile_options(Luau.Reduce.CLI PRIVATE ${LUAU_OPTIONS})
diff --git a/Executor/include/Luau/Executor.h b/Executor/include/Luau/Executor.h
index a4ecea6d..b24c9164 100644
--- a/Executor/include/Luau/Executor.h
+++ b/Executor/include/Luau/Executor.h
@@ -90,6 +90,79 @@ void logWarn(const char* source, const char* fmt, ...) LUA_PRINTF_ATTR(2, 3);
 // Figure out which clock source to use
 lua_clockProvider resolveDefaultQuantaClock();
 
+// Signature of the VM interrupt callback, as installed into lua_Callbacks
+using InterruptCallback = void (*)(lua_State* L, int gc);
+
+// Aggregate timing of a watchdog's deadline fires, for tuning its fire lead.
+// Lateness (seconds) is how far past the intended fire instant the install
+// actually happened: OS wakeup jitter in the common case, but it also
+// absorbs the whole overshoot when a window is armed with less than a
+// lead's worth of quanta, so a bimodal max isn't necessarily jitter.
+struct WatchdogStats
+{
+    uint64_t fires = 0;
+    double latenessSum = 0.0;
+    double latenessMin = 0.0;
+    double latenessMax = 0.0;
+};
+
+// Arming policy for a Script's run windows: owns the VM's interrupt handler
+// and how it gets installed so that quanta expiry can be delivered. The
+// installed pointer is only a request; the handler re-reads the real clock at
+// the safepoint, so the clock stays the source of truth. One watchdog serves
+// every VM of its provisioner (one per environment); arm() binds the open
+// window's VM as the one slot everything else operates on.
+class QuantaWatchdog
+{
+public:
+    // `handler` is whatever the script type's installVMCallbacks() put on the
+    // VM -- captured by the provisioner, so subclass handlers are honored.
+    explicit QuantaWatchdog(InterruptCallback handler)
+        : mHandler(handler)
+    {
+    }
+
+    virtual ~QuantaWatchdog();
+
+    // Open a run window: bind `target` as THE window (exactly one is open per
+    // provisioner, assert-enforced), reset its interrupt pointer to the
+    // implementation's baseline, and schedule `deadline`, a reading in the
+    // quanta clock's domain.
+    virtual void arm(lua_Callbacks* target, double deadline) = 0;
+
+    // Close out the window. Guarantees no future fire; does not touch the
+    // pointer.
+    virtual void disarm() = 0;
+
+    // Install the handler in the open window's VM right now, so the next
+    // safepoint runs it: what a deadline fire does, on demand. For conditions
+    // that must be noticed mid-window (sleep, force-yield).
+    virtual void fireNow() = 0;
+
+    // Self-heal for a spurious install in the open window: uninstall only if
+    // the window's fire is still pending, and report whether that happened.
+    // A bare store in the handler could instead wipe a concurrent fire and
+    // spend the window's one-shot.
+    virtual bool clearIfArmed() = 0;
+
+    // Lifetime totals of deadline fires. Zeros for policies where the
+    // deadline never fires as a distinct event (the synchronous one).
+    virtual WatchdogStats getStats() { return {}; }
+
+protected:
+    InterruptCallback mHandler = nullptr;
+};
+
+// The synchronous policy: arm installs the handler on the spot, so it stays
+// resident and checks the clock at every safepoint.
+std::unique_ptr<QuantaWatchdog> createImmediateQuantaWatchdog(InterruptCallback handler);
+// Go-sysmon-shaped policy for real-time clocks: windows run with no interrupt
+// installed, and a long-running watchdog thread -- asleep whenever no window
+// is armed -- stores the handler slightly ahead of the deadline so the
+// preemption lands on it rather than after it. Thread-creation failure
+// propagates as std::system_error.
+std::unique_ptr<QuantaWatchdog> createQuantaWatchdog(InterruptCallback handler, lua_clockProvider quantaClock);
+
 // Give the embedder a chance to plop their own things into the environment before it's
 // fully set up. This is called before GC fixing / ares perms registration.
 using PopulateEnvironmentCallback = void (*)(IEnvironment& environment, lua_State* L);
@@ -103,6 +176,11 @@ struct HostCallbacks
     lua_setTimerEventCallback setTimerEventCb = nullptr;
     lua_eventHandlerRegistrationCallback eventHandlerRegistrationCb = nullptr;
     lua_clockProvider quantaClockProvider = nullptr;
+    // Install the interrupt handler synchronously at window start (resident
+    // at every safepoint) instead of from the watchdog thread at the
+    // deadline. Required when quantaClockProvider doesn't advance with real
+    // time, e.g. a test's stepped fake clock.
+    bool synchronousQuantaArming = false;
     PopulateEnvironmentCallback populateEnvironment = nullptr;
 };
 
@@ -340,6 +418,10 @@ class IProvisioner
 
     virtual const HostCallbacks& getCallbacks() const = 0;
 
+    // The arming policy this provisioner's scripts use for their run windows.
+    // Never null once an environment exists (scripts can't exist before one).
+    virtual QuantaWatchdog* getQuantaWatchdog() const = 0;
+
     virtual std::shared_ptr<IEnvironment> createEnvironment(bool is_lsl, uint32_t api_version) = 0;
     virtual std::shared_ptr<IImage> buildImage(std::shared_ptr<IEnvironment> environment, const ImageConfig& config) = 0;
     virtual std::shared_ptr<Script> instantiateScript(const std::shared_ptr<IImage>& image, const ScriptConfig& config) = 0;
@@ -365,10 +447,26 @@ class Provisioner : public IProvisioner
 
     const HostCallbacks& getCallbacks() const override { return mCallbacks; }
 
+    QuantaWatchdog* getQuantaWatchdog() const override { return mWatchdog.get(); }
+
     std::shared_ptr<IEnvironment> createEnvironment(bool is_lsl, uint32_t api_version) override
     {
         std::shared_ptr<Environment> environment = makeEnvironment(is_lsl, api_version);
         environment->build<S>();
+
+        if (mWatchdog == nullptr)
+        {
+            // The first environment tells us which interrupt handler
+            // `S::installVMCallbacks` really installs (it may be a subclass's
+            // own, wrapping ours) -- every environment of this provisioner
+            // installs the same one.
+            InterruptCallback handler = lua_callbacks(environment->getBaseState())->interrupt;
+            if (mCallbacks.synchronousQuantaArming)
+                mWatchdog = createImmediateQuantaWatchdog(handler);
+            else
+                mWatchdog = createQuantaWatchdog(handler, mCallbacks.quantaClockProvider);
+        }
+
         return environment;
     }
 
@@ -433,6 +531,9 @@ class Provisioner : public IProvisioner
 
 private:
     HostCallbacks mCallbacks;
+    // Created with the first environment, once the installed interrupt
+    // handler is known. Destruction joins the threaded impl's thread.
+    std::unique_ptr<QuantaWatchdog> mWatchdog;
 };
 
 } // namespace Executor
diff --git a/Executor/include/Luau/Script.h b/Executor/include/Luau/Script.h
index be5bfa73..229d42e7 100644
--- a/Executor/include/Luau/Script.h
+++ b/Executor/include/Luau/Script.h
@@ -104,18 +104,25 @@ class Script : protected lua_SLRuntimeState
     // state. Unlike loadDefaultState(), this is valid at any time.
     bool reset();
 
-    // Start a run window for `quanta` seconds. _must_ be followed by symmetric `endRunWindow()`
-    // TODO: RAII helper thingy maybe?
+    // Start a run window for `quanta` seconds. Every window must be closed by
+    // exactly one endRunWindow() before the next begin, and must not begin
+    // with a pending sleep or force-yield (assert-enforced): sleep is a
+    // window output the host consumes (banks + zeroes) before scheduling the
+    // script again, and a host that wants a script stopped shouldn't be
+    // scheduling windows for it.
     void beginRunWindow(double quanta);
-    // And finish it.
+    // Close the current run window. isYieldDue(), getExcludedTime() and
+    // getSleep() stay readable after the close (only the next begin resets
+    // them); a pending force-yield is consumed, its life ends with its window.
     void endRunWindow();
     // True once the engine has decided the current run window is over, sticky
     // for the rest of the window.
     bool isYieldDue() const { return mYieldDue; }
 
-    // Level-triggered forced preemption, port of the host's
-    // `getReset() || !mIsEnabled` check. The host both sets and clears it.
-    void setForceYield(bool force) { mForceYield = force; }
+    // Forced preemption, a mid-window mechanism: the current window yields at
+    // its first safepoint. Port of the host's `getReset() || !mIsEnabled`
+    // check; the host sets it, and endRunWindow() consumes it.
+    void setForceYield(bool force);
 
     void *getHostContext() const { return mHostContext; }
 
@@ -157,7 +164,7 @@ class Script : protected lua_SLRuntimeState
     // How long we've been told to sleep. Never decremented, only zeroed out when the scheduler
     // decides we're done the sleep.
     float getSleep() const { return mSleep; }
-    void setSleep(float sleep) { mSleep = sleep; }
+    void setSleep(float sleep);
 
     // Wall time excluded from punishment accounting in the current window
     double getExcludedTime() const { return mExcludedTime; }
@@ -219,15 +226,21 @@ class Script : protected lua_SLRuntimeState
     // Monotonic stopwatch used for quanta-elapsed measurement, seeded from the
     // provisioner's.
     lua_clockProvider mQuantaClockProvider = nullptr;
+    // Arming policy for run windows, from the provisioner. Never null.
+    QuantaWatchdog* mWatchdog = nullptr;
+    // The VM's callback struct, one per environment and stable for its whole
+    // life -- which brackets ours, so this never dangles. Every instance we
+    // ever fork lives in that same VM.
+    lua_Callbacks* mCallbacks = nullptr;
 
     // When did we start running
     double mWindowStart = 0.0;
     // How long are we supposed to run?
     double mQuanta = 0.0;
-    // Wall time this window spent inside GC steps and reachability walks.
+    // Wall time this window spent inside reachability walks.
     double mExcludedTime = 0.0;
-    // Quanta clock reading at the opening bracket of the GC step in flight.
-    double mGCStepStart = 0.0;
+    // GC threshold saved across a run window while the GC is parked.
+    size_t mSavedGCThreshold = 0;
     // We've planned a script kill for this time, the script will be killed if
     // it doesn't finish before the deadline.
     double mMandatoryDeadline = 0.0;
@@ -237,8 +250,6 @@ class Script : protected lua_SLRuntimeState
     bool mYieldDue = false;
     // We already threw a catchable error trying to force a yield.
     bool mMandatoryYieldRaised = false;
-    // Between the paired pre and post interrupts of one GC step.
-    bool mGCStepInFlight = false;
     bool mInExecution = false;
     bool mMainFunctionComplete = false;
     // The host has indicated that a yield should happen at the next interrupt.
diff --git a/Executor/src/Scheduler.cpp b/Executor/src/Scheduler.cpp
index 40c8abe6..41de5a5a 100644
--- a/Executor/src/Scheduler.cpp
+++ b/Executor/src/Scheduler.cpp
@@ -1,33 +1,60 @@
-// low-overhead timestamp-counter clock for quanta preemption checks.
-//  This is largely a formalization of the `LLRDTSCTimer` pattern in
-//  viewer and server.
+// Quanta preemption scheduling: the watchdog policies that arm the VM's
+// interrupt pointer, and the low-overhead timestamp-counter clock they read.
+// The clock is largely a formalization of the `LLRDTSCTimer` pattern in
+// viewer and server.
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <thread>
+
 #include "Luau/Executor.h"
 
 #include "Luau/Common.h"
 
 #include "lua.h"
 
-#if defined(__x86_64__) || defined(_M_X64)
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
 #if defined(_MSC_VER)
 #include <intrin.h>
 #else
 #include <x86intrin.h>
 #endif
-#define SLUA_QUANTA_TSC_X64 1
+#define SLUA_QUANTA_TSC_X86 1
 #elif defined(__aarch64__) && !defined(_MSC_VER)
 #define SLUA_QUANTA_TSC_ARM64 1
 #endif
 
-#if defined(SLUA_QUANTA_TSC_X64) || defined(SLUA_QUANTA_TSC_ARM64)
+#if defined(SLUA_QUANTA_TSC_X86) || defined(SLUA_QUANTA_TSC_ARM64)
 #define SLUA_QUANTA_TSC 1
 #endif
 
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#else
+#include <pthread.h>
+#include <sched.h>
+#if defined(__linux__)
+#include <cerrno>
+#include <sys/resource.h>
+#endif
+#endif
+
+LUAU_FASTFLAGVARIABLE(SLuaElevateWatchdogPriority)
+
 namespace Luau
 {
 namespace Executor
 {
 
-#if defined(SLUA_QUANTA_TSC_X64)
+#if defined(SLUA_QUANTA_TSC_X86)
 static inline uint64_t read_tsc()
 {
     // Shouldn't need a fence.
@@ -104,5 +131,232 @@ lua_clockProvider resolveDefaultQuantaClock()
 #endif
 }
 
+QuantaWatchdog::~QuantaWatchdog() = default;
+
+namespace
+{
+
+class ImmediateQuantaWatchdog final : public QuantaWatchdog
+{
+public:
+    using QuantaWatchdog::QuantaWatchdog;
+
+    void arm(lua_Callbacks* target, double /* deadline */) override
+    {
+        mTarget = target;
+        fireNow();
+    }
+
+    void disarm() override {}
+
+    void fireNow() override
+    {
+        LUAU_ASSERT(mTarget != nullptr);
+        mTarget->interrupt = mHandler;
+    }
+
+    bool clearIfArmed() override
+    {
+        // The install always stands: the resident handler is the mechanism.
+        return false;
+    }
+
+private:
+    lua_Callbacks* mTarget = nullptr;
+};
+
+// How far ahead of the deadline the watch loop delivers its fire.
+// Allows some slop to
+constexpr double kWatchdogFireLead = 50e-6;  // 50us
+
+// Best-effort hoist of the watch loop above the timesharing class, so a
+// deadline wakeup preempts a busy script thread immediately instead of
+// waiting out the kernel's wakeup-preemption granularity (multi-ms against
+// a spinning peer, enough to draw false punishments). Failure is survivable
+// -- fires still happen, just late -- but the outcome must be logged, or
+// "the flag didn't help" is indistinguishable from a silent EPERM.
+void elevate_watchdog_priority()
+{
+#if defined(_WIN32)
+    if (SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
+    {
+        logInfo("QuantaWatchdog", "Watchdog thread priority raised to TIME_CRITICAL");
+        return;
+    }
+    logWarn("QuantaWatchdog", "Watchdog priority elevation failed: SetThreadPriority error %lu", GetLastError());
+#else
+    // The lowest RT priority is enough: the goal is class-based wakeup
+    // preemption over SCHED_OTHER threads, not competition within RT.
+    sched_param param = {};
+    param.sched_priority = sched_get_priority_min(SCHED_RR);
+    int rr_err = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
+    if (rr_err == 0)
+    {
+        logInfo("QuantaWatchdog", "Watchdog thread scheduling class raised to SCHED_RR");
+        return;
+    }
+#if defined(__linux__)
+    // SCHED_RR needs CAP_SYS_NICE/RLIMIT_RTPRIO; a negative nice at least
+    // lowers the wakeup-preemption bar. who == 0 targets the calling thread
+    // under NPTL.
+    if (setpriority(PRIO_PROCESS, 0, -10) == 0)
+    {
+        logInfo("QuantaWatchdog", "Watchdog thread niced to -10 (SCHED_RR unavailable, errno %d)", rr_err);
+        return;
+    }
+    logWarn("QuantaWatchdog", "Watchdog priority elevation failed: SCHED_RR errno %d, setpriority errno %d", rr_err, errno);
+#else
+    logWarn("QuantaWatchdog", "Watchdog priority elevation failed: SCHED_RR errno %d", rr_err);
+#endif
+#endif
+}
+
+class ThreadedQuantaWatchdog final : public QuantaWatchdog
+{
+public:
+    ThreadedQuantaWatchdog(InterruptCallback handler, lua_clockProvider quanta_clock)
+        : QuantaWatchdog(handler)
+        , mQuantaClock(quanta_clock)
+    {
+        mThread = std::thread([this] { watch(); });
+    }
+
+    ~ThreadedQuantaWatchdog() override
+    {
+        {
+            std::lock_guard<std::mutex> guard(mMutex);
+            mExit = true;
+        }
+        mCondition.notify_one();
+        mThread.join();
+    }
+
+    ThreadedQuantaWatchdog(const ThreadedQuantaWatchdog&) = delete;
+    ThreadedQuantaWatchdog& operator=(const ThreadedQuantaWatchdog&) = delete;
+
+    void arm(lua_Callbacks* target, double deadline) override
+    {
+        // The null store must precede the armed publish below: stored after,
+        // a fire delivered in between would be wiped with the window's
+        // one-shot already spent, leaving the window unpreemptable.
+        target->interrupt = nullptr;
+
+        {
+            std::lock_guard<std::mutex> guard(mMutex);
+            // Run windows are serial per provisioner, and every path to a new
+            // begin passes through disarm (or a delivered fire), so an armed
+            // slot here means concurrent windows -- which would silently
+            // overwrite this deadline and lose the other window's preemption.
+            LUAU_ASSERT(!mArmed);
+            mTarget = target;
+            mDeadline = deadline;
+            mArmed = true;
+        }
+        // The watch loop sleeps indefinitely while unarmed (and on a stale
+        // deadline after a disarm), so every arm must wake it. Notified
+        // outside the lock so the woken thread doesn't stall on it.
+        mCondition.notify_one();
+    }
+
+    void disarm() override
+    {
+        std::lock_guard<std::mutex> guard(mMutex);
+        mArmed = false;
+    }
+
+    void fireNow() override
+    {
+        std::lock_guard<std::mutex> guard(mMutex);
+        // Unarmed mid-window means the deadline fire was already delivered,
+        // so the handler is resident and there is nothing to add. The lock
+        // makes mTarget safe to read from a cross-thread producer and orders
+        // us against the fire.
+        if (mArmed)
+            mTarget->interrupt = mHandler;
+    }
+
+    bool clearIfArmed() override
+    {
+        std::lock_guard<std::mutex> guard(mMutex);
+        // The fire clears mArmed under this same mutex, so armed means the
+        // fire is still coming and will re-install; unarmed means the install
+        // being questioned IS the fire, and it must stand.
+        if (!mArmed)
+            return false;
+        mTarget->interrupt = nullptr;
+        return true;
+    }
+
+    WatchdogStats getStats() override
+    {
+        std::lock_guard<std::mutex> guard(mMutex);
+        return mStats;
+    }
+
+private:
+    void watch()
+    {
+        if (FFlag::SLuaElevateWatchdogPriority)
+            elevate_watchdog_priority();
+
+        std::unique_lock<std::mutex> lock(mMutex);
+        while (!mExit)
+        {
+            if (!mArmed)
+            {
+                // Nothing scheduled: block until an arm (or exit) notifies.
+                // A disarm doesn't notify, so this can also be reached by a
+                // stale deadline expiring after its window closed -- harmless,
+                // we just go back to sleep here.
+                mCondition.wait(lock);
+                continue;
+            }
+
+            double remaining = mDeadline - mQuantaClock(nullptr);
+            if (remaining <= kWatchdogFireLead)
+            {
+                // Deliver the one-shot while holding the lock, so it can
+                // only target the currently-armed window's VM. The VM
+                // reads the pointer unsynchronized by design (lua.h's
+                // interrupt contract).
+                mTarget->interrupt = mHandler;
+                mArmed = false;
+
+                double lateness = kWatchdogFireLead - remaining;
+                mStats.latenessSum += lateness;
+                mStats.latenessMin = mStats.fires == 0 ? lateness : std::min(mStats.latenessMin, lateness);
+                mStats.latenessMax = std::max(mStats.latenessMax, lateness);
+                mStats.fires++;
+                continue;
+            }
+            mCondition.wait_for(lock, std::chrono::duration<double>(remaining - kWatchdogFireLead));
+        }
+    }
+
+    lua_clockProvider mQuantaClock = nullptr;
+
+    std::mutex mMutex;
+    std::condition_variable mCondition;
+    lua_Callbacks* mTarget = nullptr;
+    double mDeadline = 0.0;
+    WatchdogStats mStats;
+    bool mArmed = false;
+    bool mExit = false;
+
+    std::thread mThread;
+};
+
+} // namespace
+
+std::unique_ptr<QuantaWatchdog> createImmediateQuantaWatchdog(InterruptCallback handler)
+{
+    return std::make_unique<ImmediateQuantaWatchdog>(handler);
+}
+
+std::unique_ptr<QuantaWatchdog> createQuantaWatchdog(InterruptCallback handler, lua_clockProvider quanta_clock)
+{
+    return std::make_unique<ThreadedQuantaWatchdog>(handler, quanta_clock);
+}
+
 } // namespace Executor
 } // namespace Luau
diff --git a/Executor/src/Script.cpp b/Executor/src/Script.cpp
index c046c472..b4cf4a51 100644
--- a/Executor/src/Script.cpp
+++ b/Executor/src/Script.cpp
@@ -8,6 +8,7 @@
 #include "lualib.h"
 #include "llsl.h"
 
+#include "lgc.h"
 #include "lstate.h"
 
 namespace Luau
@@ -129,13 +130,34 @@ Script::Script(const std::shared_ptr<IImage>& image, const ScriptConfig& config)
     setTimerEventCb = callbacks.setTimerEventCb;
     eventHandlerRegistrationCb = callbacks.eventHandlerRegistrationCb;
     mQuantaClockProvider = callbacks.quantaClockProvider;
+
+    // Non-null from the environment's existence: the provisioner built the
+    // watchdog when it built the first environment.
+    mWatchdog = image->getProvisioner().getQuantaWatchdog();
+    LUAU_ASSERT(mWatchdog != nullptr);
+    mCallbacks = lua_callbacks(image->getEnvironment().getBaseState());
 }
 
 Script::~Script()
 {
     LUAU_ASSERT(!mHandlerState && !mInExecution);
-    // Nothing to do: mInstance releases its anchor before mImage lets go of
-    // the VM, by member declaration order.
+    // A teardown mid-window must disarm (a later fire would write into a
+    // lua_Callbacks that dies with the VM) and unpark the GC of the
+    // environment's VM, which outlives us.
+    // TODO: Ech. Yeah, we want more RAII to improve discipline around keeping
+    //  these all synced.
+    if (mRunWindowOpen)
+    {
+        mWatchdog->disarm();
+        if (mInstance)
+        {
+            global_State* global = mInstance.thread()->global;
+            LUAU_ASSERT(global->GCthreshold == SIZE_MAX);
+            global->GCthreshold = mSavedGCThreshold;
+        }
+    }
+    // mInstance releases its anchor before mImage lets go of the VM, by
+    // member declaration order.
 }
 
 // static
@@ -190,7 +212,6 @@ bool Script::loadDefaultState()
     mMandatoryYieldRaised = false;
     mMandatoryDeadline = 0.0;
     mExcludedTime = 0.0;
-    mGCStepInFlight = false;
     mSleep = 0.0f;
     // in LSL we treat the main function as complete, since it runs
     // while loading the image.
@@ -266,20 +287,70 @@ void Script::beginRunWindow(double quanta)
 {
     LUAU_ASSERT(mInstance);
     LUAU_ASSERT(!mRunWindowOpen);
+    // Sleep is a window output; the host banks and zeroes it before
+    // scheduling us again.
+    LUAU_ASSERT(mSleep == 0.0f);
+    // Force-yield is a mid-window mechanism: a host that knows a script is
+    // reset/disabled shouldn't be scheduling a window for it at all.
+    LUAU_ASSERT(!mForceYield);
+    lua_State* instance = mInstance.thread();
+
     mRunWindowOpen = true;
     mYieldDue = false;
     mMandatoryYieldRaised = false;
     mMandatoryDeadline = 0.0;
     mExcludedTime = 0.0;
-    mGCStepInFlight = false;
-    mWindowStart = mQuantaClockProvider(mInstance.thread());
+    mWindowStart = mQuantaClockProvider(instance);
     mQuanta = quanta;
+
+    // Park the GC for the window; endRunWindow() pays down the debt
+    global_State* global = instance->global;
+    mSavedGCThreshold = global->GCthreshold;
+    global->GCthreshold = SIZE_MAX;
+
+    mWatchdog->arm(mCallbacks, mWindowStart + quanta);
 }
 
 void Script::endRunWindow()
 {
     LUAU_ASSERT(mRunWindowOpen);
     mRunWindowOpen = false;
+    // A force-yield's life ends with its window; the host re-asserts it if
+    // it still wants one.
+    mForceYield = false;
+
+    mWatchdog->disarm();
+    if (mInstance)
+    {
+        // Restore before stepping: the pacer computes its debt from the
+        // threshold. This is the window's deferred GC work, on host time.
+        lua_State* instance = mInstance.thread();
+        global_State* global = instance->global;
+        // Anything that rewrote the threshold mid-window (a lua_gc call, a
+        // new engine path) would corrupt the parking dance; catch it here.
+        LUAU_ASSERT(global->GCthreshold == SIZE_MAX);
+        global->GCthreshold = mSavedGCThreshold;
+        while (luaC_needsGC(instance))
+            luaC_step(instance, false);
+    }
+}
+
+void Script::setSleep(float sleep)
+{
+    mSleep = sleep;
+    // A condition set mid-window must run the handler at the next safepoint.
+    // Outside a window our safepoints aren't live and the member alone is
+    // enough: a force-yield is read by the next begin's flush branch, and a
+    // sleep is the host's to serve before it schedules us again.
+    if (sleep > 0.0f && mRunWindowOpen)
+        mWatchdog->fireNow();
+}
+
+void Script::setForceYield(bool force)
+{
+    mForceYield = force;
+    if (force && mRunWindowOpen)
+        mWatchdog->fireNow();
 }
 
 RunResult Script::callEventHandler(int lsl_state, const char* event_name, PushArgsFn pushArgs, void* push_args_ctx)
@@ -715,21 +786,11 @@ void Script::interruptHandler(lua_State* L, int gc)
     if (!execute || !execute->mInExecution || execute->mHandlerState == nullptr)
         return;
 
-    // Keep track of GC phases so we can discount their cost
+    // GC is parked for every run window, so a GC bracket can't arrive
+    // mid-execution; the end-of-window catch-up steps return at the gate
+    // above.
     if (gc >= 0)
-    {
-        if (!execute->mGCStepInFlight)
-        {
-            execute->mGCStepInFlight = true;
-            execute->mGCStepStart = execute->mQuantaClockProvider(L);
-        }
-        else
-        {
-            execute->mGCStepInFlight = false;
-            execute->mExcludedTime += execute->mQuantaClockProvider(L) - execute->mGCStepStart;
-        }
         return;
-    }
 
     // This particular handler had better be _active_, or we're somehow triggering
     // interrupts through pushing handler arguments or something like that.
@@ -746,6 +807,13 @@ void Script::interruptHandler(lua_State* L, int gc)
     {
         execute->tryYield(L, elapsed);
     }
+    else
+    {
+        // A spurious install (the deadline hadn't actually passed): uninstall
+        // through the watchdog, where a bare store could wipe a concurrent
+        // fire and spend the window's one-shot.
+        execute->mWatchdog->clearIfArmed();
+    }
 }
 
 // static
diff --git a/VM/src/llsl.cpp b/VM/src/llsl.cpp
index 8936facb..52dffcdb 100644
--- a/VM/src/llsl.cpp
+++ b/VM/src/llsl.cpp
@@ -1182,7 +1182,7 @@ static int push_uuid_common(lua_State *L, const char *str, size_t len, bool comp
         {
             // See `lgctraverse.cpp` for reasoning behind this
             const size_t uuid_size = 4;
-            if (LUAU_LIKELY(g->GCthreshold != SIZE_MAX) && g->cb.beforeallocate(L, 0, uuid_size))
+            if (g->cb.beforeallocate(L, 0, uuid_size))
                 luaD_throw(L, LUA_ERRMEM);
         }
 
diff --git a/VM/src/lmem.cpp b/VM/src/lmem.cpp
index 0aeae0b8..7c44589c 100644
--- a/VM/src/lmem.cpp
+++ b/VM/src/lmem.cpp
@@ -509,8 +509,7 @@ void* luaM_new_(lua_State* L, size_t nsize, uint8_t memcat)
     // ServerLua: enforce memory allocation limits in user-owned memcats
     if (LUAU_LIKELY(!!g->cb.beforeallocate) && memcat >= LUA_FIRST_USER_MEMCAT)
     {
-        // But don't do invoke the hook if GC is disabled
-        if (LUAU_LIKELY(g->GCthreshold != SIZE_MAX) && g->cb.beforeallocate(L, 0, nsize))
+        if (g->cb.beforeallocate(L, 0, nsize))
             luaD_throw(L, LUA_ERRMEM);
     }
 
@@ -548,7 +547,7 @@ GCObject* luaM_newgco_(lua_State* L, size_t nsize, uint8_t memcat)
     // ServerLua: enforce memory allocation limits in user-owned memcats
     if (LUAU_LIKELY(!!g->cb.beforeallocate) && memcat >= LUA_FIRST_USER_MEMCAT)
     {
-        if (LUAU_LIKELY(g->GCthreshold != SIZE_MAX) && g->cb.beforeallocate(L, 0, nsize))
+        if (g->cb.beforeallocate(L, 0, nsize))
             luaD_throw(L, LUA_ERRMEM);
     }
 
@@ -696,7 +695,7 @@ void* luaM_realloc_(lua_State* L, void* block, size_t osize, size_t nsize, uint8
     // ServerLua: enforce memory allocation limits in user-owned memcats
     if (LUAU_LIKELY(!!g->cb.beforeallocate) && memcat >= LUA_FIRST_USER_MEMCAT)
     {
-        if (LUAU_LIKELY(g->GCthreshold != SIZE_MAX) && g->cb.beforeallocate(L, osize, nsize))
+        if (g->cb.beforeallocate(L, osize, nsize))
             luaD_throw(L, LUA_ERRMEM);
     }
 
diff --git a/VM/src/lstring.cpp b/VM/src/lstring.cpp
index 04ed8b33..006e2d74 100644
--- a/VM/src/lstring.cpp
+++ b/VM/src/lstring.cpp
@@ -136,7 +136,7 @@ static TString* findstring(lua_State * L, const char *data, unsigned int len, un
             {
                 // See `lgctraverse.cpp` for reasoning behind this
                 const size_t str_size = 16 + el->len;
-                if (LUAU_LIKELY(g->GCthreshold != SIZE_MAX) && g->cb.beforeallocate(L, 0, str_size))
+                if (g->cb.beforeallocate(L, 0, str_size))
                     luaD_throw(L, LUA_ERRMEM);
             }
             return el;
diff --git a/autobuild.xml b/autobuild.xml
index b52f19e7..13c41298 100644
--- a/autobuild.xml
+++ b/autobuild.xml
@@ -180,6 +180,7 @@
           <key>manifest</key>
           <array>
             <string>lib</string>
+            <string>bin</string>
           </array>
           <key>name</key>
           <string>darwin</string>
diff --git a/build-cmd.sh b/build-cmd.sh
index 30472602..31779394 100755
--- a/build-cmd.sh
+++ b/build-cmd.sh
@@ -84,6 +84,7 @@ pushd "$top"
             cp -v "Release/Luau.Common.lib" "$stage/lib/release/"
 
             cp -v Release/slua.exe "$stage/bin/"
+            cp -v Release/slua-harness.exe "$stage/bin/"
         ;;
         darwin*|linux*)
             # Optimized builds use the inherited release flags as-is, any local
@@ -111,6 +112,7 @@ pushd "$top"
             cp -v "libLuau.Executor.a" "$stage/lib/release"
 
             cp -v "slua" "$stage/bin/"
+            cp -v "slua-harness" "$stage/bin/"
 
             # Run the conformance test for good measure
             "${stage}/build/Luau.Conformance"
diff --git a/tests/SLConformance.test.cpp b/tests/SLConformance.test.cpp
index 6a17befb..807868aa 100644
--- a/tests/SLConformance.test.cpp
+++ b/tests/SLConformance.test.cpp
@@ -172,6 +172,10 @@ static int memoryLimitCallback(lua_State *L, size_t osize, size_t nsize)
     L = lua_mainthread(L);
     RuntimeState* state = (RuntimeState*)L->userdata;
 
+    // Bail if GC is disabled (host bulk work like luau_load)
+    if (L->global->GCthreshold == SIZE_MAX)
+        return 0;
+
     // This is a net shrink in memory, not relevant for our limiting logic. We can't assume that
     // memory being freed has anything to do with us, given that the GC can work on things unrelated
     // to the currently executing task.
diff --git a/tests/SLExecutor.test.cpp b/tests/SLExecutor.test.cpp
index c961f26e..c02d1585 100644
--- a/tests/SLExecutor.test.cpp
+++ b/tests/SLExecutor.test.cpp
@@ -59,6 +59,9 @@ struct TestProvisioner : Provisioner<>
         callbacks.setTimerEventCb = set_timer_event;
         callbacks.eventHandlerRegistrationCb = handler_registration;
         callbacks.quantaClockProvider = quanta_clock;
+        // A stepped fake clock needs synchronous arming; a watchdog thread
+        // can't watch a clock only the test advances.
+        callbacks.synchronousQuantaArming = true;
         callbacks.populateEnvironment = populate_environment;
         return callbacks;
     }
@@ -71,9 +74,6 @@ struct TestProvisioner : Provisioner<>
         lua_pushcfunction(L, lua_break, "preempt");
         lua_setglobal(L, "preempt");
 
-        lua_pushcfunction(L, simulate_gc_step, "simulate_gc_step");
-        lua_setglobal(L, "simulate_gc_step");
-
         lua_pushcfunction(L, jump_clock, "jump_clock");
         lua_setglobal(L, "jump_clock");
     }
@@ -106,19 +106,6 @@ struct TestProvisioner : Provisioner<>
         return static_cast<TestProvisioner&>(executor->getProvisioner());
     }
 
-    // Invoke the GC callbacks as if GC is happening, without actually triggering it.
-    static int simulate_gc_step(lua_State* L)
-    {
-        double cost = luaL_checknumber(L, 1);
-        int post_state = luaL_optinteger(L, 2, 0);
-        void (*interrupt)(lua_State*, int) = lua_callbacks(L)->interrupt;
-        REQUIRE((interrupt != nullptr));
-        interrupt(L, 0);
-        of(L).clock += cost;
-        interrupt(L, post_state);
-        return 0;
-    }
-
     // An engine pause the executor has no bracket for: time passes with no
     // exclusion banked, as if the host got descheduled mid-execution.
     static int jump_clock(lua_State* L)
@@ -206,6 +193,9 @@ static RunResult resumeToCompletion(Script& exec, double quanta, HandlerRunStatu
     RunResult result{HandlerRunStatus::Preempted, 0};
     while (result.status == HandlerRunStatus::Preempted)
     {
+        // Bank-and-zero like a real host: a window must not begin with a
+        // pending sleep, and punishments can land one mid-loop.
+        exec.setSleep(0.0f);
         result = resumeRaw(exec, quanta);
         if (preemptions && result.status == HandlerRunStatus::Preempted)
             ++(*preemptions);
@@ -866,10 +856,11 @@ TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor weak references die before OoM")
     REQUIRE(script->loadDefaultState());
 
     // Keep the real GC from completing a cycle on its own so any weak
-    // clearing is attributable to the memory limit callback's heap walk.
-    // Don't use LUA_GCSTOP, it disables the beforeallocate callback entirely.
-    lua_gc(script->getInstanceState(), LUA_GCSETGOAL, 100000);
+    // clearing is attributable to the memory limit callback's heap walk. The
+    // callback stays live under LUA_GCSTOP: it gates on execution state, not
+    // the GC threshold.
     lua_gc(script->getInstanceState(), LUA_GCCOLLECT, 0);
+    lua_gc(script->getInstanceState(), LUA_GCSTOP, 0);
 
     resume(*script);
     CHECK(script->getFaultKind() == FaultKind::None);
@@ -1074,66 +1065,6 @@ TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor mandatory yield kill")
 
 TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor engine pauses are not charged")
 {
-    SUBCASE("unyieldable region survives a GC-inflated window")
-    {
-        // A long GC step lands while execution is inside a metamethod frame,
-        // where a yield can't be injected. GC isn't the executing code's fault,
-        // necessarily, so we discount it against their runtime.
-        TestScript ts(R"(
-            local mt = {}
-            mt.__index = function(t, k)
-                simulate_gc_step(10, 2)
-                local total = 0
-                for i = 1, 20 do
-                    total += i
-                end
-                return total
-            end
-            local obj = setmetatable({}, mt)
-            print(obj.missing)
-        )");
-        ts.loadDefaultState();
-        Script& exec = ts.exec;
-
-        // Charged time only accrues one clock step per interrupt reading, so
-        // it stays far below the punishment thresholds against a 5ms quanta.
-        ts.host.clock_step = 0.0001;
-        resumeToCompletion(exec, 0.005, HandlerRunStatus::Ok);
-        CHECK(exec.getFaultKind() == FaultKind::None);
-        CHECK(exec.getSleep() == 0.0f);
-        checkCapture(ts.host.printed, {"210"});
-    }
-
-    SUBCASE("GC-inflated time is not punished, preemption stays on wall time")
-    {
-        TestScript ts(R"(
-            simulate_gc_step(10)
-            local total = 0
-            for i = 1, 100 do
-                total += i
-            end
-            print("finished")
-        )");
-        ts.loadDefaultState();
-        Script& exec = ts.exec;
-
-        // Wall elapsed is ~10s against a 50ms quanta, so the first yieldable
-        // interrupt still preempts, but the charged handful of clock steps
-        // stays under the 3x threshold, so no sleep punishment lands.
-        ts.host.clock_step = 0.001;
-        resume(exec, 0.05, HandlerRunStatus::Preempted);
-        CHECK(exec.isYieldDue());
-        CHECK(exec.getSleep() == 0.0f);
-        // The banked exclusion is readable until the next window resets it
-        CHECK(exec.getExcludedTime() >= 10.0);
-
-        // Zero out the sleep so we don't deadlock the suite if the earlier
-        // getSleep() == 0.0f check didn't hold.
-        exec.setSleep(0.0f);
-        resumeToCompletion(exec, 0.05);
-        checkCapture(ts.host.printed, {"finished"});
-    }
-
     SUBCASE("baseline heap walk feeds the exclusion accumulator")
     {
         // Trigger a ton of allocations so the lua_userthreadgc() check kicks
@@ -1254,39 +1185,6 @@ TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor mandatory yield grace")
         CHECK(ts.host.printed.empty());
     }
 
-    SUBCASE("excluded time does not consume the grace window")
-    {
-        // The grace deadline must be measured in charged time: a GC step
-        // landing after the deadline is armed must not burn the window.
-        TestScript ts(R"(
-            local mt = {}
-            mt.__index = function(t, k)
-                jump_clock(10)
-                local total = 0
-                for i = 1, 5 do
-                    total += i
-                end
-                simulate_gc_step(10)
-                for i = 1, 20 do
-                    total += i
-                end
-                return total
-            end
-            local obj = setmetatable({}, mt)
-            print(obj.missing)
-        )");
-        ts.loadDefaultState();
-        Script& exec = ts.exec;
-
-        ts.host.clock_step = 0.000001;
-        resume(exec, 0.005, HandlerRunStatus::Preempted);
-        CHECK(exec.getFaultKind() == FaultKind::None);
-        CHECK(exec.getSleep() > 0.0f);
-
-        exec.setSleep(0.0f);
-        resumeToCompletion(exec, 0.005);
-        checkCapture(ts.host.printed, {"225"});
-    }
 }
 
 TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor pending sleep preempts")
@@ -1300,16 +1198,68 @@ TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor pending sleep preempts")
     )");
     ts.loadDefaultState();
 
+    // A sleep set mid-window (the producer installs the handler) forces the
+    // next interrupt to yield
+    ts.exec.beginRunWindow(1.0);
     ts.exec.setSleep(1.0f);
-    resume(ts.exec, 1.0, HandlerRunStatus::Preempted);
+    RunResult result = ts.exec.resumeEventHandler();
+    ts.exec.endRunWindow();
+    REQUIRE(result.status == HandlerRunStatus::Preempted);
     CHECK(ts.exec.isYieldDue());
     // Sleep-driven preemption carries no punishment
     CHECK(ts.exec.getSleep() == 1.0f);
 
-    ts.exec.setSleep(0.0f);
     resumeToCompletion(ts.exec, 1.0);
 }
 
+TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor watchdog preempts a busy script")
+{
+    // All-null callbacks: the provisioner resolves the real quanta clock and
+    // stands up the threaded watchdog.
+    TestProvisioner host{HostCallbacks{}};
+    std::shared_ptr<Script> script = host.provisionScript(makeImageConfig(Luau::compile(R"(
+        local total = 0
+        for i = 1, 1000000000 do
+            total += i
+        end
+    )")), makeScriptConfig());
+    REQUIRE(script != nullptr);
+    REQUIRE(script->loadDefaultState());
+
+    // A 1e9-iteration loop can't finish inside 2ms, so preemption is the only
+    // way out -- no timing flakiness.
+    script->beginRunWindow(0.002);
+    RunResult result = script->resumeEventHandler();
+    script->endRunWindow();
+    REQUIRE(result.status == HandlerRunStatus::Preempted);
+    CHECK(script->isYieldDue());
+    // The close unparked the GC and paid down the window's debt
+    CHECK(script->getInstanceState()->global->GCthreshold < SIZE_MAX);
+}
+
+TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor watchdog honors a mid-window sleep")
+{
+    TestProvisioner host{HostCallbacks{}};
+    std::shared_ptr<Script> script = host.provisionScript(makeImageConfig(Luau::compile(R"(
+        local total = 0
+        for i = 1, 1000000000 do
+            total += i
+        end
+    )")), makeScriptConfig());
+    REQUIRE(script != nullptr);
+    REQUIRE(script->loadDefaultState());
+
+    // Quanta generous enough that only the sleep can preempt: the producer
+    // store installs the handler and the first safepoint yields, no clocks
+    // involved.
+    script->beginRunWindow(10.0);
+    script->setSleep(0.5f);
+    RunResult result = script->resumeEventHandler();
+    script->endRunWindow();
+    REQUIRE(result.status == HandlerRunStatus::Preempted);
+    CHECK(script->isYieldDue());
+}
+
 TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor memory limit")
 {
     std::string bytecode = Luau::compile(R"(
@@ -1402,20 +1352,23 @@ TEST_CASE_FIXTURE(SLuaFixture, "SLExecutor pushes args outside a resume")
 
     resume(ts.exec);
 
-    // A pending forced yield makes the first interrupt mandatory, so one reaching
-    // the marshalling would kill the script rather than pass unnoticed. The first
-    // one that does fire lands in `handleEvent`, which is yieldable.
+    // A forced yield makes the first interrupt mandatory, so one reaching the
+    // marshalling would kill the script rather than pass unnoticed. The first
+    // one that does fire lands in `handleEvent`, which is yieldable. Driven
+    // raw because the flag is mid-window state; begin asserts it's clear.
+    ts.exec.beginRunWindow(1.0);
     ts.exec.setForceYield(true);
-
-    RunResult result = dispatchRaw(ts.exec, 0, "dataserver", [](lua_State* handler, void*) {
+    RunResult result = ts.exec.callEventHandler(0, "dataserver", [](lua_State* handler, void*) {
         luaSL_pushuuidstring(handler, "8d4a1e26-3f2b-4c7d-9a15-6e0b3c8f2d41");
         lua_pushstring(handler, "payload");
     });
+    ts.exec.endRunWindow();
     REQUIRE(result.status == HandlerRunStatus::Preempted);
     CHECK(ts.exec.getFaultKind() == FaultKind::None);
     CHECK(ts.host.printed.empty());
 
-    ts.exec.setForceYield(false);
+    // No setForceYield(false): endRunWindow() consumed the flag, and this
+    // completion depends on that -- a leaked flag would flush every window.
     resumeToCompletion(ts.exec, 1.0);
     checkCapture(ts.host.printed, {"uuid/payload"});
 }
@@ -1979,6 +1932,7 @@ struct StatefulProvisioner : Provisioner<StatefulScript>
     {
         HostCallbacks callbacks;
         callbacks.quantaClockProvider = quanta_clock;
+        callbacks.synchronousQuantaArming = true;
         return callbacks;
     }