feat(async): track current running coroutine for graph export

include/eventide/async/runtime/frame.h

@@ -16,12 +16,18 @@
 
 namespace eventide {
 
+class async_node;
 class sync_primitive;
 
 namespace detail {
 
 /// Resume a coroutine and immediately drain any deferred root-frame destruction.
-void resume_and_drain(std::coroutine_handle<> handle);
+/// @param restore_to  The async_node* to write back into the thread-local
+///                    current-node slot after the resumed chain returns.
+///                    Callers must capture this **before** any call to
+///                    handle_subtask_result / deliver_deferred, which
+///                    overwrite the slot as part of symmetric-transfer setup.
+void resume_and_drain(async_node* restore_to, std::coroutine_handle<> handle);
 
 }  // namespace detail
 
@@ -122,6 +128,14 @@ class async_node {
     /// Dump the async graph reachable from this node as a DOT (graphviz) graph.
     std::string dump_dot() const;
 
+    /// Returns the async_node whose coroutine body is currently executing on
+    /// this thread, or nullptr if no coroutine is active.
+    const static async_node* current() noexcept;
+
+    /// Convenience: calls dump_dot() on the current node.  Returns an empty
+    /// string if no coroutine is active.
+    static std::string dump_current_dot();
+
 private:
     const static async_node* get_awaiter(const async_node* node);
     const static sync_primitive* get_resource_parent(const async_node* node);
@@ -420,4 +434,15 @@ class system_op : public async_node {
     void complete() noexcept;
 };
 
+namespace detail {
+
+/// Thread-local pointer to the async_node whose coroutine body is currently
+/// executing on this thread.  Set by the tracking awaiters in task.h and
+/// save/restored around every resume entry-point so that user code can always
+/// call async_node::current() to obtain it.
+void set_current_node(async_node* node) noexcept;
+async_node* current_node() noexcept;
+
+}  // namespace detail
+
 }  // namespace eventide

include/eventide/async/runtime/task.h

@@ -65,6 +65,24 @@ struct promise_result<void, E, C> {
     }
 };
 
+// ============================================================================
+// initial_tracking_suspend — sets current node when coroutine body first runs
+// ============================================================================
+
+struct initial_tracking_suspend {
+    async_node* node;
+
+    bool await_ready() const noexcept {
+        return false;
+    }
+
+    void await_suspend(std::coroutine_handle<>) const noexcept {}
+
+    void await_resume() const noexcept {
+        detail::set_current_node(node);
+    }
+};
+
 // ============================================================================
 // promise_exception, transition_await, cancel()
 // ============================================================================
@@ -245,6 +263,7 @@ std::coroutine_handle<> propagate_fail(async_node* child_node, async_node* paren
 
     // Exception: let parent resume normally; await_resume will rethrow.
     if(child->propagated_exception) {
+        detail::set_current_node(parent_node);
         return parent_task->handle();
     }
 
@@ -301,8 +320,8 @@ struct task_promise_object : standard_task, promise_result<T, E, void>, promise_
         return coroutine_handle::from_promise(*this);
     }
 
