For BDD, should the step to wait be explicit in the feature file or just implemented in the step?

Given that the stakeholder "would not know about the necessity to wait", then no, there should not be an explicit wait step. There are times when it's appropriate to have one, but they are times when the wait is something that the user would care about (for example, automated logouts on financial software).

In fact, you probably shouldn't have any explicit waits in your tests. You don't care that the time has passed, you care that the operations have completed. It's still not ideal to have a Given the operations have completed step (since, as you say, the user wouldn't phrase it that way) and to instead have that in the code behind the When step.

Even besides the question of whether the user would phrase the step that way, there's a direct technical reason not to use explicit waits: they are slow, and they stay slow. If your code takes 2 seconds to process things, then waiting 2 seconds isn't actually enough - you need to wait long enough that you can be pretty sure that it will have finished (even if the system is under additional load). So you might need to build in a little extra time, say 3 seconds. Which isn't too bad for one test, but if you end up with a suite of a few hundred tests, then executing the suite gets slower and slower (especially since, when doing BDD, you often reuse steps.) Furthermore - if later on, you come up with a faster way to do things (or get a faster machine, or a faster execution environment for automated tests), then you don't get any of that speed benefit, since the test is still explicitly waiting an amount of time.

Such a step is probably not a good idea, mostly because this will make your tests terribly slow. But why do you need such a step?

• You have a nonfunctional requirement that some operation must finish within some deadline.

  Then let the operation run and measure the elapsed time, for example

  Given that I have a timer
  When I perform some action
  Then I get some result
   And no more than 2 seconds have elapsed on the timer
  

• You need to synchronize some operations, e.g. some external system might need those two seconds to respond.

  Then using a timer is a completely backwards approach. Instead, use some proper synchronization or at least wait with some timeout.

• You need to test time-dependent behaviour, e.g. a token should be expired after 24 hours.

  Then don't wait until that time passes, but use some kind of mock time source that you can advance in your tests. For example:

  When I perform some action
   And 24 hours pass
  Then I get some result
  

  With huge timeframes like 24 hours this approach is obvious, but for small timeframes like 2 seconds the same concepts hold.

With BDD your test should match the requirements for the feature. Include the wait step when its a requirement

Good:

When the "Win a Prize" button is clicked
and the 2 seconds mandatory wait between clicks has elapsed
the "You have won!" message should be displayed

And not when it is a simple technical restriction on the system

Bad:

When the "Win a Prize" button is clicked
and the 2 seconds round time trip to the prize api has elapsed
the "You have won!" message should be displayed

The way I answer this question is by asking a different question: "how would you tell a human to test this feature?". Would you explicitly tell them to wait, or is waiting implied?

What is your system under test doing "after all the operations complete"?

Either nothing is happening, in which case the wait is superfluous, or something is happening, so your definition of "all the operations" is incomplete, and should be changed to include the extra things going on.