Notify std::condition_variable that waits on the std::future returned by std::async from within the async function

Question

Given the following code my question is whether precondition of the std::condition_variable is guaranteed to see the std::future in the state after the lambda returned, i.e. std::future_status::ready. Or if it could happen that the std::condition_variable is woken up before the return value of the lambda is used to update the state of the std::future. In which case the worker might be stuck forever as it will not be notified again.

I guess another formulation would be whether the inner_lock is guaranteed to not be released before the return value of the lambda is used to update the state of the std::future.

In practice this seems to work fine so far. The question is more whether this guaranteed to be safe or whether there is a race condition in this code.

std::mutex m;
std::future<bool> task;
std::condition_variable cv;

void dispatcher() {
    std::lock_guard lock(m);

    task = std::async(std::launch::async, [&] {
        // Do work...

        std::lock_guard inner_lock(m);
        cv.notify_one();
        return true;
    });
}

void worker() {
    auto task_ready = [&] {
        return task.valid() && task.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
    };

    std::unique_lock<std::mutex> lock(m);

    cv.wait(lock, task_ready);

    bool result = task.get();
    
    // Do some more work...
}