fix(hitl): cancel paused executions directly in DB

Paused HITL executions are idle in the DB — they don't poll Redis or
run in-process, so the existing cancel signals had no effect. The DB
status stayed 'pending', causing the optimistic 'cancelling' update to
revert on refetch.

- Add PauseResumeManager.cancelPausedExecution: atomically sets
  paused_executions.status and workflow_execution_logs.status to
  'cancelled' inside a FOR UPDATE transaction
- Guard enqueueOrStartResume against resuming a cancelled execution
- Include pausedCancelled in the cancel route success check

Author: waleedlatif1

apps/sim/app/api/workflows/[id]/executions/[executionId]/cancel/route.ts

@@ -4,6 +4,7 @@ import { checkHybridAuth } from '@/lib/auth/hybrid'
 import { markExecutionCancelled } from '@/lib/execution/cancellation'
 import { abortManualExecution } from '@/lib/execution/manual-cancellation'
 import { captureServerEvent } from '@/lib/posthog/server'
+import { PauseResumeManager } from '@/lib/workflows/executor/human-in-the-loop-manager'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 
 const logger = createLogger('CancelExecutionAPI')
@@ -49,19 +50,24 @@ export async function POST(
 
     const cancellation = await markExecutionCancelled(executionId)
     const locallyAborted = abortManualExecution(executionId)
+    const pausedCancelled = await PauseResumeManager.cancelPausedExecution(executionId)
 
     if (cancellation.durablyRecorded) {
       logger.info('Execution marked as cancelled in Redis', { executionId })
     } else if (locallyAborted) {
       logger.info('Execution cancelled via local in-process fallback', { executionId })
+    } else if (pausedCancelled) {
+      logger.info('Paused execution cancelled directly in database', { executionId })
     } else {
       logger.warn('Execution cancellation was not durably recorded', {
         executionId,
         reason: cancellation.reason,
       })
     }
 
-    if (cancellation.durablyRecorded || locallyAborted) {
+    const success = cancellation.durablyRecorded || locallyAborted || pausedCancelled
+
+    if (success) {
       const workspaceId = workflowAuthorization.workflow?.workspaceId
       captureServerEvent(
         auth.userId,
@@ -72,11 +78,12 @@ export async function POST(
     }
 
     return NextResponse.json({
-      success: cancellation.durablyRecorded || locallyAborted,
+      success,
       executionId,
       redisAvailable: cancellation.reason !== 'redis_unavailable',
       durablyRecorded: cancellation.durablyRecorded,
       locallyAborted,
+      pausedCancelled,
       reason: cancellation.reason,
     })
   } catch (error: any) {

apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts

@@ -193,6 +193,10 @@ export class PauseResumeManager {
         throw new Error('Paused execution not found or already resumed')
       }
 
+      if (pausedExecution.status === 'cancelled') {
+        throw new Error('Execution has been cancelled')
+      }
+
       const pausePoints = pausedExecution.pausePoints as Record<string, any>
       const pausePoint = pausePoints?.[contextId]
       if (!pausePoint) {
@@ -1253,6 +1257,43 @@ export class PauseResumeManager {
     })
   }
 
+  /**
+   * Cancels a paused execution by updating both the paused execution record and the
+   * workflow execution log status to 'cancelled'. Returns true if a paused execution
+   * was found and cancelled, false if no paused execution exists for this executionId.
+   */
+  static async cancelPausedExecution(executionId: string): Promise<boolean> {
+    const now = new Date()
+
+    return await db.transaction(async (tx) => {
+      const pausedExecution = await tx
+        .select({ id: pausedExecutions.id })
+        .from(pausedExecutions)
+        .where(
+          and(eq(pausedExecutions.executionId, executionId), eq(pausedExecutions.status, 'paused'))
+        )
+        .for('update')
+        .limit(1)
+        .then((rows) => rows[0])
+
+      if (!pausedExecution) {
+        return false
+      }
+
+      await tx
+        .update(pausedExecutions)
+        .set({ status: 'cancelled', updatedAt: now })
+        .where(eq(pausedExecutions.id, pausedExecution.id))
+
+      await tx
+        .update(workflowExecutionLogs)
+        .set({ status: 'cancelled' })
+        .where(eq(workflowExecutionLogs.executionId, executionId))
+
+      return true
+    })
+  }
+
   static async listPausedExecutions(options: {
     workflowId: string
     status?: string | string[]