fix(execution): abort local runs before the removal signal deadline can skip them

The signal deadline bounds only the Redis flag writes. Aborting a run this
process holds needs no Redis, so every execution is aborted first, even after
the deadline has passed. Corrects the ban's note on why a failed stop record is
logged: banning again records the stops again.

Author: waleedlatif1

apps/sim/lib/execution/removal-stop-records.test.ts

@@ -0,0 +1,32 @@
+/**
+ * An in-process run is stopped by aborting it here, which needs no Redis. Failure mode: the
+ * signal deadline passes before the Redis writes start, and the local runs are left going.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import {
+  registerManualExecutionAborter,
+  unregisterManualExecutionAborter,
+} from '@/lib/execution/manual-cancellation'
+import { signalExecutionStops } from '@/lib/execution/removal-stop-records'
+
+describe('signalling removed executions', () => {
+  it('aborts the runs this process holds even after the signal deadline has passed', async () => {
+    const abort = vi.fn()
+    registerManualExecutionAborter('execution-local', abort)
+    const deadline = new AbortController()
+    deadline.abort()
+
+    try {
+      await expect(
+        signalExecutionStops(
+          [{ executionId: 'execution-local', executionDeadlineAt: null }],
+          deadline.signal
+        )
+      ).resolves.toBe(1)
+    } finally {
+      unregisterManualExecutionAborter('execution-local', abort)
+    }
+
+    expect(abort).toHaveBeenCalledOnce()
+  })
+})

apps/sim/lib/execution/removal-stop-records.ts

@@ -193,8 +193,9 @@ export async function recordExecutionStops(
  * Sets the cancellation flag each execution's engine watches, and aborts the ones this process
  * runs, without the queue sweep or the retry the outbox event adds. Callers whose module graph
  * cannot load the delivery stop in-flight runs with it at once and leave the rest to the outbox
- * worker. Returns how many flags Redis refused or the deadline (`signal`, else
- * {@link SIGNAL_DEADLINE_MS}) left unsent; never throws.
+ * worker. The deadline (`signal`, else {@link SIGNAL_DEADLINE_MS}) bounds only the Redis writes;
+ * every execution this process runs is aborted first. Returns how many flags Redis refused or
+ * the deadline left unsent; never throws.
  *
  * Without Redis at all the flag is process-local by design (`markExecutionCancelled`) and a
  * retry from any process could reach no further, so that outcome does not count as refused.
@@ -203,6 +204,16 @@ export async function signalExecutionStops(
   executions: readonly Pick<PlannedExecutionStop, 'executionId' | 'executionDeadlineAt'>[],
   signal?: AbortSignal
 ): Promise<number> {
+  for (const { executionId } of executions) {
+    try {
+      abortManualExecution(executionId)
+    } catch (error) {
+      logger.warn('Failed to abort a local execution being stopped', {
+        executionId,
+        error: describeError(error),
+      })
+    }
+  }
   const deadline = signal ?? AbortSignal.timeout(SIGNAL_DEADLINE_MS)
   let refused = 0
   await mapWithConcurrency(executions, SIGNAL_CONCURRENCY, async (execution) => {
@@ -222,14 +233,6 @@ export async function signalExecutionStops(
         error: describeError(error),
       })
     }
-    try {
-      abortManualExecution(execution.executionId)
-    } catch (error) {
-      logger.warn('Failed to abort a local execution being stopped', {
-        executionId: execution.executionId,
-        error: describeError(error),
-      })
-    }
   })
   return refused
 }

apps/sim/lib/workflows/lifecycle.ts

@@ -324,8 +324,9 @@ export async function disableUserResources(userId: string): Promise<void> {
   /**
    * Records the workspaces' stops and signals their in-flight runs; the recorded stop's queue
    * sweep and retries run in the outbox worker, since this module sits in page graphs that must
-   * not load that delivery. Logged, not thrown: the ban and archives have committed, and a retry
-   * would find no unarchived workspace to stop.
+   * not load that delivery. Logged, not thrown: the ban and archives have committed, and banning
+   * the user again records the stops again, since every owned workspace is stopped, archived or
+   * not.
    */
   let stopFailed = false
   const stopRuns = async (workspaceIds: string[]): Promise<void> => {