-    auto initial_suspend() const noexcept {
-        return std::suspend_always();
+    auto initial_suspend() noexcept {
+        return initial_tracking_suspend{static_cast<async_node*>(this)};
     }
 
     auto final_suspend() const noexcept {

src/async/runtime/frame.cpp

@@ -10,6 +10,27 @@
 
 namespace eventide {
 
+static thread_local async_node* current_running_node = nullptr;
+
+void detail::set_current_node(async_node* node) noexcept {
+    current_running_node = node;
+}
+
+async_node* detail::current_node() noexcept {
+    return current_running_node;
+}
+
+const async_node* async_node::current() noexcept {
+    return current_running_node;
+}
+
+std::string async_node::dump_current_dot() {
+    if(auto* node = current_running_node) {
+        return node->dump_dot();
+    }
+    return {};
+}
+
 namespace {
 
 #if ETD_WORKAROUND_MSVC_COROUTINE_ASAN_UAF
@@ -42,9 +63,10 @@ void drain_pending_destroys() {
 
 }  // namespace
 
-void detail::resume_and_drain(std::coroutine_handle<> handle) {
+void detail::resume_and_drain(async_node* restore_to, std::coroutine_handle<> handle) {
     if(handle) {
         handle.resume();
+        current_running_node = restore_to;
     }
 #if ETD_WORKAROUND_MSVC_COROUTINE_ASAN_UAF
     drain_pending_destroys();
@@ -66,17 +88,22 @@ std::coroutine_handle<> aggregate_op::deliver_deferred() noexcept {
     awaiter->clear_awaitee();
 
     switch(deferred) {
-        case Deferred::Resume: return static_cast<standard_task*>(awaiter)->handle();
+        case Deferred::Resume:
+            current_running_node = awaiter;
+            return static_cast<standard_task*>(awaiter)->handle();
 
         case Deferred::Cancel:
             if(policy & InterceptCancel) {
                 state = Cancelled;
+                current_running_node = awaiter;
                 return static_cast<standard_task*>(awaiter)->handle();
             }
             awaiter->state = Cancelled;
             return awaiter->final_transition();
 
-        case Deferred::Error: return static_cast<standard_task*>(awaiter)->handle();
+        case Deferred::Error:
+            current_running_node = awaiter;
+            return static_cast<standard_task*>(awaiter)->handle();
 
         case Deferred::None: break;
     }
@@ -109,8 +136,9 @@ void async_node::cancel() {
             return;
         }
 
+        auto* prev = current_running_node;
         auto next = awaiter->handle_subtask_result(link);
-        detail::resume_and_drain(next);
+        detail::resume_and_drain(prev, next);
     };
 
     switch(kind) {
@@ -149,8 +177,9 @@ void async_node::cancel() {
                 break;
             }
 
+            auto* prev = current_running_node;
             auto next = self->deliver_deferred();
-            detail::resume_and_drain(next);
+            detail::resume_and_drain(prev, next);
             break;
         }
 
@@ -168,7 +197,9 @@ void async_node::cancel() {
 void async_node::resume() {
     if(is_standard_task()) {
         if(!is_cancelled() && !is_failed()) {
+            auto* prev = current_running_node;
             static_cast<standard_task*>(this)->handle().resume();
+            current_running_node = prev;
 #if ETD_WORKAROUND_MSVC_COROUTINE_ASAN_UAF
             drain_pending_destroys();
 #endif
@@ -187,8 +218,9 @@ void system_op::complete() noexcept {
     if(!parent) {
         return;
     }
+    auto* prev = current_running_node;
     auto next = parent->handle_subtask_result(this);
-    detail::resume_and_drain(next);
+    detail::resume_and_drain(prev, next);
 }
 
 /// Wires this node as a child of `awaiter`. For Task nodes, sets state
@@ -277,6 +309,7 @@ std::coroutine_handle<> async_node::handle_subtask_result(async_node* child) {
             if(child->state == Cancelled) {
                 if(child->policy & InterceptCancel) {
                     self->awaitee = nullptr;
+                    current_running_node = self;
                     return self->handle();
                 }
 
@@ -297,6 +330,7 @@ std::coroutine_handle<> async_node::handle_subtask_result(async_node* child) {
                     return propagate(child, self);
                 }
             }
+            current_running_node = self;
             return self->handle();
         }
 

src/async/runtime/sync.cpp

@@ -63,8 +63,9 @@ bool sync_primitive::cancel_waiter(waiter_link* link) noexcept {
     // than first stashing raw waiter pointers into a temporary container.
     link->state = async_node::Cancelled;
     link->policy = static_cast<async_node::Policy>(link->policy | async_node::InterceptCancel);
+    auto* prev = detail::current_node();
     auto next = awaiting->handle_subtask_result(link);
-    detail::resume_and_drain(next);
+    detail::resume_and_drain(prev, next);
     return true;
 }