fix(copilot): honor aborts before cancellation commit

Author: j15z

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

@@ -1050,6 +1050,50 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
     expect(mockCancelByExecution).not.toHaveBeenCalled()
   })
 
+  it('rolls back pause staging when cancellation is aborted during staging', async () => {
+    const controller = new AbortController()
+    mockStagePausedCancellation.mockImplementationOnce(async () => {
+      controller.abort()
+      return { kind: 'idle' }
+    })
+
+    const response = await cancelWorkflowExecutionPostAuth({
+      workflowId: 'wf-1',
+      executionId: 'ex-1',
+      userId: 'user-1',
+      abortSignal: controller.signal,
+    })
+
+    expect(response.status).toBe(409)
+    expect(mockClearPausedCancellationIntent).toHaveBeenCalledWith('ex-1', 'wf-1')
+    expect(mockMarkExecutionCancelled).not.toHaveBeenCalled()
+    expect(mockAbortManualExecution).not.toHaveBeenCalled()
+    expect(mockCancelByExecution).not.toHaveBeenCalled()
+  })
+
+  it('rolls back an active resume staged while cancellation is aborted', async () => {
+    const controller = new AbortController()
+    mockStagePausedCancellation.mockImplementationOnce(async () => {
+      controller.abort()
+      return { kind: 'active_resume', target: ACTIVE_RESUME_TARGET }
+    })
+
+    const response = await cancelWorkflowExecutionPostAuth({
+      workflowId: 'wf-1',
+      executionId: 'ex-1',
+      userId: 'user-1',
+      abortSignal: controller.signal,
+    })
+
+    expect(response.status).toBe(409)
+    expect(mockRollbackActiveResumeCancellation).toHaveBeenCalledWith(
+      'ex-1',
+      'wf-1',
+      'resume-entry-1'
+    )
+    expect(mockMarkExecutionCancelled).not.toHaveBeenCalled()
+  })
+
   it('returns 404 when the execution does not belong to the workflow', async () => {
     dbChainMockFns.limit.mockResolvedValueOnce([])
 

apps/sim/lib/execution/cancel-workflow-execution-post-auth.ts

@@ -111,6 +111,11 @@ function mergeExecutionStopSignal(
   summary.signalledExecutionIds.add(signalExecutionId)
 }
 
+/**
+ * Commits cancellation after the caller's final abort check. Once signalling begins, the
+ * operation must finish reconciliation because workers may already have observed the durable,
+ * local, or queued signal; attempting to honor a later abort could revive only part of a run.
+ */
 async function signalExecutionStop(args: {
   workflowId: string
   signalExecutionId: string
@@ -341,6 +346,28 @@ function cancellationAbortedResponse(abortSignal?: AbortSignal): NextResponse |
     : null
 }
 
+async function rollbackPausedCancellationAfterAbort(args: {
+  stage: PausedCancellationStage
+  workflowId: string
+  executionId: string
+  abortSignal?: AbortSignal
+}): Promise<NextResponse | null> {
+  const abortResponse = cancellationAbortedResponse(args.abortSignal)
+  if (!abortResponse) return null
+
+  if (args.stage.kind === 'active_resume') {
+    await PauseResumeManager.rollbackActiveResumeCancellation(
+      args.executionId,
+      args.workflowId,
+      args.stage.target.resumeEntryId
+    )
+  } else if (args.stage.kind === 'idle') {
+    await PauseResumeManager.clearPausedCancellationIntent(args.executionId, args.workflowId)
+  }
+
+  return abortResponse
+}
+
 /** Runs the existing workflow cancellation lifecycle after surface authentication. */
 export async function cancelWorkflowExecutionPostAuth({
   workflowId,
@@ -593,6 +620,14 @@ export async function cancelWorkflowExecutionPostAuth({
       executionId,
       workflowId
     )
+    const postStageAbort = await rollbackPausedCancellationAfterAbort({
+      stage: pausedCancellationStage,
+      workflowId,
+      executionId,
+      abortSignal,
+    })
+    if (postStageAbort) return postStageAbort
+
     let effectivePausedCancellationPath = isPausedCancellationStage(pausedCancellationStage)
     let activeResumeTarget =
       pausedCancellationStage.kind === 'active_resume' ? pausedCancellationStage.target : null
@@ -656,6 +691,17 @@ export async function cancelWorkflowExecutionPostAuth({
           executionId,
           workflowId
         )
+        const postLateStageAbort = await rollbackPausedCancellationAfterAbort({
+          stage: pausedCancellationStage,
+          workflowId,
+          executionId,
+          abortSignal,
+        })
+        if (postLateStageAbort) {
+          await clearStopSignalMarkers(stopSummary)
+          return postLateStageAbort
+        }
+
         effectivePausedCancellationPath = isPausedCancellationStage(pausedCancellationStage)
         activeResumeTarget =
           pausedCancellationStage.kind === 'active_resume' ? pausedCancellationStage.target : null