@@ -670,7 +670,6 @@ async function executeTask(request, executionId) {
   // sweep regardless of where execution throws.
   let nextTimerId = 1
   const timers = new Map()
-  let activeIntervals = 0
   const cleanupTimers = () => {
     for (const entry of timers.values()) {
       try {
@@ -682,7 +681,6 @@ async function executeTask(request, executionId) {
       } catch {}
     }
     timers.clear()
-    activeIntervals = 0
   }
 
   // Phase timings (ms). Populated inline during execution; returned in
@@ -768,19 +766,35 @@ async function executeTask(request, executionId) {
     }
 
     // Thrown into the isolate, so the stack must not carry worker host frames.
-    const rejectTimer = (fnRef, message) => {
+    const timerLimitError = (fnRef, message) => {
       try {
         fnRef.release()
       } catch {}
       const error = new RangeError(message)
       error.stack = `RangeError: ${message}`
-      throw error
+      return error
     }
-
-    const setTimeoutRef = new ivm.Reference((fnRef, msRef) => {
+    const admitTimer = (fnRef, recurring) => {
       if (timers.size >= MAX_PENDING_TIMERS) {
-        rejectTimer(fnRef, `Too many pending timers (limit ${MAX_PENDING_TIMERS} per execution)`)
+        throw timerLimitError(
+          fnRef,
+          `Too many pending timers (limit ${MAX_PENDING_TIMERS} per execution)`
+        )
       }
+      if (!recurring) return
+      let activeIntervals = 0
+      for (const entry of timers.values()) {
+        if (entry.recurring && ++activeIntervals >= MAX_ACTIVE_INTERVALS) {
+          throw timerLimitError(
+            fnRef,
+            `Too many active intervals (limit ${MAX_ACTIVE_INTERVALS} per execution)`
+          )
+        }
+      }
+    }
+
+    const setTimeoutRef = new ivm.Reference((fnRef, msRef) => {
+      admitTimer(fnRef, false)
       const id = nextTimerId++
       const delay = Math.max(0, Math.min(Number(unwrapPrimitive(msRef)) || 0, timeoutMs))
       const nodeTimer = setTimeout(() => {
@@ -815,21 +829,12 @@ async function executeTask(request, executionId) {
         entry.fnRef.release()
       } catch {}
       timers.delete(key)
-      if (entry.recurring) activeIntervals--
     })
     releaseables.push(clearTimeoutRef)
     await jail.set('__clearTimeoutRef', clearTimeoutRef)
 
     const setIntervalRef = new ivm.Reference((fnRef, msRef) => {
-      if (timers.size >= MAX_PENDING_TIMERS) {
-        rejectTimer(fnRef, `Too many pending timers (limit ${MAX_PENDING_TIMERS} per execution)`)
-      }
-      if (activeIntervals >= MAX_ACTIVE_INTERVALS) {
-        rejectTimer(
-          fnRef,
-          `Too many active intervals (limit ${MAX_ACTIVE_INTERVALS} per execution)`
-        )
-      }
+      admitTimer(fnRef, true)
       const id = nextTimerId++
       const delay = Math.max(1, Math.min(Number(unwrapPrimitive(msRef)) || 1, timeoutMs))
       const nodeTimer = setInterval(() => {
@@ -843,7 +848,6 @@ async function executeTask(request, executionId) {
         }
       }, delay)
       timers.set(id, { nodeTimer, fnRef, recurring: true })
-      activeIntervals++
       return id
     })
     releaseables.push(setIntervalRef)
 
@@ -87,6 +87,8 @@ type ControllableReadyProc = {
   spawn: SpawnFactory
   dispatched: Promise<void>
   release: (result?: unknown) => void
+  /** Every message the pool sent the worker, in order. */
+  sent: Array<{ type?: string; executionId?: number }>
 }
 
 /**
@@ -104,11 +106,13 @@ function createControllableReadyProc(): ControllableReadyProc {
   })
   let proc: MockProc | undefined
   let lastExecutionId = 0
+  const sent: ControllableReadyProc['sent'] = []
 
   const spawn: SpawnFactory = () => {
     const current = createBaseProc()
     current.send = (message: unknown) => {
       const msg = message as { type?: string; executionId?: number }
+      sent.push(msg)
       if (msg.type === 'execute') {
         lastExecutionId = msg.executionId ?? 0
         markDispatched()
@@ -128,7 +132,7 @@ function createControllableReadyProc(): ControllableReadyProc {
     })
   }
 
-  return { spawn, dispatched, release }
+  return { spawn, dispatched, release, sent }
 }
 
 function createReadyFetchProxyProc(fetchMessage: { url: string; optionsJson?: string }): MockProc {
@@ -337,17 +341,8 @@ describe('isolated-vm scheduler', () => {
   })
 
   it('disposes the worker execution when the host timeout fires', async () => {
-    const sent: Array<{ type?: string; executionId?: number }> = []
-    const hungWorker = () => {
-      const proc = createBaseProc()
-      proc.send = (message: unknown) => {
-        sent.push(message as { type?: string; executionId?: number })
-        return true
-      }
-      setImmediate(() => proc.emit('message', { type: 'ready' }))
-      return proc
-    }
-    const { executeInIsolatedVM } = await loadExecutionModule({ spawns: [hungWorker] })
+    const { spawn, sent } = createControllableReadyProc()
+    const { executeInIsolatedVM } = await loadExecutionModule({ spawns: [spawn] })
 
     const result = await executeInIsolatedVM({
       code: 'await new Promise(() => {})',
 
@@ -1233,6 +1233,15 @@ function spawnWorker(): Promise<WorkerInfo> {
  * Returns the ready worker with the fewest active executions that still
  * has capacity, or null if none available.
  */
+/** Asks the worker to dispose an execution's isolate, sweeping its timers and pending calls. */
+function sendCancel(workerInfo: WorkerInfo, executionId: number) {
+  try {
+    workerInfo.process.send({ type: 'cancel', executionId })
+  } catch (err) {
+    logger.warn('Failed to send cancel to worker', { err, workerId: workerInfo.id })
+  }
+}
+
 function selectWorker(): WorkerInfo | null {
   let best: WorkerInfo | null = null
   for (const w of workers.values()) {
@@ -1311,11 +1320,7 @@ function dispatchToWorker(
     workerInfo.pendingExecutions.delete(execId)
     // A never-settling promise escapes the isolate's own script timeout, so the worker
     // would otherwise keep the isolate and its timers alive until the worker retires.
-    try {
-      workerInfo.process.send({ type: 'cancel', executionId: execId })
-    } catch (err) {
-      logger.warn('Failed to send timeout cancel to worker', { err, workerId: workerInfo.id })
-    }
+    sendCancel(workerInfo, execId)
     workerInfo.activeExecutions--
     totalActiveExecutions--
     ownerState.activeExecutions = Math.max(0, ownerState.activeExecutions - 1)
@@ -1689,13 +1694,7 @@ export async function executeInIsolatedVM(
           const wi = workers.get(state.workerId)
           const pending = wi?.pendingExecutions.get(state.execId)
           if (pending) pending.cancelled = true
-          if (wi) {
-            try {
-              wi.process.send({ type: 'cancel', executionId: state.execId })
-            } catch (err) {
-              logger.warn('Failed to send cancel to worker', { err, workerId: state.workerId })
-            }
-          }
+          if (wi) sendCancel(wi, state.execId)
         }
         resolveWithRelease({
           result: null,
 
@@ -9,6 +9,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { sleep } from '@sim/utils/helpers'
 import { generateRandomBytes, generateRandomHex } from '@sim/utils/random'
+import type { IsolatedVMExecutionRequest } from '@/lib/execution/isolated-vm'
 
 /**
  * Runs the isolated-vm pool against a real `isolated-vm-host.cjs` over real
@@ -383,7 +384,14 @@ async function run() {
   const slowFetch = (ms: number) =>
     `const r = await fetch('http://127.0.0.1:${slowAddress.port}/?ms=${ms}'); return await r.text()`
 
-  const execute = (code: string, extra: { timeoutMs?: number; signal?: AbortSignal } = {}) =>
+  const execute = (
+    code: string,
+    extra: {
+      timeoutMs?: number
+      signal?: AbortSignal
+      task?: IsolatedVMExecutionRequest['task']
+    } = {}
+  ) =>
     executeInIsolatedVM(
       {
         code,
@@ -393,6 +401,7 @@ async function run() {
         timeoutMs: extra.timeoutMs ?? 10000,
         requestId: `e2e-${generateRandomHex(4)}`,
         ownerKey: 'e2e-owner',
+        task: extra.task,
       },
       { signal: extra.signal }
     )
@@ -500,14 +509,7 @@ async function run() {
   })
 
   const runTask = (code: string) =>
-    executeInIsolatedVM({
-      code,
-      params: {},
-      envVars: {},
-      contextVariables: {},
-      timeoutMs: 10000,
-      requestId: `e2e-${generateRandomHex(4)}`,
-      ownerKey: 'e2e-owner',
+    execute(code, {
       task: {
         id: 'e2e-timers',
         bundles: [],