Misunderstanding of async/await evaluation details

I try to follow the ECMAScript spec to find out how async/await do its work and encountered some hurdle.

Let's suppose there is such code:

function boo() {
    return 1;
}

async function foo() {
    let result = await boo();
    return result;
}

foo();

So let's start to track step by step what must be done under the hood:

1. Running [[Call]] internal method of foo(), that suspends the current execution context (callerContext), creates new one (calleeContext) and pushes it onto the execution context stack. We have the execution context stack of this look: callerContext < calleeContext -- running.

2. The next step is a foo() evaluation (that is AsyncFunctionBody associated with it), that in effect is EvaluateAsyncFunctionBody. This routine, in turn, calls AsyncFunctionStart. It creates a copy of the running execution context - asyncContext - and pushes it onto the stack, which now is as follows: callerContext < calleeContext < asyncContext -- running. calleeContext is left anxious to receive the result of asyncContext evaluation later (step 10).

3. As it was prescribed in AsyncFunctionStart, asyncContext evaluates FunctionBodyof foo(). The await expression is met along the way. It is defined to get the result of boo() firstly and subsequently call Await routine with 1 as an argument.

4. Await creates a promise resolved with 1 and performs its then(), so that the promise can notify of its fulfilled value and this value would exposed as the result of the await expression. But for now asyncContext is removed from the execution context stack, which at the current time is callerContext < calleeContext -- running.

It is difficult to me to understand what is next due to happen. A promise takes the opportunity to notify its subscribers only when the execution context stack is empty because for the sake of it the Job queue is involved. In the other hand, caleeContext is waiting for the result of asyncContext evaluation (step 10 of AsyncFunctionStart) and I can't find the place where both execution contexts (calleeContext and callerContext) removed from the stack. It seems like a deadlock!