Condition_variable wait_for timeout issue

Ok, I have it, so I'll post the solution below. It came down to a number of mistakes on my part;

• from compile switches -g -fsanitize=thread I was able to see I had a number of read/write race conditions and a bunch of other excitement which required some love from a bunch of mutexes.
• following from above I was calling a read from the thread after the parent object was destroyed. This was because the construction of Coundown object and it's insertion into the waitlist map, caused a move constructor to be created twice, so I separated out another function (start) which would then start the thread after all the constructor nonsense was finished with.
• From compile switch -Wall picked up I was initializing the initialization list out of order (I didn't know that was a thing)

.

#include <chrono>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <map>
#include <mutex>
#include <thread>

using Time = std::chrono::system_clock;
using Seconds = std::chrono::seconds;
using Timepoint = Time::time_point;

class Countdown {
private:
    Timepoint               target;
    unsigned int            guid;
    std::string             name;
    std::thread             t;
    std::condition_variable cv;
    std::mutex              cv_m;

public:
    Countdown() // Needed to compile, but doesn't appear to run 
    { }

    Countdown(unsigned int guid_, std::string name_, unsigned int waitFor)
        : target(Time::now() + Seconds(waitFor))
        , guid(guid_)
        , name(name_)
    { }

    Countdown(Countdown &&from) // move constructor
    {
        //std::cout << "Countdown move constructor" << std::endl; 
        target = from.target;
        t = std::move(from.t);
        name = from.name;
        guid = from.guid;
    }

    ~Countdown()
    {
        //std::cout << "~Countdown()" << std::endl; 
        if (t.joinable()) t.join();
    }

    void start(std::function<void(unsigned int)> callback)
    {
        auto exec_run = [this, callback]() mutable {
            std::unique_lock<std::mutex> lk(cv_m);
            unsigned int guid = getGUID();
            //std::time_t target = std::chrono::system_clock::to_time_t(getTarget());
            //std::cout << "[Thread " << guid << "] waiting for " << std::ctime(&target) << " seconds." << std::endl;
 
            Timepoint before = Time::now();
            if (cv.wait_until(lk, target) == std::cv_status::timeout)
            {
                Timepoint after = Time::now();
                std::chrono::duration<float> difference = after - before;
                std::cout << "[Thread " << guid << "] Elapsed " << difference.count() << " seconds." << std::endl;
                callback(guid);
            } 
        };
        
        t = std::thread(exec_run);
    }

    unsigned int getGUID() { return guid; }

};

class Holder {
private:
    unsigned int                        id;
    std::map<unsigned int, Countdown>   waitlist;
    std::mutex                          waitlist_mutex;
    std::vector<unsigned int>           completed;
    std::mutex                          completed_mutex;

public:
    Holder()
        : id(0)
    { }

    // Create a new task with a name for WaitFor (s) period of time
    unsigned int addTask(std::string name, unsigned int waitFor) {
        id++;
        std::lock_guard<std::mutex> guard(waitlist_mutex);
        Countdown newCountdown(id, name, waitFor);
        
        // Needed to separate the following into 3 lines to give the move constructors a chance
        // to settle down, and separate out a start which initiates the thread so that the thread
        // isn't trying to access stuff as the destructors after the move constructor are called
        std::pair<unsigned int, Countdown> pair(id, std::move(newCountdown));
        waitlist.emplace(std::move(pair));
        
        waitlist[id].start(std::bind(&Holder::taskComplete, this, std::placeholders::_1)); 
        
        return id;
    }

    void taskComplete(unsigned int id)
    {
        std::cout << "[Thread " << id << "] taskComplete" << std::endl;
        // Add task id to the completed list to be picked up by main thread
        std::lock_guard<std::mutex> guard(completed_mutex);
        completed.push_back(id);
    }

    void cleanupCompleted()
    {
        // Purge the completed entries from the waitlist
        std::lock_guard<std::mutex> guard_c(completed_mutex);

        for (auto& id : completed)
        {
            std::cout << "[Main] Erasing task: " << id << std::endl;
            std::lock_guard<std::mutex> guard_w(waitlist_mutex);
            waitlist.erase(id);
        }

        // Empty the completed list
        completed.clear();
    }
};

int main()
{
    Holder *h = new Holder();
    // Create a task which spawns a thread, which notifies us when complete
    h->addTask("fluffy", 1);
    h->addTask("woof", 4);
    std::cout << "[Main]: Done adding tasks.." << std::endl;
 
    // Rest a while..
    std::this_thread::sleep_for(Seconds(5));
    h->cleanupCompleted();

    // Just to show the main thread continues on.
    std::cout << "[Main]: Doing other stuff.." << std::endl;
    delete(h);

    return 0;
}

...and the proof =)

[Main]: Done adding tasks..
[Thread 1] Elapsed 0.999498 seconds.
[Thread 1] taskComplete
[Thread 2] Elapsed 3.99984 seconds.
[Thread 2] taskComplete
[Main] Erasing task: 1
[Main] Erasing task: 2
[Main]: Doing other stuff..

Thanks again Ted =)