diff --git a/kernel/src/kernel/double_buffer/model.hpp b/kernel/src/kernel/double_buffer/model.hpp
index 2e5c09d..42a27a8 100644
--- a/kernel/src/kernel/double_buffer/model.hpp
+++ b/kernel/src/kernel/double_buffer/model.hpp
@@ -244,8 +244,8 @@ private:
         data().buffer_storage.advance();
         data().dependency_graph_storage.advance();
         after_advance();
-        // after_advance 只修改已提交的 current；由状态缓冲统一刷新下一次编辑基线，具体机制不得自行同步两份状态。
-        *data().state.pending = *data().state.current;
+        // Commit_Double_Buffer::advance() 已为 pending 建立 current 基线；after_advance
+        // 只向 pending 写本轮派生状态，禁止回写正在供外部查询的 current。
     }
 public:
     template <detail::Buffer_Tag_In<Buffers> Tag>
diff --git a/kernel/src/kernel/render_common.cpp b/kernel/src/kernel/render_common.cpp
index 9adaa40..704a030 100644
--- a/kernel/src/kernel/render_common.cpp
+++ b/kernel/src/kernel/render_common.cpp
@@ -3,6 +3,7 @@
 #include <chrono>
 #include <limits>
 #include <mutex>
+#include <stdexcept>
 #include <taskflow/observer/interface.hpp>
 namespace aethera {
 namespace {
@@ -45,11 +46,9 @@ private:
     std::atomic_uint64_t worker_busy_time_ns{};
     std::atomic_uint64_t first_task_time_ns{};
     std::atomic_uint64_t last_task_time_ns{};
-    mutable std::mutex longest_mutex;
-    std::uint64_t longest_task_time_ns{};
-    std::size_t longest_task_hash{};
-    std::string longest_task_name;
-    tf::TaskType longest_task_type{tf::TaskType::UNDEFINED};
+    std::atomic_uint64_t longest_task_time_ns{};
+    std::atomic_size_t longest_task_hash{};
+    std::atomic<tf::TaskType> longest_task_type{tf::TaskType::UNDEFINED};
     static std::uint64_t clock_ns(Clock::time_point value) noexcept {
         return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(value.time_since_epoch()).count());
     }
@@ -79,7 +78,6 @@ public:
     }
     void on_entry(tf::WorkerView worker, tf::TaskView task) override {
         auto now = Clock::now();
-        detail::observe_stage_entry(task.hash_value(), clock_ns(now));
         auto& worker_starts = starts[worker.id()];
         if (worker_starts.empty()) {
             worker_busy_starts[worker.id()] = now;
@@ -103,7 +101,6 @@ public:
     }
     void on_exit(tf::WorkerView worker, tf::TaskView task) override {
         auto now = Clock::now();
-        detail::observe_stage_exit(task.hash_value(), clock_ns(now));
         auto& worker_starts = starts[worker.id()];
         auto start = worker_starts.back();
         worker_starts.pop_back();
@@ -123,14 +120,11 @@ public:
             update_min(type.min_time_ns, elapsed);
             update_max(type.max_time_ns, elapsed);
         }
-        {
-            std::lock_guard guard(longest_mutex);
-            if (longest_task_time_ns < elapsed) {
-                longest_task_time_ns = elapsed;
-                longest_task_hash = task.hash_value();
-                longest_task_name = task.name();
-                longest_task_type = task.type();
-            }
+        auto longest = longest_task_time_ns.load(std::memory_order_relaxed);
+        if (longest < elapsed && longest_task_time_ns.compare_exchange_strong(
+                longest, elapsed, std::memory_order_relaxed)) {
+            longest_task_hash.store(task.hash_value(), std::memory_order_relaxed);
+            longest_task_type.store(task.type(), std::memory_order_relaxed);
         }
         active_tasks.fetch_sub(1, std::memory_order_relaxed);
         if (worker_starts.empty()) {
@@ -187,11 +181,10 @@ public:
             target.max_task_time_ns = source.max_task_time_ns.load(std::memory_order_relaxed);
             target.utilization = state.observed_wall_time_ns ? static_cast<double>(target.busy_time_ns) * 100.0 / static_cast<double>(state.observed_wall_time_ns) : 0.0;
         }
-        std::lock_guard guard(longest_mutex);
-        state.longest_task_time_ns = longest_task_time_ns;
-        state.longest_task_hash = longest_task_hash;
-        state.longest_task_name = longest_task_name;
-        state.longest_task_type = longest_task_type;
+        state.longest_task_time_ns = longest_task_time_ns.load(std::memory_order_relaxed);
+        state.longest_task_hash = longest_task_hash.load(std::memory_order_relaxed);
+        state.longest_task_name.clear();
+        state.longest_task_type = longest_task_type.load(std::memory_order_relaxed);
     }
 };
 class Task_Resource : Pinned {
@@ -206,6 +199,7 @@ private:
     Task_Runtime_State state;
     double_buffer::detail::State_Callback_Storage<Task_Runtime_State> state_callbacks;
     std::recursive_mutex state_mutex;
+    std::atomic_bool state_callback_enabled{};
     void create_executor(std::size_t workers, std::shared_ptr<tf::WorkerInterface> worker_interface) {
         executor = std::make_unique<tf::Executor>(workers, std::move(worker_interface));
         observer = executor->make_observer<Task_Observer>();
@@ -218,6 +212,7 @@ private:
         observer = executor->make_observer<Task_Observer>();
     }
     void publish_state() {
+        if (!state_callback_enabled.load(std::memory_order_acquire)) return;
         std::lock_guard guard(state_mutex);
         observer->write_state(state, executor->num_workers(), executor->num_topologies());
         state.active_taskflow_count = active_taskflows.load(std::memory_order_relaxed);
@@ -248,7 +243,10 @@ public:
         while (peak < active && !peak_active_taskflows.compare_exchange_weak(peak, active, std::memory_order_relaxed)) {}
         auto start = std::chrono::steady_clock::now();
         try {
-            executor->run(taskflow).get();
+            if (executor->this_worker())
+                executor->corun(taskflow);
+            else
+                executor->run(taskflow).get();
         }
         catch (...) {
             active_taskflows.fetch_sub(1, std::memory_order_relaxed);
@@ -262,22 +260,46 @@ public:
         publish_state();
         return elapsed;
     }
+    void run(tf::Taskflow& taskflow, std::function<void()> completion) {
+        if (!completion) throw std::invalid_argument("Taskflow completion is empty");
+        ensure_executor();
+        auto active = active_taskflows.fetch_add(1, std::memory_order_relaxed) + 1;
+        auto peak = peak_active_taskflows.load(std::memory_order_relaxed);
+        while (peak < active && !peak_active_taskflows.compare_exchange_weak(
+                                  peak, active, std::memory_order_relaxed)) {}
+        executor->run(taskflow, [this, completion = std::move(completion)]() mutable {
+            active_taskflows.fetch_sub(1, std::memory_order_relaxed);
+            completed_taskflows.fetch_add(1, std::memory_order_relaxed);
+            publish_state();
+            completion();
+        });
+    }
+    void schedule(std::function<void()> task) {
+        if (!task) throw std::invalid_argument("Taskflow scheduled task is empty");
+        ensure_executor();
+        executor->silent_async(std::move(task));
+    }
     std::pmr::memory_resource* memory_resource() const noexcept {
         return memory;
     }
     void set_state_callback(std::function<void(const Task_Runtime_State&)> callback) {
         std::lock_guard guard(state_mutex);
         state_callbacks.template set<Task_Runtime_State_Tag>(std::move(callback));
+        state_callback_enabled.store(true, std::memory_order_release);
     }
     void clear_state_callback() {
         std::lock_guard guard(state_mutex);
         state_callbacks.template clear<Task_Runtime_State_Tag>();
+        state_callback_enabled.store(false, std::memory_order_release);
     }
 };
 }
 void initialize_runtime(std::size_t workers, std::shared_ptr<tf::WorkerInterface> worker_interface, Pmr pmr) {
     Task_Resource::instance().initialize(workers, std::move(worker_interface), pmr);
 }
+void schedule_task(std::function<void()> task) {
+    Task_Resource::instance().schedule(std::move(task));
+}
 namespace detail {
 void set_runtime_state_callback_impl(std::function<void(const Task_Runtime_State&)> callback) {
     Task_Resource::instance().set_state_callback(std::move(callback));
@@ -288,6 +310,9 @@ void clear_runtime_state_callback_impl() {
 std::uint64_t run_taskflow(tf::Taskflow& taskflow) {
     return Task_Resource::instance().run(taskflow);
 }
+void run_taskflow(tf::Taskflow& taskflow, std::function<void()> completion) {
+    Task_Resource::instance().run(taskflow, std::move(completion));
+}
 std::pmr::memory_resource* task_memory_resource() noexcept {
     return Task_Resource::instance().memory_resource();
 }
diff --git a/kernel/src/kernel/render_common.hpp b/kernel/src/kernel/render_common.hpp
index 3a5ac94..f3102a8 100644
--- a/kernel/src/kernel/render_common.hpp
+++ b/kernel/src/kernel/render_common.hpp
@@ -95,6 +95,8 @@ struct Task_Runtime_State : State_Type<Task_Runtime_State_Tag> {
 void initialize_runtime(std::size_t workers = std::thread::hardware_concurrency(),
                         std::shared_ptr<tf::WorkerInterface> worker_interface = nullptr,
                         Pmr pmr = {});
+/* 把独立业务任务提交给全局 Taskflow worker；任务不得执行阻塞式设备等待。 */
+void schedule_task(std::function<void()> task);
 /* 为全局 Taskflow 运行时状态注册回调；Tag 目前只接受 Task_Runtime_State_Tag。 */
 template <std::same_as<Task_Runtime_State_Tag> Tag, std::invocable<const Task_Runtime_State&> Callback>
 void set_runtime_state_callback(Callback&& callback);
diff --git a/kernel/src/kernel/render_common.ipp b/kernel/src/kernel/render_common.ipp
index a18cc9d..d0c5f7e 100644
--- a/kernel/src/kernel/render_common.ipp
+++ b/kernel/src/kernel/render_common.ipp
@@ -3,9 +3,8 @@ namespace aethera::detail {
 void set_runtime_state_callback_impl(std::function<void(const Task_Runtime_State&)> callback);
 void clear_runtime_state_callback_impl();
 std::uint64_t run_taskflow(tf::Taskflow& taskflow);
+void run_taskflow(tf::Taskflow& taskflow, std::function<void()> completion);
 std::pmr::memory_resource* task_memory_resource() noexcept;
-void observe_stage_entry(std::size_t task_hash, std::uint64_t now);
-void observe_stage_exit(std::size_t task_hash, std::uint64_t now);
 }
 namespace aethera {
 template <std::same_as<Task_Runtime_State_Tag> Tag, std::invocable<const Task_Runtime_State&> Callback>
diff --git a/kernel/src/kernel/renderable.cpp b/kernel/src/kernel/renderable.cpp
index 787174f..67e8e4e 100644
--- a/kernel/src/kernel/renderable.cpp
+++ b/kernel/src/kernel/renderable.cpp
@@ -1,81 +1,13 @@
 #include "renderable.hpp"
-#include <mutex>
-#include <unordered_map>
 namespace aethera {
 std::optional<double> Renderable::event_routing_distance(const Event& event) const {
     const auto& data = static_cast<const Private&>(*d);
     return data.event_routing_distance_run ? data.event_routing_distance_run(this, event) : std::nullopt;
 }
-namespace {
-class Stage_Registry : Pinned {
-private:
-    struct Binding {
-        const tf::Taskflow* owner;
-        Root* object;
-        Renderable::Private* data;
-        detail::Renderable_Stage stage;
-        detail::Stage_Observer_Point point;
-    };
-    std::unordered_map<std::size_t, Binding> bindings;
-    std::mutex mutex;
-public:
-    void bind(const tf::Taskflow* owner, std::size_t task_hash, Root* object, Renderable::Private* data, detail::Renderable_Stage stage, detail::Stage_Observer_Point point) {
-        std::lock_guard guard(mutex);
-        bindings.insert_or_assign(task_hash, Binding{owner, object, data, stage, point});
-    }
-    void clear(const tf::Taskflow* owner) {
-        std::lock_guard guard(mutex);
-        std::erase_if(
-            bindings,
-            [owner](const auto& value) {
-                return value.second.owner == owner;
-            }
-        );
-    }
-    void on_entry(std::size_t task_hash, std::uint64_t now) {
-        std::lock_guard guard(mutex);
-        auto current = bindings.find(task_hash);
-        if (current == bindings.end() || current->second.point != detail::Stage_Observer_Point::End) return;
-        auto& binding = current->second;
-        auto& state = *binding.data->dispatch->state.get(binding.object);
-        if (binding.stage == detail::Renderable_Stage::Prepare) {
-            if (state.prepare_executed) state.prepare_execution_time_ns = now - state.prepare_execution_time_ns;
-        }
-        else if (state.paint_executed) {
-            state.paint_execution_time_ns = now - state.paint_execution_time_ns;
-        }
-    }
-    void on_exit(std::size_t task_hash, std::uint64_t now) {
-        std::lock_guard guard(mutex);
-        auto current = bindings.find(task_hash);
-        if (current == bindings.end() || current->second.point != detail::Stage_Observer_Point::Begin) return;
-        auto& binding = current->second;
-        auto& state = *binding.data->dispatch->state.get(binding.object);
-        if (binding.stage == detail::Renderable_Stage::Prepare) {
-            state.prepare_execution_time_ns = state.prepare_executed ? now : 0;
-        }
-        else {
-            state.paint_execution_time_ns = state.paint_executed ? now : 0;
-        }
-    }
-};
-Stage_Registry& stage_registry() {
-    static Stage_Registry value;
-    return value;
-}
-}
-namespace detail {
-void observe_stage_entry(std::size_t task_hash, std::uint64_t now) {
-    stage_registry().on_entry(task_hash, now);
-}
-void observe_stage_exit(std::size_t task_hash, std::uint64_t now) {
-    stage_registry().on_exit(task_hash, now);
-}
-void bind_stage_observer(const tf::Taskflow* owner, std::size_t task_hash, Root* object, Renderable::Private* data, Renderable_Stage stage, Stage_Observer_Point point) {
-    stage_registry().bind(owner, task_hash, object, data, stage, point);
-}
-void clear_stage_observers(const tf::Taskflow* owner) {
-    stage_registry().clear(owner);
-}
+tf::Taskflow& Renderable::prepare_taskflow() {
+    return static_cast<Private&>(*d).prepare_extension;
+}
+tf::Taskflow& Renderable::paint_taskflow() {
+    return static_cast<Private&>(*d).paint_extension;
 }
 }
diff --git a/kernel/src/kernel/renderable.hpp b/kernel/src/kernel/renderable.hpp
index e42eb5b..a393140 100644
--- a/kernel/src/kernel/renderable.hpp
+++ b/kernel/src/kernel/renderable.hpp
@@ -88,6 +88,16 @@ struct Renderable : Def<Renderable, Root> {
     struct Private;
     /* 返回该对象参与当前事件竞争时的几何距离；无值表示沿用普通绘制层级路由。 */
     [[nodiscard]] std::optional<double> event_routing_distance(const Event& event) const;
+    /*
+     * 返回 Prepare 阶段完成后执行的直接 Taskflow 扩展端口。
+     * tf::Taskflow 只能在该 Renderable 所属 Scene 没有运行时修改；禁止在图执行期间 emplace/erase/clear。
+     */
+    [[nodiscard]] tf::Taskflow& prepare_taskflow();
+    /*
+     * 返回 Paint 阶段完成后执行的直接 Taskflow 扩展端口。
+     * tf::Taskflow 只能在该 Renderable 所属 Scene 没有运行时修改；禁止在图执行期间 emplace/erase/clear。
+     */
+    [[nodiscard]] tf::Taskflow& paint_taskflow();
 private:
     /* 数据模式的内部调度入口：执行最终对象 prepare_data(...)，再触发各 CRTP 层 after_prepare_data(...)。 */
     template <Prepare_Data_Renderable Object>
diff --git a/kernel/src/kernel/renderable.ipp b/kernel/src/kernel/renderable.ipp
index c159650..549c967 100644
--- a/kernel/src/kernel/renderable.ipp
+++ b/kernel/src/kernel/renderable.ipp
@@ -25,8 +25,9 @@ struct Renderable::Private : Prev_Private {
         Graph_Builder builder;                                /* 子图模式构建入口；数据模式为空。 */
     };
     struct State_Dispatch {
-        State_Get get;                                        /* 获取最终对象的 Renderable 状态层。 */
-        State_Notify notify;                                  /* 发布最终对象的 Renderable 状态。 */
+        State_Get current;                                    /* 读取已经发布的 Renderable 状态。 */
+        State_Get pending;                                    /* 写入本阶段诊断，由完成节点统一交换发布。 */
+        State_Notify publish;                                 /* 阶段完成后交换 State 双缓冲并发布稳定 current。 */
     };
     struct Dispatch {
         Stage_Dispatch prepare;                               /* Prepare 阶段分派。 */
@@ -39,6 +40,8 @@ struct Renderable::Private : Prev_Private {
     Color_Cache_Visit color_cache_visit{};                    /* 最终对象存在 Color_Cache Buffer 时访问本轮写入结果。 */
     std::unique_ptr<tf::Taskflow> prepare_graph;              /* Prepare 子图模式的当前构建产物。 */
     std::unique_ptr<tf::Taskflow> paint_graph;                /* Paint 子图模式的当前构建产物。 */
+    tf::Taskflow prepare_extension{};                         /* 外部直接续写的 Prepare 完成图；不参与内部子图重建。 */
+    tf::Taskflow paint_extension{};                           /* 外部直接续写的 Paint 完成图；不参与内部子图重建。 */
     bool prepare_graph_built{};                               /* Prepare 子图是否至少成功构建过一次。 */
     bool paint_graph_built{};                                 /* Paint 子图是否至少成功构建过一次。 */
     /* CRTP 可覆盖：决定已选中子图模式的 Prepare 子图是否重建；object 为最终对象，state 为当前发布状态；默认返回 false。 */
@@ -190,6 +193,13 @@ inline void Renderable::bind_dependency_graph_object(Attached auto* object) {
             },
             [](Root* root) {
                 auto* value = static_cast<Object*>(root);
+                auto& private_data = static_cast<typename Object::Private&>(*value->d);
+                return static_cast<State*>(private_data.state.pending);
+            },
+            [](Root* root) {
+                auto* value = static_cast<Object*>(root);
+                auto& private_data = static_cast<typename Object::Private&>(*value->d);
+                private_data.state.advance();
                 value->template notify_state<Renderable::Base_Tag>();
             }
         }
@@ -197,16 +207,4 @@ inline void Renderable::bind_dependency_graph_object(Attached auto* object) {
     data.dispatch = &dispatch;
     object->template mark_dirty<Prepare_Data_Tag>();
 }
-namespace detail {
-enum class Renderable_Stage {
-    Prepare,
-    Paint
-};
-enum class Stage_Observer_Point {
-    Begin,
-    End
-};
-void bind_stage_observer(const tf::Taskflow* owner, std::size_t task_hash, Root* object, Renderable::Private* data, Renderable_Stage stage, Stage_Observer_Point point);
-void clear_stage_observers(const tf::Taskflow* owner);
-}
 }
diff --git a/kernel/src/kernel/scene.cpp b/kernel/src/kernel/scene.cpp
index 7f81a2e..38cd779 100644
--- a/kernel/src/kernel/scene.cpp
+++ b/kernel/src/kernel/scene.cpp
@@ -1,7 +1,5 @@
 #include "scene.hpp"                                        /* 后端共有 Prepare Scene 实现。 */
 namespace aethera {
 Scene::Private::Private() = default;
-Scene::Private::~Private() {
-    if (runtime && runtime->taskflow) detail::clear_stage_observers(runtime->taskflow.get());
-}
+Scene::Private::~Private() = default;
 }
diff --git a/kernel/src/kernel/scene.ipp b/kernel/src/kernel/scene.ipp
index 375a15c..44b59ac 100644
--- a/kernel/src/kernel/scene.ipp
+++ b/kernel/src/kernel/scene.ipp
@@ -1,5 +1,6 @@
 #pragma once
 #include <algorithm>
+#include <chrono>
 #include <span>
 #include <unordered_map>
 #include <unordered_set>
@@ -63,11 +64,12 @@ void Scene::Private::process(Object* object, Callback&& callback) requires std::
 template <Attached Object, typename Callback>
 void Scene::Private::process(Object* object, Render_Frame* frame, Callback&& callback) requires std::invocable<Callback, const Result&> {
     auto& private_data = static_cast<typename Object::Private&>(*this);
-    auto& state = static_cast<State&>(*private_data.state.current);
+    auto& state = static_cast<State&>(*private_data.state.pending);
     state.taskflow_execution_time_ns = 0;
     if (frame) frame->mark(Frame_Trace_Marker::prepare_started);
     if (runtime->taskflow && !runtime->taskflow->empty()) state.taskflow_execution_time_ns = detail::run_taskflow(*runtime->taskflow);
     if (frame) frame->mark(Frame_Trace_Marker::prepare_finished);
+    private_data.state.advance();
     object->template notify_state<Scene::Base_Tag>();
     Result result;
     std::invoke(std::forward<Callback>(callback), std::as_const(result));
@@ -79,7 +81,7 @@ void Scene::Private::after_advance(Object* object,
                                    const Prop* current_prop,
                                    State_Access<State> current_states) {
     auto* resource = detail::task_memory_resource();
-    auto& scene_state = current_states.get<Scene::Base_Tag>();
+    auto& scene_state = pending_states.get<Scene::Base_Tag>();
     scene_state.taskflow_rebuilt = false;
     std::pmr::unordered_set<Root*> advanced_objects{resource};
     advanced_objects.insert(object);
@@ -87,18 +89,20 @@ void Scene::Private::after_advance(Object* object,
         [&](const Dependency_Graph& dependency_graph) {
             dependency_graph.for_each(
                 [&](const Dependency_Graph::Node& node) {
-                    if (advanced_objects.insert(node.object).second) node.object->advance_object();
+                    if (advanced_objects.insert(node.object).second) {
+                        node.object->advance_object();
+                    }
                 }
             );
         }
     );
+    auto prepare_dependencies = object->template current_dependency_graph<Prepare_Data_Tag>();
     bool taskflow_dirty = !runtime->taskflow;
     object->template access_pending_dependency_graph<Prepare_Data_Tag>(
         [&](auto& prepare_state) { taskflow_dirty = taskflow_dirty || prepare_state.dirty(); });
     if (!taskflow_dirty) return;
     if (!runtime->taskflow) runtime->taskflow = std::make_unique<tf::Taskflow>();
     auto& taskflow = *runtime->taskflow;
-    auto prepare_dependencies = object->template current_dependency_graph<Prepare_Data_Tag>();
     std::pmr::unordered_set<Renderable*> renderables{resource};
     prepare_dependencies.for_each_bound(
         [&](Renderable* renderable, Renderable::Private&) {
@@ -106,7 +110,6 @@ void Scene::Private::after_advance(Object* object,
         }
     );
     scene_state.renderable_count = renderables.size();
-    detail::clear_stage_observers(&taskflow);
     taskflow.clear();
     struct Stage_Tasks {
         tf::Task prepare_entry; /* Prepare 条件任务，作为该阶段依赖入口。 */
@@ -119,7 +122,7 @@ void Scene::Private::after_advance(Object* object,
         if (!data) continue;
         auto* dispatch = data->dispatch;
         auto prepare_if = taskflow.emplace([data, dispatch, root] {
-            auto& state = *dispatch->state.get(root);
+            auto& state = *dispatch->state.pending(root);
             state.prepare_graph_rebuilt = false;
             state.prepare_execution_time_ns = 0;
             if (dispatch->prepare.builder) {
@@ -138,6 +141,11 @@ void Scene::Private::after_advance(Object* object,
             bool dirty = root->template dirty<Prepare_Data_Tag>();
             state.prepare_dirty = dirty;
             state.prepare_executed = dispatch->prepare.predicate(root, dirty);
+            if (state.prepare_executed) {
+                state.prepare_execution_time_ns = static_cast<std::uint64_t>(
+                    std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::steady_clock::now().time_since_epoch()).count());
+            }
             return state.prepare_executed ? 0 : 1;
         }).name("renderable.prepare.condition");
         tf::Task prepare_run;
@@ -150,15 +158,22 @@ void Scene::Private::after_advance(Object* object,
                 if (dispatch->prepare.run) dispatch->prepare.run(root);
             }).name("renderable.prepare.data");
         }
+        auto prepare_extension = taskflow.composed_of(data->prepare_extension)
+            .name("renderable.prepare.extension");
         auto prepare_done = taskflow.emplace([dispatch, root] {
-            auto& state = *dispatch->state.get(root);
-            if (state.prepare_executed) root->template take_dirty<Prepare_Data_Tag>();
-            dispatch->state.notify(root);
+            auto& state = *dispatch->state.pending(root);
+            if (state.prepare_executed) {
+                root->template take_dirty<Prepare_Data_Tag>();
+                const auto finished = static_cast<std::uint64_t>(
+                    std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::steady_clock::now().time_since_epoch()).count());
+                state.prepare_execution_time_ns = finished - state.prepare_execution_time_ns;
+            }
+            dispatch->state.publish(root);
         }).name("renderable.prepare.complete");
         prepare_if.precede(prepare_run, prepare_done);
-        prepare_run.precede(prepare_done);
-        detail::bind_stage_observer(&taskflow, prepare_if.hash_value(), root, data, detail::Renderable_Stage::Prepare, detail::Stage_Observer_Point::Begin);
-        detail::bind_stage_observer(&taskflow, prepare_done.hash_value(), root, data, detail::Renderable_Stage::Prepare, detail::Stage_Observer_Point::End);
+        prepare_run.precede(prepare_extension);
+        prepare_extension.precede(prepare_done);
         stage_tasks.emplace(root, Stage_Tasks{prepare_if, prepare_done});
     }
     auto connect_dependencies = [&](const auto& dependency_graph) {
diff --git a/kernel/src/test/render_test.cpp b/kernel/src/test/render_test.cpp
index 19f587e..64eb83c 100644
--- a/kernel/src/test/render_test.cpp
+++ b/kernel/src/test/render_test.cpp
@@ -93,16 +93,21 @@ TEST(renderable_capability, direct_stages_do_not_allocate_subgraphs) {
     auto renderable = build_object<Direct>();
     auto scene = build_object<Scene>();
     add_renderable(*scene, renderable.get());
+    int prepare_extension_calls{};
+    renderable->prepare_taskflow().emplace(
+        [&] { ++prepare_extension_calls; }).name("test.prepare.extension");
     scene->process([](const auto&) {});
     auto& data = renderable->data_for_test();
     auto& base = static_cast<aethera::Renderable::Private&>(data);
     EXPECT_EQ(data.prepare_calls, 1);
     EXPECT_EQ(data.paint_calls, 0);
+    EXPECT_EQ(prepare_extension_calls, 1);
     EXPECT_EQ(base.prepare_graph, nullptr);
     EXPECT_EQ(base.paint_graph, nullptr);
     scene->process([](const auto&) {});
     EXPECT_EQ(data.prepare_calls, 1);
     EXPECT_EQ(data.paint_calls, 0);
+    EXPECT_EQ(prepare_extension_calls, 1);
 }
 TEST(renderable_capability, graph_stage_builds_lazily_and_rebuilds_inside_condition) {
     aethera::initialize_runtime(2);
diff --git a/render_2D/render_2D/axis/Time_Axis.ipp b/render_2D/render_2D/axis/Time_Axis.ipp
index f538564..daf75b1 100644
--- a/render_2D/render_2D/axis/Time_Axis.ipp
+++ b/render_2D/render_2D/axis/Time_Axis.ipp
@@ -110,7 +110,7 @@ inline void Time_Axis::Private::prepare_data(Attached auto* object) {
     const auto& prop = static_cast<const Prop&>(*private_data.current);
     object->template accumulate_stream<Time_Axis_Stream_Tag>(
         static_cast<std::size_t>(std::max<Axis_Visible_Count>(2, prop.visible_count)));
-    auto& state = static_cast<State&>(*private_data.state.current);
+    auto& state = static_cast<State&>(*private_data.state.pending);
     state.next_tick = next_tick.load(std::memory_order_relaxed);
     object->template access_rendering_stream<Time_Axis_Stream_Tag>(
         [&](std::span<std::pair<Axis_Time_Tick, Time_Of_Day>> samples) {
diff --git a/render_2D/render_2D/plottable/Spectrum.ipp b/render_2D/render_2D/plottable/Spectrum.ipp
index e93391f..fe63f78 100644
--- a/render_2D/render_2D/plottable/Spectrum.ipp
+++ b/render_2D/render_2D/plottable/Spectrum.ipp
@@ -177,7 +177,7 @@ template <Attached Object>
 void Spectrum::Private::paint_frame(Object* object) {
     auto& private_data = static_cast<typename Object::Private&>(*this);
     const auto& state = static_cast<const Prop&>(*private_data.current);
-    auto& published = static_cast<State&>(*private_data.state.current);
+    auto& published = static_cast<State&>(*private_data.state.pending);
     const auto& frame = object->template current_buffer<Spectrum_Frame_Tag>();
     published.sample_count = frame.samples.size();
     published.rendered_point_count = 0;
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.cpp b/render_2D/render_2D/scene/Render_Scene_2D.cpp
index 13bb0fb..f46ea7c 100644
--- a/render_2D/render_2D/scene/Render_Scene_2D.cpp
+++ b/render_2D/render_2D/scene/Render_Scene_2D.cpp
@@ -1,13 +1,14 @@
 #include "Render_Scene_2D.hpp"                             /* 二维 Paint Taskflow、缓存失效与合成实现。 */
 namespace aethera::render_2d {
-Render_Scene_2D::Private::~Private() {
-    if (paint_taskflow) aethera::detail::clear_stage_observers(paint_taskflow.get());
-}
+Render_Scene_2D::Private::~Private() = default;
 bool Render_Scene_2D::State::operator==(const State&) const = default;
 bool Render_Scene_2D::Prop::operator==(const Prop&) const = default;
 
 Render_Scene_2D::Render_Result Render_Scene_2D::render(Frame_2D* frame) { return static_cast<Private&>(*d).dispatch->render(this, frame); }
 void Render_Scene_2D::set_frame_callback(Frame_Callback callback) { static_cast<Private&>(*d).dispatch->set_frame_callback(this, std::move(callback)); }
+tf::Taskflow& Render_Scene_2D::completion_taskflow() {
+    return static_cast<Private&>(*d).completion_graph;
+}
 void Render_Scene_2D::activate_view() {
     static_cast<Private&>(*d).dispatch->set_active(this, true);
 }
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.hpp b/render_2D/render_2D/scene/Render_Scene_2D.hpp
index 8633470..da2aa6b 100644
--- a/render_2D/render_2D/scene/Render_Scene_2D.hpp
+++ b/render_2D/render_2D/scene/Render_Scene_2D.hpp
@@ -33,12 +33,19 @@ struct Render_Scene_2D : Def<Render_Scene_2D, Scene,
     private:
         std::vector<std::function<std::expected<void, Dependency_Graph_Error>(Object*)>> attachments{}; /* 仅在 build 期间绑定已构造 Renderable。 */
     };
-    enum class Render_Result { completed, view_inactive, empty_viewport };
+    enum class Render_Result { completed, frame_in_flight, view_inactive, empty_viewport };
     using Frame_Callback = std::function<void(Frame_2D*)>;
-    /* 向调用方拥有的帧合成一次；frame 必须存活到完成回调返回。 */
+    /* 向调用方拥有的帧合成一次；必须先安装回调。回调返回前的并发请求返回 frame_in_flight。 */
     [[nodiscard]] Render_Result render(Frame_2D* frame);
-    /* 安装完成帧回调；回调收到的就是对应 render(frame) 传入的对象。 */
+    /* 安装完成帧回调；回调收到对应 render(frame) 的对象，返回时 Scene 才释放下一帧准入。 */
     void set_frame_callback(Frame_Callback callback);
+    /*
+     * 返回最终像素完成后、帧回调前执行的直接 Taskflow。
+     * 只能在 Scene 没有运行时修改该图；禁止在执行期间 emplace/erase/clear。
+     * completion Taskflow 完成前调用方必须保持本帧像素所有权；节点若启动更晚结束的异步工作，
+     * 必须捕获拥有像素所有权的对象，禁止只捕获会被下一帧复用的裸 Frame_2D*。
+     */
+    [[nodiscard]] tf::Taskflow& completion_taskflow();
     /* 激活后 render 才会执行。 */
     void activate_view();
     /* 停止后续 render 调用，不清除最后一帧。 */
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.ipp b/render_2D/render_2D/scene/Render_Scene_2D.ipp
index a4a5516..162b6cd 100644
--- a/render_2D/render_2D/scene/Render_Scene_2D.ipp
+++ b/render_2D/render_2D/scene/Render_Scene_2D.ipp
@@ -1,6 +1,8 @@
 #pragma once
+#include <chrono>
 #include "../event/Event_Routing_Rules.hpp"
 #include <stdexcept>
+#include <mutex>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -57,7 +59,10 @@ struct Render_Scene_2D::Private : Prev_Private {
         Active_Run set_active;                                /* 修改最终 Scene 的视图活动状态。 */
     };
     const Dispatch* dispatch{};                               /* Builder 绑定最终 Scene 类型后的静态分派表。 */
+    std::mutex render_mutex{};                               /* 只保护完成回调和单帧准入。 */
+    bool frame_in_flight{};                                  /* render 准入到完成回调返回的唯一状态源。 */
     Frame_Callback frame_callback{};                          /* 合成完成后的唯一像素发布出口。 */
+    tf::Taskflow completion_graph{};                          /* 最终像素完成后、发布回调前执行的外部续写图。 */
     std::unique_ptr<tf::Taskflow> paint_taskflow{};           /* 仅由二维 Paint 图构建的执行图。 */
     ~Private();
     Frame_2D* active_frame{};                                /* 当前同步 process 借用的外部帧；render 返回前清空。 */
@@ -97,7 +102,6 @@ void Render_Scene_2D::Private::after_advance(Object* object, Prop*, State_Access
     if (!rebuild) return;
     if (!paint_taskflow) paint_taskflow = std::make_unique<tf::Taskflow>();
     auto& taskflow = *paint_taskflow;
-    aethera::detail::clear_stage_observers(&taskflow);
     taskflow.clear();
     const auto dependencies = object->template current_dependency_graph<Paint_Tag>();
     paint_order.clear();
@@ -139,7 +143,7 @@ void Render_Scene_2D::Private::after_advance(Object* object, Prop*, State_Access
         auto& data = *paint_node.private_data;
         auto* dispatch = data.dispatch;
         auto paint_if = taskflow.emplace([this, &data, dispatch, root, index] {
-            auto& state = *dispatch->state.get(root);
+            auto& state = *dispatch->state.pending(root);
             state.paint_graph_rebuilt = false;
             state.paint_execution_time_ns = 0;
             if (dispatch->paint.builder) {
@@ -155,6 +159,11 @@ void Render_Scene_2D::Private::after_advance(Object* object, Prop*, State_Access
             const bool dirty = root->template dirty<Paint_Tag>();
             state.paint_dirty = dirty;
             state.paint_executed = paint_order[index].paint_requested && dispatch->paint.predicate(root, dirty);
+            if (state.paint_executed) {
+                state.paint_execution_time_ns = static_cast<std::uint64_t>(
+                    std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::steady_clock::now().time_since_epoch()).count());
+            }
             return state.paint_executed ? 0 : 1;
         }).name("render_2d.paint.condition");
         tf::Task paint_run;
@@ -162,16 +171,23 @@ void Render_Scene_2D::Private::after_advance(Object* object, Prop*, State_Access
             if (!data.paint_graph) data.paint_graph = std::make_unique<tf::Taskflow>();
             paint_run = taskflow.composed_of(*data.paint_graph).name("render_2d.paint.graph");
         } else paint_run = taskflow.emplace([dispatch, root] { if (dispatch->paint.run) dispatch->paint.run(root); }).name("render_2d.paint.data");
+        auto paint_extension = taskflow.composed_of(data.paint_extension)
+            .name("renderable.paint.extension");
         auto paint_done = taskflow.emplace([dispatch, root] {
-            auto& state = *dispatch->state.get(root);
-            if (state.paint_executed) root->template take_dirty<Paint_Tag>();
-            dispatch->state.notify(root);
+            auto& state = *dispatch->state.pending(root);
+            if (state.paint_executed) {
+                root->template take_dirty<Paint_Tag>();
+                const auto finished = static_cast<std::uint64_t>(
+                    std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::steady_clock::now().time_since_epoch()).count());
+                state.paint_execution_time_ns = finished - state.paint_execution_time_ns;
+            }
+            dispatch->state.publish(root);
         }).name("render_2d.paint.complete");
         paint_if.precede(paint_run, paint_done);
-        paint_run.precede(paint_done);
+        paint_run.precede(paint_extension);
+        paint_extension.precede(paint_done);
         if (has_previous) previous.precede(paint_if);
-        aethera::detail::bind_stage_observer(&taskflow, paint_if.hash_value(), root, &data, aethera::detail::Renderable_Stage::Paint, aethera::detail::Stage_Observer_Point::Begin);
-        aethera::detail::bind_stage_observer(&taskflow, paint_done.hash_value(), root, &data, aethera::detail::Renderable_Stage::Paint, aethera::detail::Stage_Observer_Point::End);
         previous = paint_done;
         if (paint_node.cache_group_last) {
             Root* cache_owner = paint_node.cache_owner;
@@ -283,6 +299,22 @@ void Render_Scene_2D::Private::process(Object* object, Callback&& callback)
 template <Attached Object>
 Render_Scene_2D::Render_Result Render_Scene_2D::Private::render(Object* object, Frame_2D* frame) {
     static_cast<void>(detail::Frame_2D_Access::render_target(frame));
+    Frame_Callback callback;
+    {
+        std::lock_guard lock(render_mutex);
+        if (!frame_callback)
+            throw std::logic_error("Render_Scene_2D requires a frame callback before render");
+        if (frame_in_flight) return Render_Result::frame_in_flight;
+        frame_in_flight = true;
+        callback = frame_callback;
+    }
+    struct Admission_Scope {
+        Private& data;
+        ~Admission_Scope() {
+            std::lock_guard lock(data.render_mutex);
+            data.frame_in_flight = false;
+        }
+    } admission{*this};
     frame->mark(Frame_Trace_Marker::scene_render_requested);
     struct Active_Frame_Scope {
         Frame_2D*& target;                                  /* 最终 Private 的同步 process 帧槽位。 */
@@ -294,8 +326,10 @@ Render_Scene_2D::Render_Result Render_Scene_2D::Private::render(Object* object,
     object->process([&] {
         completed = true;
         frame->mark(Frame_Trace_Marker::scene_render_finished);
+        /* 帧准入直到 completion 图和最终回调都结束才释放，因此图运行期间外部帧不会被下一帧复用。 */
+        if (!completion_graph.empty()) aethera::detail::run_taskflow(completion_graph);
         frame->mark(Frame_Trace_Marker::callback_started);
-        if (frame_callback) frame_callback(frame);
+        callback(frame);
         frame->mark(Frame_Trace_Marker::callback_finished);
     });
     if (completed) return Render_Result::completed;
@@ -339,7 +373,9 @@ const Render_Scene_2D::Private::Dispatch& Render_Scene_2D::Private::dispatch_for
         },
         [](Root* root, Frame_Callback callback) {
             auto* object = static_cast<Object*>(root);
-            static_cast<typename Object::Private&>(*object->d).frame_callback = std::move(callback);
+            auto& data = static_cast<typename Object::Private&>(*object->d);
+            std::lock_guard lock(data.render_mutex);
+            data.frame_callback = std::move(callback);
         },
         [](Root* root, bool active) { static_cast<Object*>(root)->template set<&Prop::view_active>(active); }
     };
diff --git a/render_2D/tests/Axis_Test.cpp b/render_2D/tests/Axis_Test.cpp
index 32e3b96..c50d842 100644
--- a/render_2D/tests/Axis_Test.cpp
+++ b/render_2D/tests/Axis_Test.cpp
@@ -17,6 +17,7 @@ template <typename Scene>
 std::unique_ptr<Frame_2D> render_frame(Scene* scene) {
     static std::uint64_t sequence{1};
     auto frame = std::make_unique<Frame_2D>(Frame_Identity{sequence++, 0});
+    scene->set_frame_callback([](Frame_2D*) {});
     EXPECT_EQ(scene->render(frame.get()), Render_Scene_2D::Render_Result::completed);
     return frame;
 }
@@ -92,7 +93,17 @@ TEST(axis_render, scene_prepares_and_paints_uncached_axis_into_frame) {
         prepare.add(axis.get());
         paint.add(axis.get());
     }).has_value()));
+    int paint_extension_calls{};
+    int completion_calls{};
+    axis->paint_taskflow().emplace(
+        [&] { ++paint_extension_calls; }).name("test.axis.paint.extension");
+    scene->completion_taskflow().emplace([&] {
+        EXPECT_EQ(paint_extension_calls, 1);
+        ++completion_calls;
+    }).name("test.scene_2d.completion");
     const auto frame = render_frame(scene.get());
+    EXPECT_EQ(paint_extension_calls, 1);
+    EXPECT_EQ(completion_calls, 1);
     const Image_View view = frame->image();
     ASSERT_FALSE(view.empty());
     bool contains_color{};
diff --git a/render_2D/tests/Plottable_Migration_Test.cpp b/render_2D/tests/Plottable_Migration_Test.cpp
index f10b5dd..c74b7f3 100644
--- a/render_2D/tests/Plottable_Migration_Test.cpp
+++ b/render_2D/tests/Plottable_Migration_Test.cpp
@@ -35,6 +35,7 @@ template <typename Scene>
 void render_once(Scene* scene) {
     static std::uint64_t sequence{1};
     Frame_2D frame{Frame_Identity{sequence++, 0}};
+    scene->set_frame_callback([](Frame_2D*) {});
     EXPECT_EQ(scene->render(&frame), Render_Scene_2D::Render_Result::completed);
 }
 }
diff --git a/render_2D/tests/Spectrum_Test.cpp b/render_2D/tests/Spectrum_Test.cpp
index de4abef..c919429 100644
--- a/render_2D/tests/Spectrum_Test.cpp
+++ b/render_2D/tests/Spectrum_Test.cpp
@@ -32,6 +32,7 @@ template <typename Scene>
 std::unique_ptr<Frame_2D> render_frame(Scene* scene) {
     static std::uint64_t sequence{1};
     auto frame = std::make_unique<Frame_2D>(Frame_Identity{sequence++, 0});
+    scene->set_frame_callback([](Frame_2D*) {});
     EXPECT_EQ(scene->render(frame.get()), Render_Scene_2D::Render_Result::completed);
     return frame;
 }
diff --git a/render_3D/render_3D/Gpu_Completion_State.cpp b/render_3D/render_3D/Gpu_Completion_State.cpp
new file mode 100644
index 0000000..5a173e0
--- /dev/null
+++ b/render_3D/render_3D/Gpu_Completion_State.cpp
@@ -0,0 +1,8 @@
+#include "Gpu_Completion_State.hpp"
+#include "detail/Gpu_Completion_Service.hpp"
+
+namespace aethera::render_3d {
+Gpu_Completion_State gpu_completion_state() noexcept {
+    return detail::Gpu_Completion_Service::instance().state();
+}
+}
diff --git a/render_3D/render_3D/Gpu_Completion_State.hpp b/render_3D/render_3D/Gpu_Completion_State.hpp
new file mode 100644
index 0000000..274256c
--- /dev/null
+++ b/render_3D/render_3D/Gpu_Completion_State.hpp
@@ -0,0 +1,38 @@
+#pragma once
+#include <render_common.hpp>
+#include <cstddef>
+#include <cstdint>
+
+namespace aethera::render_3d {
+struct Gpu_Completion_State_Tag {};
+
+/* 只由 GPU Completion Domain 写入并通过双缓冲发布。 */
+struct Gpu_Completion_State : State_Type<Gpu_Completion_State_Tag> {
+    std::size_t capacity{};
+    std::size_t in_flight{};
+    std::size_t peak_in_flight{};
+    std::size_t watched{};
+    std::size_t peak_watched{};
+    std::size_t active_fences{};
+    std::size_t pending_fences{};
+    std::uint64_t reservation_count{};
+    std::uint64_t completion_count{};
+    std::uint64_t cancellation_count{};
+    std::uint64_t fence_probe_count{};
+    std::uint64_t fence_wait_count{};
+    std::uint64_t fence_wait_timeout_count{};
+    std::uint64_t fence_wait_total_ns{};
+    std::uint64_t fence_wait_max_ns{};
+    std::uint64_t callback_total_ns{};
+    std::uint64_t callback_max_ns{};
+    std::uint64_t callback_failure_count{};
+    std::uint64_t backpressure_count{};
+    std::uint64_t backpressure_wait_ns{};
+    std::uint64_t fault_count{};
+    std::uint64_t abandoned_count{};
+    bool stopping{};
+    bool operator==(const Gpu_Completion_State&) const = default;
+};
+
+[[nodiscard]] Gpu_Completion_State gpu_completion_state() noexcept;
+}
diff --git a/render_3D/render_3D/detail/Async_Render_Backend.cpp b/render_3D/render_3D/detail/Async_Render_Backend.cpp
index fbb3efd..bc39463 100644
--- a/render_3D/render_3D/detail/Async_Render_Backend.cpp
+++ b/render_3D/render_3D/detail/Async_Render_Backend.cpp
@@ -2,11 +2,12 @@
 #include "Datoviz_Visual_Backend.hpp"
 #include "Gpu_Completion_Service.hpp"
 #include "Render_Domain.hpp"
-#include <concurrentqueue-1.0.5/blockingconcurrentqueue.h>
 #include <algorithm>
 #include <atomic>
 #include <cmath>
 #include <cstdio>
+#include <functional>
+#include <deque>
 #include <iterator>
 #include <limits>
 #include <mutex>
@@ -85,17 +86,15 @@ struct Async_Render_Backend::Implementation
         std::optional<Gpu_Completion_Service::Result> result{}; /* fence 正常交付时的结果。 */
         std::exception_ptr failure{};                        /* 提交域或完成服务的 Unknown Failure。 */
     };
-    using Command = std::variant<Submission, Gpu_Completion>;
+    struct Stop {};
+    using Command = std::variant<Submission, Gpu_Completion, Stop>;
 
-    static constexpr std::size_t command_capacity = 64;
     std::shared_ptr<Render_Domain> render_domain;            /* 同 GPU 唯一的轻量 Queue Submit 域。 */
-    std::unique_ptr<Datoviz_Visual_Backend> backend{};       /* 仅准备线程构造、准备、收集和销毁。 */
-    std::uint32_t gpu_index{};                              /* Datoviz 共享 GPU Context 的设备下标。 */
-    bool validation_enabled{};                             /* 是否启用 Vulkan 验证。 */
-    std::vector<Visual_Registration> visual_registrations{}; /* 首帧初始化后释放的稳定 Visual 注册表。 */
-    moodycamel::BlockingConcurrentQueue<Command> commands{command_capacity}; /* 多生产者到单准备线程的命令入口。 */
-    std::thread preparation_thread{};                       /* 每 Scene 独立的 Datoviz CPU 准备域。 */
+    std::unique_ptr<Datoviz_Visual_Backend> backend{};       /* Builder build() 创建；随后由本 Scene 串行使用。 */
     std::optional<Submission> deferred_submission{};        /* 三槽占满时仅保留的最新画面和历史回调。 */
+    std::mutex command_mutex{};                             /* 只保护本 Scene 的入队和 drain 所有权。 */
+    std::deque<Command> commands{};                         /* 不同 Scene 可并行，同一 Scene 保持严格串行。 */
+    bool drain_scheduled{};                                /* 是否已有 Taskflow worker 负责本 Scene。 */
     std::mutex callback_mutex{};                            /* 保护完成回调替换与 render 捕获。 */
     Frame_Callback frame_callback{};                       /* 后续 render 捕获的完成出口。 */
     std::mutex failure_mutex{};                             /* 保护跨线程传播的最后 Unknown Failure。 */
@@ -106,19 +105,19 @@ struct Async_Render_Backend::Implementation
 
     Implementation(std::uint32_t gpu_index_value,
                    bool validation_enabled_value,
-                   std::vector<Visual_Registration> visuals)
+                   std::vector<Visual_Registration> visuals,
+                   const Scene_3D_Parameters& initial_scene)
         : render_domain(Render_Domain::acquire(gpu_index_value)),
-          gpu_index(gpu_index_value),
-          validation_enabled(validation_enabled_value),
-          visual_registrations(std::move(visuals)) {}
+          backend(std::make_unique<Datoviz_Visual_Backend>(
+              gpu_index_value, validation_enabled_value, visuals, initial_scene)) {}
     ~Implementation();
 
-    void start();
     void stop() noexcept;
-    void run() noexcept;
     void fail(std::exception_ptr value) noexcept;
     void enqueue(Command command);
-    void initialize(const Scene_3D_Parameters& parameters);
+    void drain() noexcept;
+    void execute(Command command) noexcept;
+    void finish_stop();
     [[nodiscard]] Async_Render_Backend::Submit_Result render(
         Shared_Prepared_Visual_Batch visuals, Scene_3D_Parameters parameters,
         Frame_3D* frame, Scene::Event_Batch events);
@@ -135,35 +134,28 @@ struct Async_Render_Backend::Implementation
 
 Async_Render_Backend::Async_Render_Backend(
     std::uint32_t gpu_index, bool validation_enabled,
-    std::vector<Visual_Registration> visuals)
+    std::vector<Visual_Registration> visuals,
+    const Scene_3D_Parameters& initial_scene)
     : implementation_(std::make_shared<Implementation>(
-          gpu_index, validation_enabled, std::move(visuals))) {
-    implementation_->start();
-}
+          gpu_index, validation_enabled, std::move(visuals), initial_scene)) {}
 Async_Render_Backend::~Async_Render_Backend() {
     implementation_->stop();
 }
 
 Async_Render_Backend::Implementation::~Implementation() {
     stop();
-    if (preparation_thread.joinable() &&
-        preparation_thread.get_id() == std::this_thread::get_id())
-        preparation_thread.detach();
-}
-void Async_Render_Backend::Implementation::start() {
-    auto self = shared_from_this();
-    preparation_thread = std::thread([self = std::move(self)] { self->run(); });
 }
 
 void Async_Render_Backend::Implementation::stop() noexcept {
+    if (stop_requested.exchange(true, std::memory_order_acq_rel)) return;
     {
         std::lock_guard lock(admission_mutex);
         available.store(false, std::memory_order_release);
-        stop_requested.store(true, std::memory_order_release);
     }
-    if (preparation_thread.joinable() &&
-        preparation_thread.get_id() != std::this_thread::get_id())
-        preparation_thread.join();
+    try {
+        enqueue(Stop{});
+    }
+    catch (...) { fail(std::current_exception()); }
 }
 void Async_Render_Backend::Implementation::fail(
     std::exception_ptr value) noexcept {
@@ -182,15 +174,33 @@ void Async_Render_Backend::Implementation::fail(
     catch (...) {}
 }
 void Async_Render_Backend::Implementation::enqueue(Command command) {
-    if (!commands.enqueue(std::move(command))) throw std::bad_alloc{};
+    bool schedule{};
+    {
+        std::lock_guard lock(command_mutex);
+        commands.push_back(std::move(command));
+        if (!drain_scheduled) {
+            drain_scheduled = true;
+            schedule = true;
+        }
+    }
+    if (!schedule) return;
+    auto self = shared_from_this();
+    aethera::schedule_task([self] { self->drain(); });
 }
-void Async_Render_Backend::Implementation::initialize(
-    const Scene_3D_Parameters& parameters) {
-    if (backend) return;
-    backend = std::make_unique<Datoviz_Visual_Backend>(
-        gpu_index, validation_enabled, visual_registrations, parameters);
-    visual_registrations.clear();
-    visual_registrations.shrink_to_fit();
+void Async_Render_Backend::Implementation::drain() noexcept {
+    for (;;) {
+        std::optional<Command> command;
+        {
+            std::lock_guard lock(command_mutex);
+            if (commands.empty()) {
+                drain_scheduled = false;
+                break;
+            }
+            command.emplace(std::move(commands.front()));
+            commands.pop_front();
+        }
+        execute(std::move(*command));
+    }
 }
 Async_Render_Backend::Submit_Result
 Async_Render_Backend::Implementation::render(
@@ -254,7 +264,6 @@ void Async_Render_Backend::Implementation::accept(Submission submission) {
 void Async_Render_Backend::Implementation::prepare(Submission submission) {
     std::optional<Datoviz_Visual_Backend::Pending_Frame> prepared;
     try {
-        initialize(submission.parameters);
         for (const auto& event : submission.events)
             dispatch(event, submission.parameters.viewport);
         submission.events.clear();
@@ -492,52 +501,42 @@ void Async_Render_Backend::Implementation::dispatch(
     if ((wheel && pointer_valid) || pointer_valid || key) event->accept();
     event->mark_dispatch_completed();
 }
-void Async_Render_Backend::Implementation::run() noexcept {
-    for (;;) {
-        Command command;
-        const bool received = commands.wait_dequeue_timed(
-            command, std::chrono::milliseconds(10));
-        if (received) {
-            try {
-                if (auto* submission = std::get_if<Submission>(&command)) {
-                    accept(std::move(*submission));
-                }
-                else if (auto* completion = std::get_if<Gpu_Completion>(&command))
-                    finish(std::move(*completion));
-            }
-            catch (...) {
-                fail(std::current_exception());
-                if (auto* submission = std::get_if<Submission>(&command)) {
-                    auto pending = std::make_shared<Pending>();
-                    pending->extent = submission->parameters.viewport;
-                    pending->completions = std::move(submission->completions);
-                    try { resolve(std::move(pending), std::nullopt); }
-                    catch (...) { fail(std::current_exception()); }
-                }
-                else if (auto* completion = std::get_if<Gpu_Completion>(&command)) {
-                    try { resolve(std::move(completion->pending), std::nullopt); }
-                    catch (...) { fail(std::current_exception()); }
-                }
-            }
+void Async_Render_Backend::Implementation::execute(Command command) noexcept {
+    try {
+        if (auto* submission = std::get_if<Submission>(&command))
+            accept(std::move(*submission));
+        else if (auto* completion = std::get_if<Gpu_Completion>(&command))
+            finish(std::move(*completion));
+        else
+            finish_stop();
+    }
+    catch (...) {
+        fail(std::current_exception());
+        if (auto* submission = std::get_if<Submission>(&command)) {
+            auto pending = std::make_shared<Pending>();
+            pending->extent = submission->parameters.viewport;
+            pending->completions = std::move(submission->completions);
+            try { resolve(std::move(pending), std::nullopt); }
+            catch (...) { fail(std::current_exception()); }
         }
-        // render/event 与 stop 共享 admission_mutex，因此停止后只有已经
-        // 提交到 GPU 的完成通知还能到达。只有一次真实的 timed dequeue
-        // 为空且 backend 已无在途目标，准备域才完成排空并退出。
-        if (!received && stop_requested.load(std::memory_order_acquire) &&
-            (!backend || backend->idle())) {
-            if (deferred_submission) {
-                auto pending = std::make_shared<Pending>();
-                pending->extent = deferred_submission->parameters.viewport;
-                pending->completions =
-                    std::move(deferred_submission->completions);
-                deferred_submission.reset();
-                try { resolve(std::move(pending), std::nullopt); }
-                catch (...) { fail(std::current_exception()); }
-            }
-            backend.reset();
-            return;
+        else if (auto* completion = std::get_if<Gpu_Completion>(&command)) {
+            try { resolve(std::move(completion->pending), std::nullopt); }
+            catch (...) { fail(std::current_exception()); }
         }
     }
+    if (stop_requested.load(std::memory_order_acquire)) finish_stop();
+}
+
+void Async_Render_Backend::Implementation::finish_stop() {
+    if (deferred_submission) {
+        auto pending = std::make_shared<Pending>();
+        pending->extent = deferred_submission->parameters.viewport;
+        pending->completions = std::move(deferred_submission->completions);
+        deferred_submission.reset();
+        resolve(std::move(pending), std::nullopt);
+    }
+    if (backend && !backend->idle()) return;
+    backend.reset();
 }
 
 Async_Render_Backend::Submit_Result Async_Render_Backend::render(
diff --git a/render_3D/render_3D/detail/Async_Render_Backend.hpp b/render_3D/render_3D/detail/Async_Render_Backend.hpp
index d289fec..e9a2ee9 100644
--- a/render_3D/render_3D/detail/Async_Render_Backend.hpp
+++ b/render_3D/render_3D/detail/Async_Render_Backend.hpp
@@ -13,7 +13,8 @@ public:
         backend_unavailable
     };
     Async_Render_Backend(std::uint32_t gpu_index, bool validation_enabled,
-                         std::vector<Visual_Registration> visuals);
+                         std::vector<Visual_Registration> visuals,
+                         const Scene_3D_Parameters& initial_scene);
     ~Async_Render_Backend();
     Async_Render_Backend(const Async_Render_Backend&) = delete;
     Async_Render_Backend& operator=(const Async_Render_Backend&) = delete;
diff --git a/render_3D/render_3D/detail/Datoviz_Visual_Backend.cpp b/render_3D/render_3D/detail/Datoviz_Visual_Backend.cpp
index f56b4f4..3cbb583 100644
--- a/render_3D/render_3D/detail/Datoviz_Visual_Backend.cpp
+++ b/render_3D/render_3D/detail/Datoviz_Visual_Backend.cpp
@@ -814,8 +814,7 @@ Datoviz_Visual_Backend::Datoviz_Visual_Backend(
     std::uint32_t gpu_index, bool validation_enabled,
     const std::vector<Visual_Registration>& visuals,
     const Scene_3D_Parameters& initial_scene)
-    : preparation_thread_(std::this_thread::get_id()),
-      targets_(std::make_unique<Frame_Targets>()) {
+    : targets_(std::make_unique<Frame_Targets>()) {
     try {
         render_context_ = Datoviz_Render_Context::acquire(gpu_index, validation_enabled);
         std::scoped_lock context_lock(render_context_->api_mutex(),
@@ -842,11 +841,6 @@ Datoviz_Visual_Backend::~Datoviz_Visual_Backend() noexcept {
     try { destroy(); }
     catch (...) { abandon_resources(); }
 }
-void Datoviz_Visual_Backend::require_domain() const {
-    if (std::this_thread::get_id() != preparation_thread_)
-        throw std::logic_error(
-            "Datoviz Scene preparation may only run on its preparation thread");
-}
 void Datoviz_Visual_Backend::create_scene(
     const std::vector<Visual_Registration>& registrations,
     const Scene_3D_Parameters& initial_scene) {
@@ -1327,7 +1321,6 @@ bool Datoviz_Visual_Backend::matches_command_structure(
 void Datoviz_Visual_Backend::apply(
     const Scene_3D_Parameters& scene, const Prepared_Visual_Batch& prepared,
     std::uint8_t target_index, bool bind_target) {
-    require_domain();
     if (figure_extent_ != scene.viewport) {
         if (dvz_figure_resize(figure_, scene.viewport.width,
                               scene.viewport.height) != DVZ_OK)
@@ -1747,7 +1740,6 @@ void Datoviz_Visual_Backend::dispatch_pointer(
     ::aethera::Event_Type event, float x, float y,
     ::aethera::Mouse_Button mouse_button,
     ::aethera::Keyboard_Modifier keyboard_modifiers, Extent viewport) {
-    require_domain();
     std::lock_guard api_lock(render_context_->api_mutex());
     input_changed_ = true;
     if (applied_camera_ && applied_camera_->controller == Camera_Controller::turntable) {
@@ -1773,7 +1765,6 @@ void Datoviz_Visual_Backend::dispatch_pointer(
 void Datoviz_Visual_Backend::dispatch_wheel(
     float x, float y, float delta_x, float delta_y,
     ::aethera::Keyboard_Modifier keyboard_modifiers, Extent viewport) {
-    require_domain();
     std::lock_guard api_lock(render_context_->api_mutex());
     input_changed_ = true;
     if (applied_camera_ &&
@@ -1786,7 +1777,6 @@ void Datoviz_Visual_Backend::dispatch_wheel(
 }
 void Datoviz_Visual_Backend::dispatch_key(
     const ::aethera::Key_Event& event) {
-    require_domain();
     std::lock_guard api_lock(render_context_->api_mutex());
     input_changed_ = true;
     if (event.key == ::aethera::Key::home && event.type == ::aethera::Event_Type::key_press) {
@@ -1936,7 +1926,6 @@ Datoviz_Visual_Backend::reuse_recorded_target(
 std::optional<Datoviz_Visual_Backend::Pending_Frame> Datoviz_Visual_Backend::prepare(
     const Scene_3D_Parameters& scene, const Prepared_Visual_Batch& visuals,
     std::uint64_t frame_sequence, bool observe, bool readback) {
-    require_domain();
     if (scene.viewport.empty()) return std::nullopt;
     if (auto reused = reuse_recorded_target(
             scene, visuals, frame_sequence, observe, readback))
@@ -2097,7 +2086,6 @@ void Datoviz_Visual_Backend::submit(Pending_Frame& pending) {
 }
 Datoviz_Visual_Backend::Completed_Frame Datoviz_Visual_Backend::collect(
     Pending_Frame pending) {
-    require_domain();
     /* Fence 已完成，读回缓冲与查询池只属于本目标槽；不同 Scene 的映射内存
      * 下载可以并行，且不能反向阻塞 Render_Domain 的下一批提交。 */
     std::lock_guard target_lock(target_mutex_);
@@ -2110,7 +2098,6 @@ Datoviz_Visual_Backend::Completed_Frame Datoviz_Visual_Backend::collect(
     return {pending.extent, std::move(collection.pixels), std::move(pending.trace)};
 }
 void Datoviz_Visual_Backend::discard(Pending_Frame pending) {
-    require_domain();
     std::lock_guard target_lock(target_mutex_);
     target(pending).discard_after_completion();
 }
@@ -2157,9 +2144,6 @@ void Datoviz_Visual_Backend::abandon_resources() noexcept {
     retain_quarantined_context(render_context_);
 }
 void Datoviz_Visual_Backend::destroy() {
-    if (std::this_thread::get_id() != preparation_thread_)
-        throw std::logic_error(
-            "Datoviz backend may only be destroyed on its preparation thread");
     if (quarantined_) {
         abandon_resources();
         return;
diff --git a/render_3D/render_3D/detail/Datoviz_Visual_Backend.hpp b/render_3D/render_3D/detail/Datoviz_Visual_Backend.hpp
index 831469e..1816dce 100644
--- a/render_3D/render_3D/detail/Datoviz_Visual_Backend.hpp
+++ b/render_3D/render_3D/detail/Datoviz_Visual_Backend.hpp
@@ -79,7 +79,6 @@ private:
         std::optional<Prepared_Visual> applied{};            /* Last applied metadata and immutable payload snapshot. */
         std::vector<External_Attribute> attributes{};        /* Dynamic payload buffers, one triple region per field. */
     };
-    void require_domain() const;
     void create_scene(const std::vector<Visual_Registration>& visuals,
                       const Scene_3D_Parameters& initial_scene);
     [[nodiscard]] DvzVisual* create_visual(Visual_Family family);
@@ -112,7 +111,6 @@ private:
     [[nodiscard]] Frame_Target& target(const Pending_Frame& pending);
     void abandon_resources() noexcept;
     void destroy();
-    std::thread::id preparation_thread_;                     /* Scene API、资源准备与回收的唯一线程。 */
     std::shared_ptr<Datoviz_Render_Context> render_context_; /* 同一 GPU 上所有后端共享的 Device 与分配器。 */
     mutable std::mutex target_mutex_{};                     /* 当前 Scene 三个目标槽的唯一生命周期同步源。 */
     struct Runtime_Slot {
diff --git a/render_3D/render_3D/detail/Gpu_Completion_Service.cpp b/render_3D/render_3D/detail/Gpu_Completion_Service.cpp
index f10d1d5..b4d3af0 100644
--- a/render_3D/render_3D/detail/Gpu_Completion_Service.cpp
+++ b/render_3D/render_3D/detail/Gpu_Completion_Service.cpp
@@ -10,6 +10,7 @@ Gpu_Completion_Service& Gpu_Completion_Service::instance() {
     return service;
 }
 Gpu_Completion_Service::Gpu_Completion_Service() {
+    publish_state(0, 0);
     thread_ = std::thread([this] {
         run();
     });
@@ -62,6 +63,13 @@ void Gpu_Completion_Service::update_peak(std::atomic_size_t& peak,
         !peak.compare_exchange_weak(current, value,
                                     std::memory_order_relaxed)) {}
 }
+void Gpu_Completion_Service::update_max(std::atomic_uint64_t& maximum,
+                                        std::uint64_t value) noexcept {
+    std::uint64_t current = maximum.load(std::memory_order_relaxed);
+    while (current < value &&
+        !maximum.compare_exchange_weak(current, value,
+                                       std::memory_order_relaxed)) {}
+}
 void Gpu_Completion_Service::cancel_reserved(
     const std::shared_ptr<Pending_Fence>& pending) {
     if (!pending) return;
@@ -112,21 +120,42 @@ Gpu_Completion_Service::Prepare_Result Gpu_Completion_Service::prepare(
         release_slot();
         throw;
     }
+    reservation_count_.fetch_add(1, std::memory_order_relaxed);
     wake();
     return {Reservation(std::move(pending)), Admission_Result::none};
 }
-Gpu_Completion_Service::Statistics Gpu_Completion_Service::statistics() const noexcept {
-    return {
-        static_cast<std::size_t>(default_capacity),
-        in_flight_.load(std::memory_order_relaxed),
-        peak_in_flight_.load(std::memory_order_relaxed),
-        watched_.load(std::memory_order_relaxed),
-        peak_watched_.load(std::memory_order_relaxed),
-        backpressure_count_.load(std::memory_order_relaxed),
-        backpressure_wait_ns_.load(std::memory_order_relaxed),
-        fault_count_.load(std::memory_order_relaxed),
-        abandoned_count_.load(std::memory_order_relaxed)
-    };
+Gpu_Completion_State Gpu_Completion_Service::state() const noexcept {
+    std::lock_guard lock(state_mutex_);
+    return *state_.pending;
+}
+void Gpu_Completion_Service::publish_state(std::size_t active_fences,
+                                           std::size_t pending_fences) noexcept {
+    std::lock_guard lock(state_mutex_);
+    auto& state = *state_.current;
+    state.capacity = static_cast<std::size_t>(default_capacity);
+    state.in_flight = in_flight_.load(std::memory_order_relaxed);
+    state.peak_in_flight = peak_in_flight_.load(std::memory_order_relaxed);
+    state.watched = watched_.load(std::memory_order_relaxed);
+    state.peak_watched = peak_watched_.load(std::memory_order_relaxed);
+    state.active_fences = active_fences;
+    state.pending_fences = pending_fences;
+    state.reservation_count = reservation_count_.load(std::memory_order_relaxed);
+    state.completion_count = completion_count_.load(std::memory_order_relaxed);
+    state.cancellation_count = cancellation_count_.load(std::memory_order_relaxed);
+    state.fence_probe_count = fence_probe_count_.load(std::memory_order_relaxed);
+    state.fence_wait_count = fence_wait_count_.load(std::memory_order_relaxed);
+    state.fence_wait_timeout_count = fence_wait_timeout_count_.load(std::memory_order_relaxed);
+    state.fence_wait_total_ns = fence_wait_total_ns_.load(std::memory_order_relaxed);
+    state.fence_wait_max_ns = fence_wait_max_ns_.load(std::memory_order_relaxed);
+    state.callback_total_ns = callback_total_ns_.load(std::memory_order_relaxed);
+    state.callback_max_ns = callback_max_ns_.load(std::memory_order_relaxed);
+    state.callback_failure_count = callback_failure_count_.load(std::memory_order_relaxed);
+    state.backpressure_count = backpressure_count_.load(std::memory_order_relaxed);
+    state.backpressure_wait_ns = backpressure_wait_ns_.load(std::memory_order_relaxed);
+    state.fault_count = fault_count_.load(std::memory_order_relaxed);
+    state.abandoned_count = abandoned_count_.load(std::memory_order_relaxed);
+    state.stopping = stopping_.load(std::memory_order_relaxed);
+    state_.advance();
 }
 void Gpu_Completion_Service::wake() noexcept {
     wake_generation_.fetch_add(1, std::memory_order_release);
@@ -141,6 +170,7 @@ void Gpu_Completion_Service::run() noexcept {
     try {
     active.reserve(static_cast<std::size_t>(default_capacity));
     std::size_t wait_group_index{};
+    auto last_state_publication = std::chrono::steady_clock::time_point{};
     const auto wait_age_ns = [](std::chrono::steady_clock::time_point started) {
         const auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
             std::chrono::steady_clock::now() - started)
@@ -176,14 +206,24 @@ void Gpu_Completion_Service::run() noexcept {
             fault_count_.fetch_add(1, std::memory_order_relaxed);
             abandoned_count_.fetch_add(1, std::memory_order_relaxed);
         }
+        const auto callback_started = std::chrono::steady_clock::now();
         try { completion(std::move(completion_result)); }
         catch (...) {
+            callback_failure_count_.fetch_add(1, std::memory_order_relaxed);
             try {
                 on_exception(contextual_exception(
                     "delivering GPU completion", std::current_exception()));
             }
             catch (...) {}
         }
+        const auto callback_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now() - callback_started).count();
+        if (callback_elapsed > 0) {
+            const auto elapsed = static_cast<std::uint64_t>(callback_elapsed);
+            callback_total_ns_.fetch_add(elapsed, std::memory_order_relaxed);
+            update_max(callback_max_ns_, elapsed);
+        }
+        completion_count_.fetch_add(1, std::memory_order_relaxed);
         }
         catch (...) {
             try {
@@ -200,6 +240,7 @@ void Gpu_Completion_Service::run() noexcept {
         wake_generation_.load(std::memory_order_acquire);
         { std::lock_guard lock(pending_mutex_); while (!pending_.empty()) { active.push_back(std::move(pending_.front())); pending_.pop_front(); } }
         std::vector<Device_Fences> groups;
+        std::size_t reserved_count{};
         for (auto iterator = active.begin(); iterator != active.end();) {
             Pending_Fence::Status status;
             VkDevice device{VK_NULL_HANDLE};
@@ -215,9 +256,11 @@ void Gpu_Completion_Service::run() noexcept {
                     stopping_.load(std::memory_order_acquire))) {
                 cancel_reserved(*iterator);
                 iterator = active.erase(iterator);
+                cancellation_count_.fetch_add(1, std::memory_order_relaxed);
                 release_slot();
                 continue;
             }
+            if (status == Pending_Fence::Status::reserved) ++reserved_count;
             if (status == Pending_Fence::Status::watched) {
                 auto group = std::find_if(
                     groups.begin(), groups.end(),
@@ -232,9 +275,19 @@ void Gpu_Completion_Service::run() noexcept {
             }
             ++iterator;
         }
+        const auto publication_time = std::chrono::steady_clock::now();
+        if (last_state_publication == std::chrono::steady_clock::time_point{} ||
+            publication_time - last_state_publication >= state_publication_interval) {
+            // 域内只按诊断粒度发布双缓冲 State；逐 fence 热路径只更新原子计数。
+            publish_state(active.size(), reserved_count);
+            last_state_publication = publication_time;
+        }
         bool pending_empty;
         { std::lock_guard lock(pending_mutex_); pending_empty = pending_.empty(); }
-        if (stopping_.load(std::memory_order_acquire) && active.empty() && pending_empty) return;
+        if (stopping_.load(std::memory_order_acquire) && active.empty() && pending_empty) {
+            publish_state(0, 0);
+            return;
+        }
         // Probe every watched fence first. A permanently unsignaled fence is
         // converted into a logical failure after a bounded interval. The
         // submission is explicitly marked abandoned so its owner can
@@ -270,6 +323,7 @@ void Gpu_Completion_Service::run() noexcept {
                 completed_any = true;
                 continue;
             }
+            fence_probe_count_.fetch_add(1, std::memory_order_relaxed);
             const VkResult result = vkGetFenceStatus(device, fence);
             if (result == VK_NOT_READY) {
                 ++iterator;
@@ -296,9 +350,20 @@ void Gpu_Completion_Service::run() noexcept {
         }
         wait_group_index %= groups.size();
         const Device_Fences& group = groups[wait_group_index++];
+        const auto wait_started = std::chrono::steady_clock::now();
+        fence_wait_count_.fetch_add(1, std::memory_order_relaxed);
         const VkResult wait_result = vkWaitForFences(
             group.device, static_cast<std::uint32_t>(group.fences.size()),
             group.fences.data(), VK_FALSE, fence_wait_timeout_ns);
+        const auto wait_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now() - wait_started).count();
+        if (wait_elapsed > 0) {
+            const auto elapsed = static_cast<std::uint64_t>(wait_elapsed);
+            fence_wait_total_ns_.fetch_add(elapsed, std::memory_order_relaxed);
+            update_max(fence_wait_max_ns_, elapsed);
+        }
+        if (wait_result == VK_TIMEOUT)
+            fence_wait_timeout_count_.fetch_add(1, std::memory_order_relaxed);
         for (auto iterator = active.begin(); iterator != active.end();) {
             VkDevice device{VK_NULL_HANDLE};
             VkFence fence{VK_NULL_HANDLE};
@@ -315,7 +380,10 @@ void Gpu_Completion_Service::run() noexcept {
                 continue;
             }
             VkResult result = wait_result;
-            if (wait_result == VK_SUCCESS || wait_result == VK_TIMEOUT) result = vkGetFenceStatus(device, fence);
+            if (wait_result == VK_SUCCESS || wait_result == VK_TIMEOUT) {
+                fence_probe_count_.fetch_add(1, std::memory_order_relaxed);
+                result = vkGetFenceStatus(device, fence);
+            }
             if (result == VK_NOT_READY) {
                 ++iterator;
                 continue;
@@ -346,6 +414,7 @@ void Gpu_Completion_Service::run() noexcept {
             catch (...) {}
             if (watched)
                 watched_.fetch_sub(1, std::memory_order_relaxed);
+            cancellation_count_.fetch_add(1, std::memory_order_relaxed);
             if (on_exception) {
                 try { on_exception(service_failure); }
                 catch (...) {}
@@ -364,6 +433,7 @@ void Gpu_Completion_Service::run() noexcept {
             catch (...) { break; }
             fail_pending(pending);
         }
+        publish_state(0, 0);
     }
 }
 }
diff --git a/render_3D/render_3D/detail/Gpu_Completion_Service.hpp b/render_3D/render_3D/detail/Gpu_Completion_Service.hpp
index 5f3a507..2553417 100644
--- a/render_3D/render_3D/detail/Gpu_Completion_Service.hpp
+++ b/render_3D/render_3D/detail/Gpu_Completion_Service.hpp
@@ -1,4 +1,6 @@
 #pragma once
+#include "../Gpu_Completion_State.hpp"
+#include <double_buffer/mechanism.hpp>
 #include <volk.h>
 #include <atomic>
 #include <chrono>
@@ -30,17 +32,6 @@ public:
         VkResult vulkan_result{VK_SUCCESS};                  /* Vulkan 原始结果码。 */
         std::uint64_t wait_duration_ns{};                    /* fence 等待时间，单位为纳秒。 */
     };
-    struct Statistics {
-        std::size_t capacity{};                              /* 最大并发 reservation 数。 */
-        std::size_t in_flight{};                             /* 当前 reservation 数。 */
-        std::size_t peak_in_flight{};                        /* 历史最大 reservation 数。 */
-        std::size_t watched{};                               /* 当前受监视 fence 数。 */
-        std::size_t peak_watched{};                          /* 历史最大受监视 fence 数。 */
-        std::uint64_t backpressure_count{};                  /* 容量不足累计次数。 */
-        std::uint64_t backpressure_wait_ns{};                /* 准入累计等待时间，单位为纳秒。 */
-        std::uint64_t fault_count{};                         /* Vulkan 或超时故障累计次数。 */
-        std::uint64_t abandoned_count{};                     /* 被隔离的 fence 累计数。 */
-    };
     using Completion = std::function<void(Result)>;
     using Exception_Handler = std::function<void(std::exception_ptr)>;
     class Reservation final {
@@ -69,7 +60,7 @@ public:
     [[nodiscard]] Prepare_Result prepare(Completion completion,
                                          Exception_Handler on_exception,
                                          bool observe);
-    [[nodiscard]] Statistics statistics() const noexcept;
+    [[nodiscard]] Gpu_Completion_State state() const noexcept;
 private:
     struct Pending_Fence {
         enum class Status {
@@ -90,14 +81,19 @@ private:
     Gpu_Completion_Service();
     ~Gpu_Completion_Service();
     static void update_peak(std::atomic_size_t& peak, std::size_t value) noexcept;
+    static void update_max(std::atomic_uint64_t& maximum,
+                           std::uint64_t value) noexcept;
     static void cancel_reserved(const std::shared_ptr<Pending_Fence>& pending);
     void acquire_slot();
     void release_slot() noexcept;
+    void publish_state(std::size_t active_fences,
+                       std::size_t pending_fences) noexcept;
     void wake() noexcept;
     void run() noexcept;
     static constexpr std::ptrdiff_t default_capacity = 1024;
     static constexpr std::uint64_t fence_wait_timeout_ns = 1'000'000;
     static constexpr std::uint64_t maximum_fence_age_ns = 30'000'000'000ULL;
+    static constexpr auto state_publication_interval = std::chrono::milliseconds(100);
     std::counting_semaphore<default_capacity> slots_{default_capacity}; /* 有界 reservation 槽位。 */
     std::mutex pending_mutex_;                               /* 保护新登记 fence 队列。 */
     std::deque<std::shared_ptr<Pending_Fence>> pending_;     /* 完成线程尚未分组的 fence。 */
@@ -108,11 +104,24 @@ private:
     std::atomic_size_t peak_in_flight_{};                    /* 历史最大 reservation 数。 */
     std::atomic_size_t watched_{};                           /* 当前受监视 fence 数。 */
     std::atomic_size_t peak_watched_{};                      /* 历史最大受监视 fence 数。 */
+    std::atomic_uint64_t reservation_count_{};
+    std::atomic_uint64_t completion_count_{};
+    std::atomic_uint64_t cancellation_count_{};
+    std::atomic_uint64_t fence_probe_count_{};
+    std::atomic_uint64_t fence_wait_count_{};
+    std::atomic_uint64_t fence_wait_timeout_count_{};
+    std::atomic_uint64_t fence_wait_total_ns_{};
+    std::atomic_uint64_t fence_wait_max_ns_{};
+    std::atomic_uint64_t callback_total_ns_{};
+    std::atomic_uint64_t callback_max_ns_{};
+    std::atomic_uint64_t callback_failure_count_{};
     std::atomic_uint64_t backpressure_count_{};              /* 准入背压累计次数。 */
     std::atomic_uint64_t backpressure_wait_ns_{};            /* 准入背压累计纳秒。 */
     std::atomic_uint64_t fault_count_{};                     /* 完成故障累计次数。 */
     std::atomic_uint64_t abandoned_count_{};                 /* 放弃 fence 累计次数。 */
     std::atomic_bool stopping_{};                            /* 服务是否正在停止。 */
+    mutable std::mutex state_mutex_;                         /* 只保护域级 State 的指针交换。 */
+    double_buffer::Publish_Double_Buffer<Gpu_Completion_State> state_{};
     std::thread thread_;                                     /* 专用 fence 完成线程。 */
 };
 }
diff --git a/render_3D/render_3D/scene/Render_Scene_3D.cpp b/render_3D/render_3D/scene/Render_Scene_3D.cpp
index c6972ef..ba52075 100644
--- a/render_3D/render_3D/scene/Render_Scene_3D.cpp
+++ b/render_3D/render_3D/scene/Render_Scene_3D.cpp
@@ -1,9 +1,18 @@
 #include "Render_Scene_3D.hpp"                             /* 三维异步提交阶段实现。 */
 namespace aethera::render_3d {
+Render_Scene_3D::Private::~Private() {
+    /* 先停止后端产生新回调，再等待已经触发的 completion topology 释放借用帧。 */
+    backend.reset();
+    std::unique_lock lock(completion_mutex);
+    completion_condition.wait(lock, [this] { return !completion_running; });
+}
 bool Render_Scene_3D::Prop::operator==(const Prop&) const = default;
 bool Render_Scene_3D::State::operator==(const State&) const = default;
 Render_Scene_3D::Render_Result Render_Scene_3D::render(Frame_3D* frame) { return static_cast<Private&>(*d).dispatch->render(this, frame); }
 void Render_Scene_3D::set_frame_callback(Frame_Callback callback) { static_cast<Private&>(*d).dispatch->set_frame_callback(this, std::move(callback)); }
+tf::Taskflow& Render_Scene_3D::completion_taskflow() {
+    return static_cast<Private&>(*d).completion_graph;
+}
 void Render_Scene_3D::activate_view() { static_cast<Private&>(*d).dispatch->set_active(this, true); }
 void Render_Scene_3D::deactivate_view() { static_cast<Private&>(*d).dispatch->set_active(this, false); }
 }
diff --git a/render_3D/render_3D/scene/Render_Scene_3D.hpp b/render_3D/render_3D/scene/Render_Scene_3D.hpp
index 6bdb6ac..98e3bc0 100644
--- a/render_3D/render_3D/scene/Render_Scene_3D.hpp
+++ b/render_3D/render_3D/scene/Render_Scene_3D.hpp
@@ -56,12 +56,19 @@ struct Render_Scene_3D : Def<Render_Scene_3D, Scene, Dependency_Graph_Type<Submi
         std::uint32_t gpu_index{};                            /* Datoviz 使用的物理 GPU 下标。 */
         bool validation_enabled{};                            /* 是否启用 Vulkan 验证。 */
     };
-    enum class Render_Result { submitted, view_inactive, empty_viewport, backend_unavailable };
+    enum class Render_Result { submitted, frame_in_flight, view_inactive, empty_viewport, backend_unavailable };
     using Frame_Callback = std::function<void(Frame_3D*)>;
-    /* 无等待提交到调用方拥有的帧；frame 必须存活到完成回调返回。 */
+    /* 无等待提交到调用方拥有的帧；必须先安装回调，回调返回前只允许一帧在途。 */
     [[nodiscard]] Render_Result render(Frame_3D* frame);
-    /* 安装完成帧回调；回调由 Datoviz Render Domain 线程传回同一外部帧。 */
+    /* 安装完成帧回调；回调传回同一外部帧，返回时 Scene 才释放下一帧准入。 */
     void set_frame_callback(Frame_Callback callback);
+    /*
+     * 返回 GPU 完成并回读像素后、帧回调前执行的直接 Taskflow。
+     * 只能在 Scene 没有运行时修改该图；禁止在执行期间 emplace/erase/clear。
+     * completion Taskflow 完成前调用方必须保持本帧像素所有权；节点若启动更晚结束的异步工作，
+     * 必须捕获 share_pixels() 等拥有像素所有权的对象，禁止只捕获会被下一帧复用的裸 Frame_3D*。
+     */
+    [[nodiscard]] tf::Taskflow& completion_taskflow();
     void activate_view();
     void deactivate_view();
 };
diff --git a/render_3D/render_3D/scene/Render_Scene_3D.ipp b/render_3D/render_3D/scene/Render_Scene_3D.ipp
index 48f1d07..d1f414a 100644
--- a/render_3D/render_3D/scene/Render_Scene_3D.ipp
+++ b/render_3D/render_3D/scene/Render_Scene_3D.ipp
@@ -1,6 +1,8 @@
 #pragma once
 #include "../detail/Async_Render_Backend.hpp"
 #include <algorithm>
+#include <condition_variable>
+#include <mutex>
 #include <stdexcept>
 namespace aethera::render_3d {
 namespace detail {
@@ -23,6 +25,13 @@ struct Render_Scene_3D::Private : Prev_Private {
         Callback_Run set_frame_callback;                     /* 安装最终完成帧回调。 */
         Active_Run set_active;                               /* 修改最终 Scene 的活动属性。 */
     };
+    std::mutex render_mutex{};                               /* 只保护完成回调和单帧准入。 */
+    bool frame_in_flight{};                                  /* render 准入到异步完成回调返回的唯一状态源。 */
+    Frame_Callback frame_callback{};                         /* Scene 的唯一对外完成出口。 */
+    tf::Taskflow completion_graph{};                         /* GPU 像素完成后、发布回调前执行的外部续写图。 */
+    std::mutex completion_mutex{};                           /* 只保护 completion 图拓扑的在途生命周期。 */
+    std::condition_variable completion_condition{};
+    bool completion_running{};                              /* 析构等待异步 completion 图结束的唯一状态源。 */
     std::shared_ptr<detail::Async_Render_Backend> backend{};  /* Scene 拥有的异步后端；已入队命令自行延长实现寿命。 */
     std::shared_ptr<void> paint_context{};                    /* Paint 节点读取 Scene 当前 Prop 的生命周期门闩。 */
     Root* camera_component{};                                /* Builder 绑定的 Camera 组件。 */
@@ -31,6 +40,7 @@ struct Render_Scene_3D::Private : Prev_Private {
     std::array<plot::Axis_Descriptor, 3> (*read_axes)(const Root*){}; /* 读取三轴当前配置。 */
     Frame_3D* active_frame{};                                /* 当前同步 process 借用的外部帧；提交完成后清空。 */
     const Dispatch* dispatch{};                              /* 最终 Scene 类型对应的静态公开分派表。 */
+    ~Private();
     /* Builder 内部初始化后端；必须在绑定 Visual Paint 目标之前调用一次。 */
     template <Attached Object>
     void initialize_backend(Object* object, std::uint32_t gpu_index, bool validation_enabled,
@@ -157,7 +167,41 @@ void Render_Scene_3D::Private::initialize_backend(
     read_axes = axes_reader;
     const auto initial = parameters(object);
     backend = std::make_shared<detail::Async_Render_Backend>(gpu_index, validation_enabled,
-                                                             std::move(visuals));
+                                                             std::move(visuals), initial);
+    backend->set_frame_callback([this](Frame_3D* frame) {
+        Frame_Callback callback;
+        {
+            std::lock_guard lock(render_mutex);
+            callback = frame_callback;
+        }
+        auto finish = [this, frame, callback = std::move(callback)]() mutable {
+            frame->mark(Frame_Trace_Marker::callback_started);
+            if (callback) callback(frame);
+            frame->mark(Frame_Trace_Marker::callback_finished);
+            {
+                std::lock_guard lock(render_mutex);
+                frame_in_flight = false;
+            }
+            {
+                std::lock_guard lock(completion_mutex);
+                completion_running = false;
+            }
+            completion_condition.notify_all();
+        };
+        if (completion_graph.empty()) {
+            finish();
+            return;
+        }
+        {
+            std::lock_guard lock(completion_mutex);
+            completion_running = true;
+        }
+        /*
+         * GPU 完成线程只触发 Taskflow topology，不等待编码/发送节点；最终回调在 topology 完成后执行。
+         * 帧准入在 finish() 之前始终有效，因此 completion 图运行期间该外部 Frame 不会被下一帧复用。
+         */
+        aethera::detail::run_taskflow(completion_graph, std::move(finish));
+    });
     paint_context = std::make_shared<detail::Scene_Paint_Context<Object>>(
         detail::Scene_Paint_Context<Object>{
             backend, object, nullptr, initial,
@@ -219,20 +263,21 @@ void Render_Scene_3D::Private::process(Object* object, Callback&& callback) requ
     Prev_Private::process(object, frame, [&](const Scene::Private::Result&) {
         frame->mark(Frame_Trace_Marker::paint_started);
         const auto prepare = object->template current_dependency_graph<Prepare_Data_Tag>();
-        prepare.for_each_bound([](Renderable* renderable, Renderable::Private& data) { if (data.dispatch->state.get(renderable)->prepare_executed) renderable->template mark_dirty<Submit_Tag>(); });
+        prepare.for_each_bound([](Renderable* renderable, Renderable::Private& data) { if (data.dispatch->state.pending(renderable)->prepare_executed) renderable->template mark_dirty<Submit_Tag>(); });
         const auto submit = object->template current_dependency_graph<Submit_Tag>();
         const auto result = submit.for_each_topological_view([&](const auto& view, const Dependency_Graph::Node& node) {
             auto* data = view.private_data(node);
             if (!data) return;
             Root* root = node.object;
             auto* dispatch = data->dispatch;
-            auto& state = *dispatch->state.get(root);
+            auto& state = *dispatch->state.pending(root);
             state.paint_graph_rebuilt = false;
             state.paint_execution_time_ns = 0;
             const bool dirty = root->template dirty<Submit_Tag>();
             state.paint_dirty = dirty;
             state.paint_executed = dispatch->paint.predicate(root, dirty);
             if (!state.paint_executed) return;
+            const auto paint_started = std::chrono::steady_clock::now();
             if (dispatch->paint.builder) {
                 if (!data->paint_graph) data->paint_graph = std::make_unique<tf::Taskflow>();
                 const bool rebuild = dispatch->paint.rebuild_predicate(root);
@@ -240,8 +285,13 @@ void Render_Scene_3D::Private::process(Object* object, Callback&& callback) requ
                 state.paint_task_count = data->paint_graph->num_tasks();
                 if (!data->paint_graph->empty()) aethera::detail::run_taskflow(*data->paint_graph);
             } else { state.paint_task_count = dispatch->paint.run ? 1 : 0; if (dispatch->paint.run) dispatch->paint.run(root); }
+            if (!data->paint_extension.empty())
+                aethera::detail::run_taskflow(data->paint_extension);
             root->template take_dirty<Submit_Tag>();
-            dispatch->state.notify(root);
+            state.paint_execution_time_ns = static_cast<std::uint64_t>(
+                std::chrono::duration_cast<std::chrono::nanoseconds>(
+                    std::chrono::steady_clock::now() - paint_started).count());
+            dispatch->state.publish(root);
         });
         if (!result) throw std::logic_error("render scene submit graph became invalid during submission");
         if (context->visuals->empty())
@@ -257,6 +307,23 @@ void Render_Scene_3D::Private::process(Object* object, Callback&& callback) requ
 template <Attached Object>
 Render_Scene_3D::Render_Result Render_Scene_3D::Private::render(Object* object, Frame_3D* frame) {
     if (!frame) throw std::invalid_argument("Render_Scene_3D requires a non-null external frame");
+    {
+        std::lock_guard lock(render_mutex);
+        if (!frame_callback)
+            throw std::logic_error("Render_Scene_3D requires a frame callback before render");
+        if (frame_in_flight) return Render_Result::frame_in_flight;
+        frame_in_flight = true;
+    }
+    bool submitted{};
+    struct Admission_Scope {
+        Private& data;
+        bool& submitted;
+        ~Admission_Scope() {
+            if (submitted) return;
+            std::lock_guard lock(data.render_mutex);
+            data.frame_in_flight = false;
+        }
+    } admission{*this, submitted};
     frame->mark(Frame_Trace_Marker::scene_render_requested);
     struct Active_Frame_Scope {
         Frame_3D*& target;                                  /* 最终 Private 的同步 process 帧槽位。 */
@@ -264,7 +331,6 @@ Render_Scene_3D::Render_Result Render_Scene_3D::Private::render(Object* object,
         ~Active_Frame_Scope() { target = previous; }
     } active_frame_scope{active_frame, active_frame};
     active_frame = frame;
-    bool submitted{};
     object->process([&] { submitted = true; frame->mark(Frame_Trace_Marker::scene_render_finished); });
     if (submitted) return Render_Result::submitted;
     const auto& prop = object->template read_prop<Render_Scene_3D::Base_Tag>();
@@ -272,6 +338,6 @@ Render_Scene_3D::Render_Result Render_Scene_3D::Private::render(Object* object,
     if (prop.viewport.empty()) return Render_Result::empty_viewport;
     return Render_Result::backend_unavailable;
 }
-template <Attached Object> const Render_Scene_3D::Private::Dispatch& Render_Scene_3D::Private::dispatch_for() { static const Dispatch value{[](Root* root, Frame_3D* frame) { auto* object = static_cast<Object*>(root); return static_cast<typename Object::Private&>(*object->d).render(object, frame); }, [](Root* root, Frame_Callback callback) { auto* object = static_cast<Object*>(root); auto& data = static_cast<typename Object::Private&>(*object->d); if (data.backend) data.backend->set_frame_callback(std::move(callback)); }, [](Root* root, bool active) { static_cast<Object*>(root)->template set<&Prop::view_active>(active); }}; return value; }
+template <Attached Object> const Render_Scene_3D::Private::Dispatch& Render_Scene_3D::Private::dispatch_for() { static const Dispatch value{[](Root* root, Frame_3D* frame) { auto* object = static_cast<Object*>(root); return static_cast<typename Object::Private&>(*object->d).render(object, frame); }, [](Root* root, Frame_Callback callback) { auto* object = static_cast<Object*>(root); auto& data = static_cast<typename Object::Private&>(*object->d); std::lock_guard lock(data.render_mutex); data.frame_callback = std::move(callback); }, [](Root* root, bool active) { static_cast<Object*>(root)->template set<&Prop::view_active>(active); }}; return value; }
 template <Attached Object> void Render_Scene_3D::Private::bind_private_crtp(Object* object) { Prev_Private::bind_private_crtp(object); dispatch = &dispatch_for<Object>(); }
 }
diff --git a/render_3D/tests/Visual_Tests.cpp b/render_3D/tests/Visual_Tests.cpp
index a82d99f..58f314a 100644
--- a/render_3D/tests/Visual_Tests.cpp
+++ b/render_3D/tests/Visual_Tests.cpp
@@ -67,7 +67,15 @@ TEST(Render_3D_Scene, Paint_Submits_Without_Waiting_For_Gpu) {
         Frame_3D unchanged_frame{Frame_Identity{2, 0}};
         Frame_3D exchanged_unchanged_frame{Frame_Identity{3, 0}};
         Frame_3D* completed_frame{};
-        scene->set_frame_callback([&](Frame_3D* value) { completed_frame = value; frame_ready.store(true, std::memory_order_release); });
+        std::atomic_size_t completion_calls{};
+        scene->completion_taskflow().emplace([&] {
+            completion_calls.fetch_add(1, std::memory_order_release);
+        }).name("test.scene_3d.completion");
+        scene->set_frame_callback([&](Frame_3D* value) {
+            EXPECT_GT(completion_calls.load(std::memory_order_acquire), 0u);
+            completed_frame = value;
+            frame_ready.store(true, std::memory_order_release);
+        });
         const auto started = std::chrono::steady_clock::now();
         EXPECT_EQ(scene->render(&frame), Render_Scene_3D::Render_Result::submitted);
         const auto submit_duration = std::chrono::steady_clock::now() - started;
@@ -86,6 +94,7 @@ TEST(Render_3D_Scene, Paint_Submits_Without_Waiting_For_Gpu) {
         EXPECT_EQ(scene->render(&exchanged_unchanged_frame), Render_Scene_3D::Render_Result::submitted);
         for (std::size_t attempt = 0; attempt != 500 && !frame_ready.load(std::memory_order_acquire); ++attempt) std::this_thread::sleep_for(std::chrono::milliseconds(10));
         EXPECT_EQ(completed_frame, &exchanged_unchanged_frame);
+        EXPECT_EQ(completion_calls.load(std::memory_order_acquire), 3u);
         EXPECT_TRUE(std::ranges::equal(unchanged_frame.pixels(), exchanged_unchanged_frame.pixels()));
     }
     catch (const std::exception& error) {
diff --git a/web_server/src/Gallery_Plots_2D.cpp b/web_server/src/Gallery_Plots_2D.cpp
index 803defa..5820e81 100644
--- a/web_server/src/Gallery_Plots_2D.cpp
+++ b/web_server/src/Gallery_Plots_2D.cpp
@@ -477,7 +477,7 @@ void resize_axes(Scene_2D* scene, Size viewport, Axes*... axes) {
     (resize_axis(axes), ...);
 }
 }
-std::shared_ptr<Plot> make_axes_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_axes_plot() {
     constexpr Size canvas{720, 420};
     auto frequency = make_frequency_axis();
     frequency->template set<&Abs_Axis::Prop::unit_text>("Hz");
@@ -544,9 +544,9 @@ std::shared_ptr<Plot> make_axes_plot(asio::any_io_executor executor) {
                  {"fields", std::move(generator_fields)}},
             std::move(generate)},
         std::move(frequency), std::move(numeric), std::move(time));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_spectrum_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_spectrum_plot() {
     constexpr Size canvas{720, 420};
     auto frequency = make_frequency_axis();
     auto vertical = make_numeric_axis(Axis_Orientation::vertical, {64.0, 370.0}, -320.0, {-110.0, 0.0});
@@ -606,9 +606,9 @@ std::shared_ptr<Plot> make_spectrum_plot(asio::any_io_executor executor) {
         State_Field<Spectrum, &Spectrum::State::rendered_point_count, "rendered_point_count", "Number of curve points emitted by the latest render preparation.">,
         State_Field<Spectrum, &Spectrum::State::selectable_marker_count, "selectable_marker_count", "Number of markers currently eligible for selection.">>(
         *spectrum, *scene, std::move(update), std::move(frequency), std::move(vertical), std::move(spectrum), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_frequency_trace_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_frequency_trace_plot() {
     constexpr Size canvas{720, 420};
     auto time = make_time_axis(
         Axis_Orientation::horizontal, {64.0, 370.0}, 620.0);
@@ -642,9 +642,9 @@ std::shared_ptr<Plot> make_frequency_trace_plot(asio::any_io_executor executor)
         Prop_Field<&Frequency_Trace::Prop::pen, "pen", "Stroke style used to draw the frequency trace.">,
         Prop_Field<&Frequency_Trace::Prop::partition_mode, "partition_mode", "Selects how trace samples are divided between preparation tasks.">>(
         *trace, *scene, std::move(update), std::move(time), std::move(vertical), std::move(trace), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_sweep_spectrum_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_sweep_spectrum_plot() {
     constexpr Size canvas{720, 420};
     auto frequency = make_frequency_axis();
     auto vertical = make_numeric_axis(
@@ -691,9 +691,9 @@ std::shared_ptr<Plot> make_sweep_spectrum_plot(asio::any_io_executor executor) {
         Prop_Field<&Sweep_Spectrum::Prop::current_frequency_pen, "current_frequency_pen", "Stroke style used for the current sweep-frequency indicator.">,
         Prop_Field<&Sweep_Spectrum::Prop::interpolation_mode, "interpolation_mode", "Selects interpolation between adjacent sweep bins.">>(
         *sweep, *scene, std::move(update), std::move(frequency), std::move(vertical), std::move(sweep), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_afterglow_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_afterglow_plot() {
     constexpr Size canvas{720, 420};
     auto frequency = make_frequency_axis();
     auto vertical = make_numeric_axis(
@@ -735,9 +735,9 @@ std::shared_ptr<Plot> make_afterglow_plot(asio::any_io_executor executor) {
         Prop_Field<&Afterglow::Prop::partition_mode, "partition_mode", "Selects how afterglow cells are divided between preparation tasks.">,
         Prop_Field<&Afterglow::Prop::color_map, "color_map", "Maps accumulated energy values to rendered colors.">>(
         *afterglow, *scene, std::move(update), std::move(frequency), std::move(vertical), std::move(afterglow), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_waterfall_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_waterfall_plot() {
     constexpr Size canvas{720, 420};
     auto frequency = make_frequency_axis();
     auto time = make_time_axis(
@@ -787,9 +787,9 @@ std::shared_ptr<Plot> make_waterfall_plot(asio::any_io_executor executor) {
         Prop_Field<&Waterfall::Prop::interpolation_mode, "interpolation_mode", "Selects interpolation when samples are mapped to raster cells.">,
         Prop_Field<&Waterfall::Prop::color_map, "color_map", "Maps sample power values to waterfall colors.">>(
         *waterfall, *scene, std::move(update), std::move(frequency), std::move(time), std::move(waterfall), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_constellation_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_constellation_plot() {
     constexpr Size canvas{720, 420};
     auto horizontal = make_numeric_axis(
         Axis_Orientation::horizontal, {64.0, 370.0}, 620.0, {-1.2, 1.2});
@@ -838,9 +838,9 @@ std::shared_ptr<Plot> make_constellation_plot(asio::any_io_executor executor) {
         Prop_Field<&Constellation_Diagram::Prop::point_color, "point_color", "Color used to render received I/Q samples.">,
         Prop_Field<&Constellation_Diagram::Prop::anchor_color, "anchor_color", "Color used to render ideal modulation anchors.">>(
         *constellation, *scene, std::move(update), std::move(horizontal), std::move(vertical), std::move(constellation), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
-std::shared_ptr<Plot> make_selection_overlay_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_selection_overlay_plot() {
     constexpr Size canvas{720, 420};
     auto horizontal = make_numeric_axis(
         Axis_Orientation::horizontal, {64.0, 370.0}, 620.0, {0.0, 100.0});
@@ -866,6 +866,6 @@ std::shared_ptr<Plot> make_selection_overlay_plot(asio::any_io_executor executor
                     "selected_region_count",
                     "Number of rectangular regions currently selected.">>(
         *selection, *scene, std::move(update), std::move(horizontal), std::move(vertical), std::move(selection));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
 }
diff --git a/web_server/src/Gallery_Plots_2D.hpp b/web_server/src/Gallery_Plots_2D.hpp
index 6e6a338..cd9605c 100644
--- a/web_server/src/Gallery_Plots_2D.hpp
+++ b/web_server/src/Gallery_Plots_2D.hpp
@@ -2,12 +2,12 @@
 #include "Plot.hpp"
 
 namespace aethera::web {
-[[nodiscard]] std::shared_ptr<Plot> make_spectrum_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_axes_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_frequency_trace_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_sweep_spectrum_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_afterglow_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_waterfall_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_constellation_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_selection_overlay_plot(asio::any_io_executor executor);
+[[nodiscard]] std::shared_ptr<Plot> make_spectrum_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_axes_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_frequency_trace_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_sweep_spectrum_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_afterglow_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_waterfall_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_constellation_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_selection_overlay_plot();
 }
diff --git a/web_server/src/Gallery_Plots_3D.cpp b/web_server/src/Gallery_Plots_3D.cpp
index a5dd0ea..d07bfdb 100644
--- a/web_server/src/Gallery_Plots_3D.cpp
+++ b/web_server/src/Gallery_Plots_3D.cpp
@@ -375,7 +375,7 @@ struct Scene_Components_3D {
 
 template <typename Definition, typename Build_Result,
           typename Data_Generator = Random_Data_Generator>
-std::shared_ptr<Plot> make_visual_plot(asio::any_io_executor executor, std::string label,
+std::shared_ptr<Plot> make_visual_plot(std::string label,
                                       Build_Result build_result,
                                       Scene_Components_3D components = {},
                                       Data_Generator data_generator = {},
@@ -421,7 +421,7 @@ std::shared_ptr<Plot> make_visual_plot(asio::any_io_executor executor, std::stri
     auto view = std::make_unique<Visual_Scene_View<Visual_Object, Data_Generator>>(
         *scene, std::move(camera), std::move(axes), std::move(visual),
         std::move(label), std::move(data_generator), std::move(markers));
-    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
+    return std::make_shared<Plot>(std::move(scene), std::move(view));
 }
 
 Color color(std::uint8_t red, std::uint8_t green, std::uint8_t blue, std::uint8_t alpha = 255) {
@@ -656,55 +656,55 @@ struct Spectrogram_Data_Generator {
 };
 }
 
-std::shared_ptr<Plot> make_datoviz_point_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Point_Visual>(std::move(executor), "Point Visual", Impl<Point_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_point_plot() {
+    return make_visual_plot<Point_Visual>("Point Visual", Impl<Point_Visual>::Builder{}
         .set(&Point_Visual::Prop::items, std::vector<Point>{{{-0.65F, -0.25F, 0.05F}, color(255, 91, 110), 28.0F}, {{0.0F, 0.58F, 0.25F}, color(82, 226, 190), 34.0F}, {{0.62F, -0.12F, -0.15F}, color(75, 145, 255), 30.0F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_splat_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Splat_Visual>(std::move(executor), "Splat Visual", Impl<Splat_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_splat_plot() {
+    return make_visual_plot<Splat_Visual>("Splat Visual", Impl<Splat_Visual>::Builder{}
         .set(&Splat_Visual::Prop::items, std::vector<Splat>{{{-0.48F, 0.0F, 0.1F}, color(255, 98, 115, 210), {0.18F, 0.08F}, 0.45F}, {{0.28F, 0.15F, 0.0F}, color(66, 218, 188, 210), {0.12F, 0.22F}, -0.3F}, {{0.15F, -0.38F, 0.2F}, color(76, 132, 255, 210), {0.2F, 0.1F}, 0.9F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_pixel_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_pixel_plot() {
     std::vector<Pixel> pixels;
     for (int y = -8; y <= 8; ++y) for (int x = -12; x <= 12; ++x) pixels.push_back({{x / 13.0F, y / 9.0F, 0.12F * std::sin(x * .45F) * std::cos(y * .35F)}, color(static_cast<std::uint8_t>(90 + 6 * (x + 12)), static_cast<std::uint8_t>(100 + 8 * (y + 8)), 230), 5.0F});
-    return make_visual_plot<Pixel_Visual>(std::move(executor), "Pixel Visual", Impl<Pixel_Visual>::Builder{}.set(&Pixel_Visual::Prop::items, std::move(pixels)).build());
+    return make_visual_plot<Pixel_Visual>("Pixel Visual", Impl<Pixel_Visual>::Builder{}.set(&Pixel_Visual::Prop::items, std::move(pixels)).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_marker_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Marker_Visual>(std::move(executor), "Marker Visual", Impl<Marker_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_marker_plot() {
+    return make_visual_plot<Marker_Visual>("Marker Visual", Impl<Marker_Visual>::Builder{}
         .set(&Marker_Visual::Prop::items, std::vector<Marker>{{{-0.7F, 0.0F, 0.0F}, color(255, 93, 115), 34.0F, 0.0F, Marker_Shape::disc}, {{-0.35F, 0.25F, 0.1F}, color(91, 226, 193), 36.0F, 0.25F, Marker_Shape::square}, {{0.0F, -0.2F, 0.2F}, color(100, 158, 255), 38.0F, 0.5F, Marker_Shape::triangle}, {{0.35F, 0.25F, 0.1F}, color(250, 195, 92), 40.0F, 0.75F, Marker_Shape::diamond}, {{0.7F, 0.0F, 0.0F}, color(201, 132, 255), 42.0F, 1.0F, Marker_Shape::cross}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_sphere_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Sphere_Visual>(std::move(executor), "Sphere Visual", Impl<Sphere_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_sphere_plot() {
+    return make_visual_plot<Sphere_Visual>("Sphere Visual", Impl<Sphere_Visual>::Builder{}
         .set(&Sphere_Visual::Prop::items, std::vector<Sphere>{{{-0.48F, -0.2F, 0.0F}, color(255, 91, 110), 0.28F}, {{0.08F, 0.25F, 0.18F}, color(82, 226, 190), 0.36F}, {{0.55F, -0.18F, -0.12F}, color(75, 145, 255), 0.24F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_segment_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_segment_plot() {
     std::vector<Segment> segments;
     for (int index = 0; index < 12; ++index) { const float angle = static_cast<float>(index) * std::numbers::pi_v<float> / 6.0F; segments.push_back({{0.0F, 0.0F, 0.0F}, {0.82F * std::cos(angle), 0.82F * std::sin(angle), 0.18F * std::sin(2 * angle)}, color(static_cast<std::uint8_t>(80 + index * 13), static_cast<std::uint8_t>(220 - index * 8), 240), 4.0F}); }
-    return make_visual_plot<Segment_Visual>(std::move(executor), "Segment Visual", Impl<Segment_Visual>::Builder{}.set(&Segment_Visual::Prop::items, std::move(segments)).build());
+    return make_visual_plot<Segment_Visual>("Segment Visual", Impl<Segment_Visual>::Builder{}.set(&Segment_Visual::Prop::items, std::move(segments)).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_vector_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Vector_Visual>(std::move(executor), "Vector Visual", Impl<Vector_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_vector_plot() {
+    return make_visual_plot<Vector_Visual>("Vector Visual", Impl<Vector_Visual>::Builder{}
         .set(&Vector_Visual::Prop::items, std::vector<Vector_Glyph>{{{-0.55F, -0.35F, 0.0F}, {0.55F, 0.2F, 0.25F}, color(255, 98, 115), 4.0F}, {{-0.1F, 0.0F, 0.0F}, {0.2F, 0.62F, 0.18F}, color(80, 225, 190), 5.0F}, {{0.35F, -0.25F, 0.0F}, {-0.12F, 0.25F, 0.65F}, color(78, 145, 255), 4.0F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_primitive_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Primitive_Visual>(std::move(executor), "Primitive Visual", Impl<Primitive_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_primitive_plot() {
+    return make_visual_plot<Primitive_Visual>("Primitive Visual", Impl<Primitive_Visual>::Builder{}
         .set(&Primitive_Visual::Prop::topology, Primitive_Topology::triangle_list)
         .set(&Primitive_Visual::Prop::items, std::vector<Primitive_Vertex>{{{-0.72F, -0.55F, 0.0F}, color(255, 86, 110), {0, 0, 1}}, {{0.72F, -0.55F, 0.0F}, color(75, 145, 255), {0, 0, 1}}, {{0.0F, 0.72F, 0.25F}, color(82, 226, 190), {0, 0, 1}}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_mesh_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_mesh_plot() {
     const std::vector<Mesh_Vertex> mesh{{{-0.65F, -0.55F, 0.0F}, color(255, 94, 112), {0, 0, 1}, {0, 0}}, {{0.65F, -0.55F, 0.0F}, color(75, 145, 255), {0, 0, 1}, {1, 0}}, {{0.65F, 0.55F, 0.0F}, color(82, 226, 190), {0, 0, 1}, {1, 1}}, {{-0.65F, -0.55F, 0.0F}, color(255, 94, 112), {0, 0, 1}, {0, 0}}, {{0.65F, 0.55F, 0.0F}, color(82, 226, 190), {0, 0, 1}, {1, 1}}, {{-0.65F, 0.55F, 0.0F}, color(244, 190, 86), {0, 0, 1}, {0, 1}}};
-    return make_visual_plot<Mesh_Visual>(std::move(executor), "Mesh Visual", Impl<Mesh_Visual>::Builder{}.set(&Mesh_Visual::Prop::items, mesh).build());
+    return make_visual_plot<Mesh_Visual>("Mesh Visual", Impl<Mesh_Visual>::Builder{}.set(&Mesh_Visual::Prop::items, mesh).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_spectrogram_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_spectrogram_plot() {
     const Spectrogram_Parameters parameters;
     auto marker_result = Impl<Marker_Visual>::Builder{}
         .set(&Marker_Visual::Prop::items, std::vector<Marker>{
@@ -734,46 +734,46 @@ std::shared_ptr<Plot> make_datoviz_spectrogram_plot(asio::any_io_executor execut
             parameters.maximum_level_db}, plot::Axis_Scale::linear,
             "SPL", "dB", 7, 0, true, true, true}};
     return make_visual_plot<Mesh_Visual>(
-        std::move(executor), "3D Spectrogram",
+        "3D Spectrogram",
         Impl<Mesh_Visual>::Builder{}
             .set(&Mesh_Visual::Prop::items, spectrogram_mesh(parameters))
             .build(),
         std::move(components), Spectrogram_Data_Generator{parameters}, std::move(markers));
 }
 
-std::shared_ptr<Plot> make_datoviz_path_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_path_plot() {
     std::vector<Path_Vertex> path;
     for (int index = 0; index < 64; ++index) { const float t = static_cast<float>(index) / 63.0F; path.push_back({{-0.9F + 1.8F * t, 0.48F * std::sin(t * 4.0F * std::numbers::pi_v<float>), 0.25F * std::cos(t * 2.0F * std::numbers::pi_v<float>)}, color(static_cast<std::uint8_t>(70 + 170 * t), static_cast<std::uint8_t>(220 - 80 * t), 245), 5.0F}); }
-    return make_visual_plot<Path_Visual>(std::move(executor), "Path Visual", Impl<Path_Visual>::Builder{}.set(&Path_Visual::Prop::items, std::move(path)).build());
+    return make_visual_plot<Path_Visual>("Path Visual", Impl<Path_Visual>::Builder{}.set(&Path_Visual::Prop::items, std::move(path)).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_image_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Image_Visual>(std::move(executor), "Image Visual", Impl<Image_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_image_plot() {
+    return make_visual_plot<Image_Visual>("Image Visual", Impl<Image_Visual>::Builder{}
         .set(&Image_Visual::Prop::field_width, 32U).set(&Image_Visual::Prop::field_height, 32U)
         .set(&Image_Visual::Prop::items, std::vector<Image>{{{0.0F, 0.0F, 0.0F}, {1.45F, 1.0F}, {0, 0, 1, 1}, color(255, 255, 255)}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_labels_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Labels_Visual>(std::move(executor), "Labels Visual", Impl<Labels_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_labels_plot() {
+    return make_visual_plot<Labels_Visual>("Labels Visual", Impl<Labels_Visual>::Builder{}
         .set(&Labels_Visual::Prop::field_width, 8U).set(&Labels_Visual::Prop::field_height, 8U)
         .set(&Labels_Visual::Prop::items, std::vector<Label>{{{-0.55F, 0.28F, 0.0F}, 0, {72, 34}, color(255, 255, 255)}, {{0.5F, 0.25F, 0.1F}, 1, {72, 34}, color(255, 255, 255)}, {{-0.45F, -0.32F, 0.1F}, 2, {72, 34}, color(255, 255, 255)}, {{0.55F, -0.3F, 0.0F}, 3, {72, 34}, color(255, 255, 255)}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_glyph_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Glyph_Visual>(std::move(executor), "Glyph Visual", Impl<Glyph_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_glyph_plot() {
+    return make_visual_plot<Glyph_Visual>("Glyph Visual", Impl<Glyph_Visual>::Builder{}
         .set(&Glyph_Visual::Prop::field_width, 32U).set(&Glyph_Visual::Prop::field_height, 32U)
         .set(&Glyph_Visual::Prop::items, std::vector<Glyph>{{{-0.55F, -0.15F, 0.0F}, {-0.18F, -0.18F, 0.18F, 0.18F}, {0, 0, 1, 1}, color(255, 100, 120), -0.2F}, {{0.0F, 0.22F, 0.1F}, {-0.22F, -0.22F, 0.22F, 0.22F}, {0, 0, 1, 1}, color(82, 226, 190), 0.25F}, {{0.55F, -0.15F, 0.0F}, {-0.2F, -0.2F, 0.2F, 0.2F}, {0, 0, 1, 1}, color(80, 145, 255), 0.55F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_text_plot(asio::any_io_executor executor) {
-    return make_visual_plot<Text_Visual>(std::move(executor), "Text Visual", Impl<Text_Visual>::Builder{}
+std::shared_ptr<Plot> make_datoviz_text_plot() {
+    return make_visual_plot<Text_Visual>("Text Visual", Impl<Text_Visual>::Builder{}
         .set(&Text_Visual::Prop::items, std::vector<Text_Label>{{{-0.72F, 0.28F, 0.0F}, "Aethera", color(82, 226, 190), 28.0F}, {{-0.62F, -0.15F, 0.1F}, "Datoviz Visual", color(90, 155, 255), 22.0F}}).build());
 }
 
-std::shared_ptr<Plot> make_datoviz_volume_plot(asio::any_io_executor executor) {
+std::shared_ptr<Plot> make_datoviz_volume_plot() {
     std::vector<Voxel> voxels(16U * 16U * 16U);
     for (std::size_t index = 0; index < voxels.size(); ++index) voxels[index].value = static_cast<float>(index % 256U) / 255.0F;
-    return make_visual_plot<Volume_Visual>(std::move(executor), "Volume Visual", Impl<Volume_Visual>::Builder{}
+    return make_visual_plot<Volume_Visual>("Volume Visual", Impl<Volume_Visual>::Builder{}
         .set(&Volume_Visual::Prop::field_width, 16U).set(&Volume_Visual::Prop::field_height, 16U).set(&Volume_Visual::Prop::field_depth, 16U)
         .set(&Volume_Visual::Prop::items, std::move(voxels)).build());
 }
diff --git a/web_server/src/Gallery_Plots_3D.hpp b/web_server/src/Gallery_Plots_3D.hpp
index 6469bb9..e91ec20 100644
--- a/web_server/src/Gallery_Plots_3D.hpp
+++ b/web_server/src/Gallery_Plots_3D.hpp
@@ -2,20 +2,20 @@
 #include "Plot.hpp"
 
 namespace aethera::web {
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_point_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_splat_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_pixel_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_marker_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_sphere_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_segment_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_vector_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_primitive_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_mesh_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_spectrogram_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_path_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_image_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_labels_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_glyph_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_text_plot(asio::any_io_executor executor);
-[[nodiscard]] std::shared_ptr<Plot> make_datoviz_volume_plot(asio::any_io_executor executor);
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_point_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_splat_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_pixel_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_marker_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_sphere_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_segment_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_vector_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_primitive_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_mesh_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_spectrogram_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_path_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_image_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_labels_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_glyph_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_text_plot();
+[[nodiscard]] std::shared_ptr<Plot> make_datoviz_volume_plot();
 }
diff --git a/web_server/src/Gallery_Video_Stream.cpp b/web_server/src/Gallery_Video_Stream.cpp
index 7018755..ea08c28 100644
--- a/web_server/src/Gallery_Video_Stream.cpp
+++ b/web_server/src/Gallery_Video_Stream.cpp
@@ -2,8 +2,6 @@
 #include "Sliding_Statistics.hpp"
 #include "detail/Gallery_Frame_Atlas.hpp"
 #include "detail/Gallery_Frame_Clock.hpp"
-#include <asio/post.hpp>
-#include <asio/strand.hpp>
 #include <nlohmann/json.hpp>
 #include <algorithm>
 #include <atomic>
@@ -46,8 +44,6 @@ struct Gallery_Video_Stream::Private {
         Plot::Stream_Id stream{};                            /* Plot 完成帧的唯一订阅标识。 */
     };
 
-    asio::any_io_executor clock_executor;                   /* bind_plots 时转交给页面级绝对帧时钟。 */
-    asio::strand<asio::any_io_executor> encoding_strand;
     std::vector<Source> sources{};                           /* 已按业务标识排序的稳定图集来源。 */
     std::unique_ptr<detail::Gallery_Frame_Atlas> atlas{};    /* 最近完成帧与 RGBA 图集的唯一状态源。 */
     std::unique_ptr<detail::Gallery_Frame_Clock> clock{};    /* 页面所有 Plot 共用的绝对 100 Hz 时钟。 */
@@ -56,6 +52,7 @@ struct Gallery_Video_Stream::Private {
         Stream_Id id{};                                      /* 当前独占网页媒体连接的订阅身份。 */
         std::shared_ptr<const Stream_Handler> handler{};      /* 发布期间保持回调存活，不复制 std::function。 */
         std::shared_ptr<const Video_Readiness> video_readiness{}; /* 编码前查询 WebRTC 三槽发送窗口。 */
+        std::shared_ptr<const Video_Diagnostics> video_diagnostics{};
     };
     mutable std::mutex consumers_mutex;
     Stream_Id next_consumer_id{1};                          /* 在互斥量内区分重连前后的独占消费者。 */
@@ -63,7 +60,8 @@ struct Gallery_Video_Stream::Private {
     std::atomic_bool stopping{};                            /* 拒绝关闭开始后的新 tick、帧与订阅。 */
     std::mutex pending_mutex;
     std::optional<Plot_Render_Tick> pending_encode_tick{};  /* 编码拥塞时保留的最新页面时钟点。 */
-    bool encode_scheduled{};                                /* encoding_strand 是否已有唯一消费任务。 */
+    bool encode_scheduled{};                                /* Taskflow 是否已有唯一编码消费任务。 */
+    std::atomic_bool key_frame_requested{};                 /* 下一次实际编码前消费的关键帧请求。 */
     std::atomic_uint64_t skipped_encode_ticks{};            /* 被最新帧策略合并的页面编码 tick 总数。 */
     std::atomic_uint64_t delivered_clock_ticks{};           /* 实际分发给全部 Plot 的页面 tick 总数。 */
     std::atomic_bool failed{};                              /* 首次 Unknown Failure 后停止全部热路径。 */
@@ -80,11 +78,7 @@ struct Gallery_Video_Stream::Private {
     mutable std::mutex diagnostics_mutex;
     nlohmann::json latest_diagnostics{};                    /* 最近一次低频聚合结果；HTTP 请求只复制该快照。 */
 
-    Private(asio::any_io_executor value_clock_executor,
-            asio::any_io_executor encoding_executor,
-            std::vector<Plot_Entry> plots)
-        : clock_executor(std::move(value_clock_executor)),
-          encoding_strand(asio::make_strand(std::move(encoding_executor))) {
+    explicit Private(std::vector<Plot_Entry> plots) {
         std::ranges::sort(plots, {}, &Plot_Entry::id);
         std::vector<std::string> source_ids;
         source_ids.reserve(plots.size());
@@ -171,7 +165,7 @@ struct Gallery_Video_Stream::Private {
         tick.height = tile_height;
         delivered_clock_ticks.fetch_add(1, std::memory_order_relaxed);
         /*
-         * 时钟只调用 render：每个 Plot 在自己的并行 strand 完成数据生成和
+         * 时钟只产生 tick：每个 Plot 的数据生成和 Prepare 由 Taskflow 执行，
          * Scene Prepare。编码使用上一个已经完成的图集快照，不等待本 tick 的
          * GPU 结果，因此 CPU Prepare、GPU 三槽和页面视频编码能够持续重叠。
          */
@@ -194,7 +188,7 @@ struct Gallery_Video_Stream::Private {
             }
         }
         if (!schedule) return;
-        asio::post(encoding_strand, [lifetime] {
+        aethera::schedule_task([lifetime] {
             if (const auto owner = lifetime.lock())
                 owner->d->encode_latest(lifetime);
         });
@@ -314,6 +308,8 @@ struct Gallery_Video_Stream::Private {
                         std::chrono::steady_clock::now() - compose_started)
                         .count());
                 const auto started = std::chrono::steady_clock::now();
+                if (key_frame_requested.exchange(false, std::memory_order_acq_rel))
+                    encoder.request_key_frame();
                 auto video = encoder.encode(
                     composition.rgba, composition.width, composition.height,
                     Video_Pixel_Layout::rgba, tick.sequence,
@@ -353,7 +349,7 @@ struct Gallery_Video_Stream::Private {
         }
         if (again) {
             try {
-                asio::post(encoding_strand, [lifetime] {
+                aethera::schedule_task([lifetime] {
                     if (const auto owner = lifetime.lock())
                         owner->d->encode_latest(lifetime);
                 });
@@ -364,22 +360,15 @@ struct Gallery_Video_Stream::Private {
 };
 
 std::shared_ptr<Gallery_Video_Stream> Gallery_Video_Stream::create(
-    asio::any_io_executor clock_executor,
-    asio::any_io_executor encoding_executor,
     std::vector<Plot_Entry> plots) {
     auto result = std::shared_ptr<Gallery_Video_Stream>(new Gallery_Video_Stream(
-        std::move(clock_executor), std::move(encoding_executor), std::move(plots)));
+        std::move(plots)));
     result->bind_plots();
     return result;
 }
 
-Gallery_Video_Stream::Gallery_Video_Stream(
-    asio::any_io_executor clock_executor,
-    asio::any_io_executor encoding_executor,
-    std::vector<Plot_Entry> plots)
-    : d(std::make_unique<Private>(std::move(clock_executor),
-                                  std::move(encoding_executor),
-                                  std::move(plots))) {}
+Gallery_Video_Stream::Gallery_Video_Stream(std::vector<Plot_Entry> plots)
+    : d(std::make_unique<Private>(std::move(plots))) {}
 
 Gallery_Video_Stream::~Gallery_Video_Stream() {
     shutdown();
@@ -388,14 +377,14 @@ Gallery_Video_Stream::~Gallery_Video_Stream() {
 void Gallery_Video_Stream::bind_plots() {
     const auto weak = weak_from_this();
     d->clock = std::make_unique<detail::Gallery_Frame_Clock>(
-        std::move(d->clock_executor), gallery_frame_rate,
+        gallery_frame_rate,
         [weak](Plot_Render_Tick tick) {
             if (const auto owner = weak.lock())
                 owner->d->dispatch_tick(tick, weak);
         },
         [weak](std::exception_ptr failure) {
             if (const auto owner = weak.lock()) {
-                asio::post(owner->d->encoding_strand,
+                aethera::schedule_task(
                     [weak, failure = std::move(failure)]() mutable {
                         if (const auto stream = weak.lock())
                             stream->d->fail(std::move(failure));
@@ -411,7 +400,7 @@ void Gallery_Video_Stream::bind_plots() {
                     return;
                 /*
                  * 每个 Plot 只替换自己槽位的不可变最近帧快照。这里不能把
-                 * 每个源帧重新投递到单一编码 strand，否则 24 个高帧率图
+                 * 每个源帧重新投递到编码任务，否则 24 个高帧率图
                  * 会先制造任务洪泛，再让图集编码永远追赶旧任务。
                  */
                 owner->d->accept_frame(slot, std::move(frame));
@@ -421,7 +410,8 @@ void Gallery_Video_Stream::bind_plots() {
 }
 
 Gallery_Video_Stream::Stream_Id Gallery_Video_Stream::subscribe(
-    Stream_Handler handler, Video_Readiness video_readiness) {
+    Stream_Handler handler, Video_Readiness video_readiness,
+    Video_Diagnostics video_diagnostics) {
     if (d->stopping.load(std::memory_order_acquire))
         throw std::logic_error("gallery video stream is shutting down");
     if (d->failed.load(std::memory_order_acquire))
@@ -431,6 +421,9 @@ Gallery_Video_Stream::Stream_Id Gallery_Video_Stream::subscribe(
     if (!video_readiness)
         throw std::invalid_argument(
             "gallery video subscription requires WebRTC readiness");
+    if (!video_diagnostics)
+        throw std::invalid_argument(
+            "gallery video subscription requires WebRTC diagnostics");
     Stream_Id id{};
     {
         std::lock_guard lock(d->consumers_mutex);
@@ -440,7 +433,9 @@ Gallery_Video_Stream::Stream_Id Gallery_Video_Stream::subscribe(
         d->consumer = Private::Consumer{
             id, std::make_shared<const Stream_Handler>(std::move(handler)),
             std::make_shared<const Video_Readiness>(
-                std::move(video_readiness))};
+                std::move(video_readiness)),
+            std::make_shared<const Video_Diagnostics>(
+                std::move(video_diagnostics))};
     }
     try {
         d->clock->start();
@@ -466,13 +461,9 @@ void Gallery_Video_Stream::unsubscribe(Stream_Id stream) {
 }
 
 void Gallery_Video_Stream::request_video_key_frame() {
-    const auto weak = weak_from_this();
-    asio::post(d->encoding_strand, [weak] {
-        if (const auto owner = weak.lock();
-            owner && !owner->d->stopping.load(std::memory_order_acquire) &&
-            !owner->d->failed.load(std::memory_order_acquire))
-            owner->d->encoder.request_key_frame();
-    });
+    if (!d->stopping.load(std::memory_order_acquire) &&
+        !d->failed.load(std::memory_order_acquire))
+        d->key_frame_requested.store(true, std::memory_order_release);
 }
 
 void Gallery_Video_Stream::shutdown() noexcept {
@@ -519,10 +510,23 @@ std::string Gallery_Video_Stream::layout_description() const {
 }
 
 nlohmann::json Gallery_Video_Stream::diagnostics() const {
-    std::lock_guard lock(d->diagnostics_mutex);
-    if (!d->latest_diagnostics.is_null()) return d->latest_diagnostics;
-    return {{"kind", "gallery_metrics"},
-            {"protocol", "aethera.gallery.video"}, {"version", 2},
-            {"sources", nlohmann::json::object()}};
+    nlohmann::json output;
+    {
+        std::lock_guard lock(d->diagnostics_mutex);
+        output = !d->latest_diagnostics.is_null()
+            ? d->latest_diagnostics
+            : nlohmann::json{{"kind", "gallery_metrics"},
+                             {"protocol", "aethera.gallery.video"},
+                             {"version", 2},
+                             {"sources", nlohmann::json::object()}};
+    }
+    std::shared_ptr<const Video_Diagnostics> video_diagnostics;
+    {
+        std::lock_guard lock(d->consumers_mutex);
+        if (d->consumer)
+            video_diagnostics = d->consumer->video_diagnostics;
+    }
+    if (video_diagnostics) output["webrtc"] = (*video_diagnostics)();
+    return output;
 }
 }
diff --git a/web_server/src/Gallery_Video_Stream.hpp b/web_server/src/Gallery_Video_Stream.hpp
index a369219..f158e9d 100644
--- a/web_server/src/Gallery_Video_Stream.hpp
+++ b/web_server/src/Gallery_Video_Stream.hpp
@@ -1,11 +1,10 @@
 #pragma once
 #include "H264_Encoder.hpp"
 #include "Plot.hpp"
-#include <asio/any_io_executor.hpp>
 #include <cstdint>
 #include <functional>
 #include <memory>
-#include <nlohmann/json_fwd.hpp>
+#include <nlohmann/json.hpp>
 #include <optional>
 #include <string>
 #include <vector>
@@ -27,17 +26,17 @@ public:
     using Stream_Handler =
         std::function<void(Gallery_Stream_Frame)>;
     using Video_Readiness = std::function<bool()>;
+    using Video_Diagnostics = std::function<nlohmann::json()>;
 
     [[nodiscard]] static std::shared_ptr<Gallery_Video_Stream> create(
-        asio::any_io_executor clock_executor,
-        asio::any_io_executor encoding_executor,
         std::vector<Plot_Entry> plots);
     ~Gallery_Video_Stream();
     Gallery_Video_Stream(const Gallery_Video_Stream&) = delete;
     Gallery_Video_Stream& operator=(const Gallery_Video_Stream&) = delete;
 
     [[nodiscard]] Stream_Id subscribe(Stream_Handler handler,
-                                      Video_Readiness video_readiness);
+                                      Video_Readiness video_readiness,
+                                      Video_Diagnostics video_diagnostics);
     void unsubscribe(Stream_Id stream);
     void request_video_key_frame();
     void shutdown() noexcept;
@@ -46,9 +45,7 @@ public:
 
 private:
     struct Private;
-    Gallery_Video_Stream(asio::any_io_executor clock_executor,
-                         asio::any_io_executor encoding_executor,
-                         std::vector<Plot_Entry> plots);
+    explicit Gallery_Video_Stream(std::vector<Plot_Entry> plots);
     void bind_plots();
     std::unique_ptr<Private> d;
 };
diff --git a/web_server/src/Gallery_WebSocket.cpp b/web_server/src/Gallery_WebSocket.cpp
index 4bd3418..effdc36 100644
--- a/web_server/src/Gallery_WebSocket.cpp
+++ b/web_server/src/Gallery_WebSocket.cpp
@@ -74,6 +74,13 @@ void Gallery_WebSocket::start() {
             const auto socket = weak.lock();
             return socket && socket->d->attached.load(std::memory_order_acquire) &&
                 socket->d->video && socket->d->video->can_accept_video();
+        },
+        [weak] {
+            const auto socket = weak.lock();
+            return socket && socket->d->video
+                ? socket->d->video->diagnostics()
+                : nlohmann::json{{"kind", "webrtc_transport_state"},
+                                 {"available", false}};
         });
     if (const auto connection = d->connection.lock();
         connection && connection->connected())
diff --git a/web_server/src/Plot.cpp b/web_server/src/Plot.cpp
index 861ca09..a25a69c 100644
--- a/web_server/src/Plot.cpp
+++ b/web_server/src/Plot.cpp
@@ -1,11 +1,10 @@
 #include "Plot.hpp"
 #include "Renderable_Adapter.hpp"
 #include "Sliding_Statistics.hpp"
-#include <asio/post.hpp>
-#include <asio/strand.hpp>
 #include <nlohmann/json.hpp>
 #include <render_2D/plottable/Plottables.hpp>
 #include <render_3D/Render_3D.hpp>
+#include <render_3D/Gpu_Completion_State.hpp>
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -449,7 +448,7 @@ nlohmann::json Plot_Diagnostics::snapshot() const {
     const double frame_rate = interval != frame_statistics.end() &&
             interval->value("trimmed_average", 0.0) > 0.0
         ? 1'000.0 / interval->value("trimmed_average", 0.0) : 0.0;
-    return {
+    nlohmann::json output{
         {"protocol", "aethera.plot.diagnostics"}, {"version", 1},
         {"dimension", is_3d ? "3D" : "2D"},
         {"sequence", sequence}, {"correlation_id", correlation_id},
@@ -468,6 +467,46 @@ nlohmann::json Plot_Diagnostics::snapshot() const {
                     {"video_enabled", pacing.video_enabled}}},
         {"frame_statistics", std::move(frame_statistics)},
         {"input_statistics", std::move(input_statistics)}};
+    if (is_3d) {
+        const auto gpu = gpu_completion_state();
+        const auto milliseconds = [](std::uint64_t nanoseconds) {
+            return static_cast<double>(nanoseconds) / 1'000'000.0;
+        };
+        output["gpu_completion_domain"] = {
+            {"capacity", gpu.capacity},
+            {"in_flight", gpu.in_flight},
+            {"peak_in_flight", gpu.peak_in_flight},
+            {"utilization_percent", gpu.capacity == 0 ? 0.0 :
+                100.0 * static_cast<double>(gpu.in_flight) /
+                static_cast<double>(gpu.capacity)},
+            {"watched", gpu.watched},
+            {"peak_watched", gpu.peak_watched},
+            {"active_fences", gpu.active_fences},
+            {"pending_fences", gpu.pending_fences},
+            {"reservation_count", gpu.reservation_count},
+            {"completion_count", gpu.completion_count},
+            {"cancellation_count", gpu.cancellation_count},
+            {"fence_probe_count", gpu.fence_probe_count},
+            {"fence_wait_count", gpu.fence_wait_count},
+            {"fence_wait_timeout_count", gpu.fence_wait_timeout_count},
+            {"fence_wait_total_ms", milliseconds(gpu.fence_wait_total_ns)},
+            {"fence_wait_average_ms", gpu.fence_wait_count == 0 ? 0.0 :
+                milliseconds(gpu.fence_wait_total_ns) /
+                static_cast<double>(gpu.fence_wait_count)},
+            {"fence_wait_max_ms", milliseconds(gpu.fence_wait_max_ns)},
+            {"callback_total_ms", milliseconds(gpu.callback_total_ns)},
+            {"callback_average_ms", gpu.completion_count == 0 ? 0.0 :
+                milliseconds(gpu.callback_total_ns) /
+                static_cast<double>(gpu.completion_count)},
+            {"callback_max_ms", milliseconds(gpu.callback_max_ns)},
+            {"callback_failure_count", gpu.callback_failure_count},
+            {"backpressure_count", gpu.backpressure_count},
+            {"backpressure_wait_ms", milliseconds(gpu.backpressure_wait_ns)},
+            {"fault_count", gpu.fault_count},
+            {"abandoned_count", gpu.abandoned_count},
+            {"stopping", gpu.stopping}};
+    }
+    return output;
 }
 
 template <typename Scene_Object>
@@ -551,7 +590,6 @@ struct Plot::Private {
         std::uint32_t height{};
     };
 
-    asio::strand<asio::any_io_executor> strand;
     std::unique_ptr<Scene_View> view;
     std::once_flag start_once;
     mutable std::mutex consumers_mutex;
@@ -568,15 +606,15 @@ struct Plot::Private {
     Scene scene;                                             /* 析构顺序保证 Scene 先停止，再释放物理帧。 */
     mutable std::mutex tick_mutex;
     std::optional<Plot_Render_Tick> pending_tick{};          /* 时钟拥塞时只保留尚未处理的最新时间点。 */
-    bool tick_task_scheduled{};                              /* Plot strand 上是否已有唯一消费任务。 */
+    bool tick_task_scheduled{};                              /* Taskflow 中是否已有唯一 tick 消费任务。 */
+    std::mutex render_preparation_mutex{};                  /* 仅串行本图 CPU prepare；Scene 管理帧在途。 */
     double last_clock_render_time_ms{-std::numeric_limits<double>::infinity()};
     std::chrono::steady_clock::time_point clock_origin{std::chrono::steady_clock::now()};
 
     template <typename Scene_Object>
-    Private(asio::any_io_executor executor, std::unique_ptr<Scene_Object> value_scene,
+    Private(std::unique_ptr<Scene_Object> value_scene,
             std::unique_ptr<Scene_View> value_view)
-        : strand(asio::make_strand(executor)), view(std::move(value_view)),
-          scene(std::move(value_scene)) {
+        : view(std::move(value_view)), scene(std::move(value_scene)) {
         for (auto& slot : frame_slots) {
             if constexpr (std::same_as<Scene_Object, Scene_2D>)
                 slot.frame = std::make_unique<Frame_2D>(Frame_Identity{});
@@ -663,13 +701,18 @@ void Plot::Private::publish(
 }
 
 void Plot::Private::consume_tick() {
-    std::optional<Plot_Render_Tick> tick;
-    {
-        std::lock_guard lock(tick_mutex);
-        tick = std::exchange(pending_tick, {});
-        tick_task_scheduled = false;
+    for (;;) {
+        std::optional<Plot_Render_Tick> tick;
+        {
+            std::lock_guard lock(tick_mutex);
+            tick = std::exchange(pending_tick, {});
+            if (!tick) {
+                tick_task_scheduled = false;
+                return;
+            }
+        }
+        clock_tick(*tick);
     }
-    if (tick) clock_tick(*tick);
 }
 
 void Plot::Private::clock_tick(const Plot_Render_Tick& tick) {
@@ -687,18 +730,14 @@ void Plot::Private::clock_tick(const Plot_Render_Tick& tick) {
 }
 
 void Plot::Private::render_frame(Plot_Render_Tick tick) {
+    std::unique_lock preparation_lock(render_preparation_mutex, std::try_to_lock);
+    if (!preparation_lock.owns_lock()) return;
     if (terminal_failure.load(std::memory_order_acquire)) return;
     const auto streams = stream_snapshot();
     const auto pacing = frame_policy.snapshot();
     if (!pacing.render_enabled || streams.consumers.empty()) return;
     {
         std::lock_guard lock(frame_mutex);
-        const auto in_flight = std::ranges::count_if(
-            frame_slots, [](const Managed_Frame& slot) {
-                return slot.state == Frame_State::in_flight;
-            });
-        if (std::holds_alternative<std::unique_ptr<Scene_3D>>(scene) &&
-            in_flight >= scene_frame_capacity - 1) return;
         if (std::ranges::none_of(frame_slots, [](const Managed_Frame& slot) {
                 return slot.state == Frame_State::available;
             })) return;
@@ -923,19 +962,19 @@ void Plot::Private::queue_completed_frame(Render_Frame* frame) {
     }
 }
 
-Plot::Plot(asio::any_io_executor executor, std::unique_ptr<Scene_2D> scene,
+Plot::Plot(std::unique_ptr<Scene_2D> scene,
            std::unique_ptr<Scene_View> view)
-    : d(std::make_unique<Private>(std::move(executor), std::move(scene), std::move(view))) {}
-Plot::Plot(asio::any_io_executor executor, std::unique_ptr<Scene_3D> scene,
+    : d(std::make_unique<Private>(std::move(scene), std::move(view))) {}
+Plot::Plot(std::unique_ptr<Scene_3D> scene,
            std::unique_ptr<Scene_View> view)
-    : d(std::make_unique<Private>(std::move(executor), std::move(scene), std::move(view))) {}
+    : d(std::make_unique<Private>(std::move(scene), std::move(view))) {}
 Plot::~Plot() = default;
 
 void Plot::ensure_started() {
     std::call_once(d->start_once, [this] {
         /*
          * 页面级帧时钟只触发 render；Scene 完成回调直接归还帧并发布结果。
-         * 回调不请求下一帧，也不重新投递到 Plot strand；这使准备、GPU
+         * 回调不请求下一帧，也不重新投递任务；Scene 在回调返回时释放准入，
          * 提交和页面级媒体图集能够按各自的资源域自然流水。
          */
         if (auto* scene = std::get_if<std::unique_ptr<Scene_2D>>(&d->scene)) {
@@ -1016,7 +1055,7 @@ void Plot::schedule_render(Plot_Render_Tick tick) {
     }
     if (!schedule) return;
     const auto weak = weak_from_this();
-    asio::post(d->strand, [weak] {
+    aethera::schedule_task([weak] {
         const auto owner = weak.lock();
         if (!owner) return;
         try {
@@ -1031,7 +1070,7 @@ void Plot::schedule_render(Plot_Render_Tick tick) {
 void Plot::render_once() {
     ensure_started();
     const auto weak = weak_from_this();
-    asio::post(d->strand, [weak] {
+    aethera::schedule_task([weak] {
         const auto owner = weak.lock();
         if (!owner) return;
         try {
@@ -1071,7 +1110,7 @@ void Plot::async_schema(Json_Handler handler) {
     if (!handler) throw std::invalid_argument("Plot schema handler is empty");
     ensure_started();
     auto self = shared_from_this();
-    asio::post(d->strand, [self, handler = std::move(handler)]() mutable {
+    aethera::schedule_task([self, handler = std::move(handler)]() mutable {
         nlohmann::json result;
         try {
             result = self->d->schema();
@@ -1092,7 +1131,7 @@ void Plot::async_write_prop(std::string component, std::string key,
     if (!handler) throw std::invalid_argument("Plot property handler is empty");
     ensure_started();
     auto self = shared_from_this();
-    asio::post(d->strand,
+    aethera::schedule_task(
         [self, component = std::move(component), key = std::move(key),
          value = std::move(value), handler = std::move(handler)]() mutable {
             nlohmann::json result;
@@ -1116,7 +1155,7 @@ void Plot::async_generate_data(nlohmann::json input, Json_Handler handler) {
     if (!handler) throw std::invalid_argument("Plot data handler is empty");
     ensure_started();
     auto self = shared_from_this();
-    asio::post(d->strand,
+    aethera::schedule_task(
         [self, input = std::move(input), handler = std::move(handler)]() mutable {
             nlohmann::json result;
             try {
diff --git a/web_server/src/Plot.hpp b/web_server/src/Plot.hpp
index bfc6678..8e6e5e6 100644
--- a/web_server/src/Plot.hpp
+++ b/web_server/src/Plot.hpp
@@ -1,5 +1,4 @@
 #pragma once
-#include <asio/any_io_executor.hpp>
 #include <nlohmann/json_fwd.hpp>
 #include <render_2D/scene/Render_Scene_2D.hpp>
 #include <render_3D/scene/Render_Scene_3D.hpp>
@@ -72,11 +71,9 @@ public:
         virtual void update(const Plot_Render_Tick& tick) = 0;
     };
 
-    Plot(asio::any_io_executor executor,
-         std::unique_ptr<Impl<render_2d::Render_Scene_2D>> scene,
+    Plot(std::unique_ptr<Impl<render_2d::Render_Scene_2D>> scene,
          std::unique_ptr<Scene_View> view);
-    Plot(asio::any_io_executor executor,
-         std::unique_ptr<Impl<render_3d::Render_Scene_3D>> scene,
+    Plot(std::unique_ptr<Impl<render_3d::Render_Scene_3D>> scene,
          std::unique_ptr<Scene_View> view);
     ~Plot();
     Plot(const Plot&) = delete;
diff --git a/web_server/src/WebRtc_Video_Session.cpp b/web_server/src/WebRtc_Video_Session.cpp
index aa111b3..4ff016b 100644
--- a/web_server/src/WebRtc_Video_Session.cpp
+++ b/web_server/src/WebRtc_Video_Session.cpp
@@ -1,5 +1,6 @@
 #include "WebRtc_Video_Session.hpp"
 #include <concurrentqueue-1.0.5/blockingconcurrentqueue.h>
+#include <double_buffer/mechanism.hpp>
 #include <nlohmann/json.hpp>
 #include <rtc/rtc.hpp>
 #include <atomic>
@@ -22,9 +23,46 @@ std::uint32_t make_ssrc() {
     std::random_device source;
     return (static_cast<std::uint32_t>(source()) << 16U) ^ source();
 }
+std::uint64_t steady_nanoseconds() noexcept {
+    return static_cast<std::uint64_t>(std::chrono::duration_cast<
+        std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
+}
+void update_maximum(std::atomic_uint64_t& maximum,
+                    std::uint64_t value) noexcept {
+    auto current = maximum.load(std::memory_order_relaxed);
+    while (current < value &&
+        !maximum.compare_exchange_weak(current, value,
+                                       std::memory_order_relaxed)) {}
+}
 }
 
 struct WebRtc_Video_Session::Private {
+    struct State_Tag {};
+    struct State : double_buffer::State_Type<State_Tag> {
+        std::size_t outstanding_video_frames{};
+        std::size_t transport_buffered_bytes{};
+        std::uint64_t queued_frame_count{};
+        std::uint64_t rejected_frame_count{};
+        std::uint64_t queued_byte_count{};
+        std::uint64_t sent_frame_count{};
+        std::uint64_t sent_byte_count{};
+        std::uint64_t send_failure_count{};
+        std::uint64_t send_total_ns{};
+        std::uint64_t send_max_ns{};
+        std::uint64_t current_send_ns{};
+        std::uint64_t media_lock_wait_count{};
+        std::uint64_t media_lock_wait_total_ns{};
+        std::uint64_t media_lock_wait_max_ns{};
+        std::uint64_t readiness_check_count{};
+        std::uint64_t readiness_reject_count{};
+        std::uint64_t close_join_total_ns{};
+        std::uint64_t close_join_max_ns{};
+        std::uint64_t current_close_join_ns{};
+        bool track_open{};
+        bool closed{};
+        bool sender_running{};
+        bool operator==(const State&) const = default;
+    };
     struct Callback_State {
         Signal_Handler signal_handler;                      /* SDP/ICE 信令的唯一交付出口。 */
         Ready_Handler ready_handler;                        /* Track 打开后请求首个 IDR。 */
@@ -51,6 +89,38 @@ struct WebRtc_Video_Session::Private {
         pending_frames{4};                                 /* 尚未发送的最新编码帧入口。 */
     std::thread sender_thread{};                            /* 唯一的 RTP/SRTP 发送资源域。 */
     std::atomic_size_t outstanding_video_frames{};          /* sendFrame 中和队列中的完整 access unit 数。 */
+    std::atomic_uint64_t queued_frame_count{};
+    std::atomic_uint64_t rejected_frame_count{};
+    std::atomic_uint64_t queued_byte_count{};
+    std::atomic_uint64_t sent_frame_count{};
+    std::atomic_uint64_t sent_byte_count{};
+    std::atomic_uint64_t send_failure_count{};
+    std::atomic_uint64_t send_total_ns{};
+    std::atomic_uint64_t send_max_ns{};
+    std::atomic_uint64_t send_started_ns{};
+    std::atomic_bool send_active{};
+    std::atomic_bool sender_loop_active{};
+    std::atomic_uint64_t media_lock_wait_count{};
+    std::atomic_uint64_t media_lock_wait_total_ns{};
+    std::atomic_uint64_t media_lock_wait_max_ns{};
+    std::atomic_size_t transport_buffered_bytes{};
+    std::atomic_uint64_t readiness_check_count{};
+    std::atomic_uint64_t readiness_reject_count{};
+    std::atomic_uint64_t close_join_started_ns{};
+    std::atomic_uint64_t close_join_total_ns{};
+    std::atomic_uint64_t close_join_max_ns{};
+    std::atomic_bool close_join_active{};
+    /* WebRTC 是 web_server 会话域，不借用 Scene State。热路径只写原子计数；
+     * 低频 diagnostics 请求在这里聚合并交换会话自己的发布双缓冲。 */
+    mutable std::mutex state_publication_mutex;
+    mutable double_buffer::Publish_Double_Buffer<State> state{};
+
+    void record_media_lock_wait(std::uint64_t started) noexcept {
+        const auto elapsed = steady_nanoseconds() - started;
+        media_lock_wait_count.fetch_add(1, std::memory_order_relaxed);
+        media_lock_wait_total_ns.fetch_add(elapsed, std::memory_order_relaxed);
+        update_maximum(media_lock_wait_max_ns, elapsed);
+    }
 
     Private(Signal_Handler signal_handler, Ready_Handler ready_handler,
             Failure_Handler failure_handler)
@@ -64,6 +134,11 @@ struct WebRtc_Video_Session::Private {
     }
 
     void run_sender() noexcept {
+        sender_loop_active.store(true, std::memory_order_release);
+        struct Sender_Exit final {
+            std::atomic_bool& active;
+            ~Sender_Exit() { active.store(false, std::memory_order_release); }
+        } sender_exit{sender_loop_active};
         for (;;) {
             Encoded_Video_Frame frame;
             pending_frames.wait_dequeue(frame);
@@ -71,24 +146,39 @@ struct WebRtc_Video_Session::Private {
                 callbacks->closed.load(std::memory_order_acquire))
                 return;
             try {
+                const auto lock_started = steady_nanoseconds();
                 std::lock_guard lock(media_mutex);
+                record_media_lock_wait(lock_started);
                 if (!video_track ||
                     !callbacks->track_open.load(std::memory_order_acquire) ||
                     callbacks->closed.load(std::memory_order_acquire)) {
                     outstanding_video_frames.fetch_sub(
                         1, std::memory_order_release);
+                    rejected_frame_count.fetch_add(1, std::memory_order_relaxed);
                     continue;
                 }
                 /* rtc::binary 与编码器 access unit 使用相同的 byte vector。
                  * 这里把所有权直接交给 packetizer，禁止再次复制完整 H.264 帧。 */
+                const auto byte_count = frame.annex_b.size();
+                const auto send_started = steady_nanoseconds();
+                send_started_ns.store(send_started, std::memory_order_relaxed);
+                send_active.store(true, std::memory_order_release);
                 video_track->sendFrame(
                     std::move(frame.annex_b),
                     rtc::FrameInfo(std::chrono::duration<double>(
                         frame.presentation_time)));
+                const auto send_elapsed = steady_nanoseconds() - send_started;
+                send_active.store(false, std::memory_order_release);
+                send_total_ns.fetch_add(send_elapsed, std::memory_order_relaxed);
+                update_maximum(send_max_ns, send_elapsed);
+                sent_frame_count.fetch_add(1, std::memory_order_relaxed);
+                sent_byte_count.fetch_add(byte_count, std::memory_order_relaxed);
                 outstanding_video_frames.fetch_sub(
                     1, std::memory_order_release);
             }
             catch (...) {
+                send_active.store(false, std::memory_order_release);
+                send_failure_count.fetch_add(1, std::memory_order_relaxed);
                 outstanding_video_frames.fetch_sub(
                     1, std::memory_order_release);
                 if (!callbacks->closed.load(std::memory_order_acquire) &&
@@ -230,14 +320,17 @@ WebRtc_Video_Session::Send_Result WebRtc_Video_Session::send(
     if (frame.annex_b.empty() ||
         !d->callbacks->track_open.load(std::memory_order_acquire) ||
         d->callbacks->closed.load(std::memory_order_acquire) ||
-        !d->sender_thread.joinable())
+        !d->sender_thread.joinable()) {
+        d->rejected_frame_count.fetch_add(1, std::memory_order_relaxed);
         return Send_Result::not_open;
+    }
 
     const auto previous = d->outstanding_video_frames.fetch_add(
         1, std::memory_order_acq_rel);
     if (previous >= maximum_outstanding_video_frames) {
         d->outstanding_video_frames.fetch_sub(
             1, std::memory_order_release);
+        d->rejected_frame_count.fetch_add(1, std::memory_order_relaxed);
         return Send_Result::not_open;
     }
 
@@ -250,23 +343,105 @@ WebRtc_Video_Session::Send_Result WebRtc_Video_Session::send(
     // 构造参数只预分配首批槽位；try_enqueue() 在这批槽位瞬时占满时不会
     // 扩容，会把正常背压误判成内存失败。enqueue() 允许 concurrentqueue
     // 按需增加块，实际持续突发由 RTP pacer 消化。
+    const auto byte_count = frame.annex_b.size();
     if (!d->pending_frames.enqueue(std::move(frame))) {
         d->outstanding_video_frames.fetch_sub(
             1, std::memory_order_release);
+        d->rejected_frame_count.fetch_add(1, std::memory_order_relaxed);
         throw std::bad_alloc{};
     }
+    d->queued_frame_count.fetch_add(1, std::memory_order_relaxed);
+    d->queued_byte_count.fetch_add(byte_count, std::memory_order_relaxed);
     return Send_Result::queued;
 }
 
 bool WebRtc_Video_Session::can_accept_video() const noexcept {
+    d->readiness_check_count.fetch_add(1, std::memory_order_relaxed);
+    const auto lock_started = steady_nanoseconds();
     std::lock_guard lock(d->media_mutex);
-    return d->callbacks->track_open.load(std::memory_order_acquire) &&
+    d->record_media_lock_wait(lock_started);
+    const auto buffered = d->video_track ? d->video_track->bufferedAmount() : 0;
+    d->transport_buffered_bytes.store(buffered, std::memory_order_relaxed);
+    const bool ready = d->callbacks->track_open.load(std::memory_order_acquire) &&
         !d->callbacks->closed.load(std::memory_order_acquire) &&
         d->sender_thread.joinable() &&
         d->video_track &&
-        d->video_track->bufferedAmount() < maximum_transport_buffered_bytes &&
+        buffered < maximum_transport_buffered_bytes &&
         d->outstanding_video_frames.load(std::memory_order_acquire) <
             maximum_outstanding_video_frames;
+    if (!ready)
+        d->readiness_reject_count.fetch_add(1, std::memory_order_relaxed);
+    return ready;
+}
+
+nlohmann::json WebRtc_Video_Session::diagnostics() const {
+    std::lock_guard publication_lock(d->state_publication_mutex);
+    auto& state_to_publish = *d->state.current;
+    const auto now = steady_nanoseconds();
+    state_to_publish.outstanding_video_frames =
+        d->outstanding_video_frames.load(std::memory_order_relaxed);
+    state_to_publish.transport_buffered_bytes =
+        d->transport_buffered_bytes.load(std::memory_order_relaxed);
+    state_to_publish.queued_frame_count = d->queued_frame_count.load(std::memory_order_relaxed);
+    state_to_publish.rejected_frame_count = d->rejected_frame_count.load(std::memory_order_relaxed);
+    state_to_publish.queued_byte_count = d->queued_byte_count.load(std::memory_order_relaxed);
+    state_to_publish.sent_frame_count = d->sent_frame_count.load(std::memory_order_relaxed);
+    state_to_publish.sent_byte_count = d->sent_byte_count.load(std::memory_order_relaxed);
+    state_to_publish.send_failure_count = d->send_failure_count.load(std::memory_order_relaxed);
+    state_to_publish.send_total_ns = d->send_total_ns.load(std::memory_order_relaxed);
+    state_to_publish.send_max_ns = d->send_max_ns.load(std::memory_order_relaxed);
+    state_to_publish.current_send_ns = d->send_active.load(std::memory_order_acquire)
+        ? now - d->send_started_ns.load(std::memory_order_relaxed) : 0;
+    state_to_publish.media_lock_wait_count = d->media_lock_wait_count.load(std::memory_order_relaxed);
+    state_to_publish.media_lock_wait_total_ns = d->media_lock_wait_total_ns.load(std::memory_order_relaxed);
+    state_to_publish.media_lock_wait_max_ns = d->media_lock_wait_max_ns.load(std::memory_order_relaxed);
+    state_to_publish.readiness_check_count = d->readiness_check_count.load(std::memory_order_relaxed);
+    state_to_publish.readiness_reject_count = d->readiness_reject_count.load(std::memory_order_relaxed);
+    state_to_publish.close_join_total_ns = d->close_join_total_ns.load(std::memory_order_relaxed);
+    state_to_publish.close_join_max_ns = d->close_join_max_ns.load(std::memory_order_relaxed);
+    state_to_publish.current_close_join_ns = d->close_join_active.load(std::memory_order_acquire)
+        ? now - d->close_join_started_ns.load(std::memory_order_relaxed) : 0;
+    state_to_publish.track_open = d->callbacks->track_open.load(std::memory_order_relaxed);
+    state_to_publish.closed = d->callbacks->closed.load(std::memory_order_relaxed);
+    state_to_publish.sender_running = d->sender_loop_active.load(std::memory_order_relaxed);
+    d->state.advance();
+
+    const auto snapshot = *d->state.pending;
+    const auto milliseconds = [](std::uint64_t nanoseconds) {
+        return static_cast<double>(nanoseconds) / 1'000'000.0;
+    };
+    return {
+        {"kind", "webrtc_transport_state"},
+        {"protocol", "aethera.gallery.webrtc"},
+        {"version", 1},
+        {"track_open", snapshot.track_open},
+        {"closed", snapshot.closed},
+        {"sender_running", snapshot.sender_running},
+        {"outstanding_video_frames", snapshot.outstanding_video_frames},
+        {"transport_buffered_bytes", snapshot.transport_buffered_bytes},
+        {"queued_frame_count", snapshot.queued_frame_count},
+        {"rejected_frame_count", snapshot.rejected_frame_count},
+        {"queued_megabytes", static_cast<double>(snapshot.queued_byte_count) /
+            (1024.0 * 1024.0)},
+        {"sent_frame_count", snapshot.sent_frame_count},
+        {"sent_megabytes", static_cast<double>(snapshot.sent_byte_count) /
+            (1024.0 * 1024.0)},
+        {"send_failure_count", snapshot.send_failure_count},
+        {"send_average_ms", snapshot.sent_frame_count == 0 ? 0.0 :
+            milliseconds(snapshot.send_total_ns) /
+            static_cast<double>(snapshot.sent_frame_count)},
+        {"send_max_ms", milliseconds(snapshot.send_max_ns)},
+        {"current_send_ms", milliseconds(snapshot.current_send_ns)},
+        {"media_lock_wait_count", snapshot.media_lock_wait_count},
+        {"media_lock_wait_average_ms", snapshot.media_lock_wait_count == 0 ? 0.0 :
+            milliseconds(snapshot.media_lock_wait_total_ns) /
+            static_cast<double>(snapshot.media_lock_wait_count)},
+        {"media_lock_wait_max_ms", milliseconds(snapshot.media_lock_wait_max_ns)},
+        {"readiness_check_count", snapshot.readiness_check_count},
+        {"readiness_reject_count", snapshot.readiness_reject_count},
+        {"close_join_total_ms", milliseconds(snapshot.close_join_total_ns)},
+        {"close_join_max_ms", milliseconds(snapshot.close_join_max_ns)},
+        {"current_close_join_ms", milliseconds(snapshot.current_close_join_ns)}};
 }
 
 void WebRtc_Video_Session::close() noexcept {
@@ -279,7 +454,16 @@ void WebRtc_Video_Session::close() noexcept {
         while (!d->pending_frames.try_enqueue(
             Encoded_Video_Frame{}))
             std::this_thread::yield();
-        if (d->sender_thread.joinable()) d->sender_thread.join();
+        if (d->sender_thread.joinable()) {
+            const auto join_started = steady_nanoseconds();
+            d->close_join_started_ns.store(join_started, std::memory_order_relaxed);
+            d->close_join_active.store(true, std::memory_order_release);
+            d->sender_thread.join();
+            const auto join_elapsed = steady_nanoseconds() - join_started;
+            d->close_join_active.store(false, std::memory_order_release);
+            d->close_join_total_ns.fetch_add(join_elapsed, std::memory_order_relaxed);
+            update_maximum(d->close_join_max_ns, join_elapsed);
+        }
         while (d->pending_frames.try_dequeue(discarded)) {}
         d->outstanding_video_frames.store(0, std::memory_order_release);
 
diff --git a/web_server/src/WebRtc_Video_Session.hpp b/web_server/src/WebRtc_Video_Session.hpp
index 1540cf2..227d33d 100644
--- a/web_server/src/WebRtc_Video_Session.hpp
+++ b/web_server/src/WebRtc_Video_Session.hpp
@@ -4,6 +4,7 @@
 #include <exception>
 #include <functional>
 #include <memory>
+#include <nlohmann/json_fwd.hpp>
 #include <string>
 #include <string_view>
 
@@ -31,6 +32,7 @@ public:
     [[nodiscard]] Send_Result send(
         Encoded_Video_Frame frame);
     [[nodiscard]] bool can_accept_video() const noexcept;
+    [[nodiscard]] nlohmann::json diagnostics() const;
     void close() noexcept;
 
 private:
diff --git a/web_server/src/Web_Server.cpp b/web_server/src/Web_Server.cpp
index 899536c..2bad2b4 100644
--- a/web_server/src/Web_Server.cpp
+++ b/web_server/src/Web_Server.cpp
@@ -3,7 +3,6 @@
 #include "Gallery_WebSocket.hpp"
 #include "Graph_WebSocket.hpp"
 #include "Gallery_Plots.hpp"
-#include <asio/thread_pool.hpp>
 #include <drogon/drogon.h>
 #include <nlohmann/json.hpp>
 #include <algorithm>
@@ -42,46 +41,31 @@ std::shared_ptr<Plot> find_plot(const Plot_Map& plots, std::string_view id) {
 }
 
 int run_web_server(std::uint16_t port, const std::filesystem::path& asset_root) {
-    const auto hardware_threads = std::max(2U, std::thread::hardware_concurrency());
-    const auto plot_workers = std::min(8U, hardware_threads);
-    /* 2D 的同步 Blend2D 绘制不能占满 3D 的帧时钟与 Visual Prepare 域。
-     * 两类 Plot 使用同一套 Plot/帧策略实现，但执行资源按渲染架构隔离。 */
-    auto plot_2d_pool = std::make_shared<asio::thread_pool>(plot_workers);
-    auto plot_3d_pool = std::make_shared<asio::thread_pool>(plot_workers);
-    auto gallery_clock_pool = std::make_shared<asio::thread_pool>(1);
-    // 原生 720x420 画质按四图一个媒体组并行编码。每路图集仍是完整像素
-    // 视频，但较小的 access unit 缩短 libdatachannel packetize/DTLS 临界段；
-    // 时钟只负责轻量 tick，六路编码各有独立 strand 和执行线程。
-    auto gallery_encoding_pool = std::make_shared<asio::thread_pool>(
-        std::min(6U, hardware_threads));
-    const auto executor_2d = plot_2d_pool->get_executor();
-    const auto executor_3d = plot_3d_pool->get_executor();
-
     auto plots = std::make_shared<Plot_Map>();
-    plots->emplace("axes", make_axes_plot(executor_2d));
-    plots->emplace("spectrum", make_spectrum_plot(executor_2d));
-    plots->emplace("frequency_trace", make_frequency_trace_plot(executor_2d));
-    plots->emplace("sweep_spectrum", make_sweep_spectrum_plot(executor_2d));
-    plots->emplace("afterglow", make_afterglow_plot(executor_2d));
-    plots->emplace("waterfall", make_waterfall_plot(executor_2d));
-    plots->emplace("constellation", make_constellation_plot(executor_2d));
-    plots->emplace("selection_overlay", make_selection_overlay_plot(executor_2d));
-    plots->emplace("datoviz_point", make_datoviz_point_plot(executor_3d));
-    plots->emplace("datoviz_splat", make_datoviz_splat_plot(executor_3d));
-    plots->emplace("datoviz_pixel", make_datoviz_pixel_plot(executor_3d));
-    plots->emplace("datoviz_marker", make_datoviz_marker_plot(executor_3d));
-    plots->emplace("datoviz_sphere", make_datoviz_sphere_plot(executor_3d));
-    plots->emplace("datoviz_segment", make_datoviz_segment_plot(executor_3d));
-    plots->emplace("datoviz_vector", make_datoviz_vector_plot(executor_3d));
-    plots->emplace("datoviz_primitive", make_datoviz_primitive_plot(executor_3d));
-    plots->emplace("datoviz_mesh", make_datoviz_mesh_plot(executor_3d));
-    plots->emplace("datoviz_spectrogram", make_datoviz_spectrogram_plot(executor_3d));
-    plots->emplace("datoviz_path", make_datoviz_path_plot(executor_3d));
-    plots->emplace("datoviz_image", make_datoviz_image_plot(executor_3d));
-    plots->emplace("datoviz_labels", make_datoviz_labels_plot(executor_3d));
-    plots->emplace("datoviz_glyph", make_datoviz_glyph_plot(executor_3d));
-    plots->emplace("datoviz_text", make_datoviz_text_plot(executor_3d));
-    plots->emplace("datoviz_volume", make_datoviz_volume_plot(executor_3d));
+    plots->emplace("axes", make_axes_plot());
+    plots->emplace("spectrum", make_spectrum_plot());
+    plots->emplace("frequency_trace", make_frequency_trace_plot());
+    plots->emplace("sweep_spectrum", make_sweep_spectrum_plot());
+    plots->emplace("afterglow", make_afterglow_plot());
+    plots->emplace("waterfall", make_waterfall_plot());
+    plots->emplace("constellation", make_constellation_plot());
+    plots->emplace("selection_overlay", make_selection_overlay_plot());
+    plots->emplace("datoviz_point", make_datoviz_point_plot());
+    plots->emplace("datoviz_splat", make_datoviz_splat_plot());
+    plots->emplace("datoviz_pixel", make_datoviz_pixel_plot());
+    plots->emplace("datoviz_marker", make_datoviz_marker_plot());
+    plots->emplace("datoviz_sphere", make_datoviz_sphere_plot());
+    plots->emplace("datoviz_segment", make_datoviz_segment_plot());
+    plots->emplace("datoviz_vector", make_datoviz_vector_plot());
+    plots->emplace("datoviz_primitive", make_datoviz_primitive_plot());
+    plots->emplace("datoviz_mesh", make_datoviz_mesh_plot());
+    plots->emplace("datoviz_spectrogram", make_datoviz_spectrogram_plot());
+    plots->emplace("datoviz_path", make_datoviz_path_plot());
+    plots->emplace("datoviz_image", make_datoviz_image_plot());
+    plots->emplace("datoviz_labels", make_datoviz_labels_plot());
+    plots->emplace("datoviz_glyph", make_datoviz_glyph_plot());
+    plots->emplace("datoviz_text", make_datoviz_text_plot());
+    plots->emplace("datoviz_volume", make_datoviz_volume_plot());
 
     std::vector<Gallery_Video_Stream::Plot_Entry> gallery_2d;
     std::vector<Gallery_Video_Stream::Plot_Entry> gallery_3d;
@@ -99,18 +83,14 @@ int run_web_server(std::uint16_t port, const std::filesystem::path& asset_root)
     auto gallery_streams = std::make_shared<Gallery_Stream_Map>();
     auto plot_media = std::make_shared<
         std::unordered_map<std::string, std::string>>();
-    const auto add_media_group = [&gallery_streams, &plot_media,
-                                  &gallery_clock_pool,
-                                  &gallery_encoding_pool](
+    const auto add_media_group = [&gallery_streams, &plot_media](
         std::string id,
         std::vector<Gallery_Video_Stream::Plot_Entry> entries) {
         const auto path = "/ws/gallery?group=" + id;
         for (const auto& entry : entries)
             plot_media->emplace(entry.id, path);
         gallery_streams->emplace(
-            std::move(id), Gallery_Video_Stream::create(
-                gallery_clock_pool->get_executor(),
-                gallery_encoding_pool->get_executor(), std::move(entries)));
+            std::move(id), Gallery_Video_Stream::create(std::move(entries)));
     };
     constexpr std::size_t plots_per_media_group{4};
     const auto add_media_groups = [&add_media_group](
@@ -260,23 +240,15 @@ int run_web_server(std::uint16_t port, const std::filesystem::path& asset_root)
         .setHomePage("index.html")
         .setStaticFileHeaders({{"Cache-Control", "no-store"}})
         .addListener("127.0.0.1", port)
-        .setThreadNum(std::min(8U, hardware_threads))
+        .setThreadNum(std::min(8U, std::max(2U, std::thread::hardware_concurrency())))
         .setIdleConnectionTimeout(90)
         .run();
-    /* 先解除 Plot 完成帧订阅并停止页面时钟，再停止其执行资源。
-     * 这样销毁期不存在回调访问已释放图集、计时器跨线程 cancel 或半途编码。 */
+    /* 先解除 Plot 完成帧订阅并停止页面时钟；Taskflow 任务只捕获弱所有权，
+     * 因而销毁期不会访问已经释放的图集，也不需要额外业务线程池排空。 */
     for (const auto& [id, stream] : *gallery_streams) {
         static_cast<void>(id);
         stream->shutdown();
     }
-    plot_2d_pool->stop();
-    plot_3d_pool->stop();
-    gallery_clock_pool->stop();
-    gallery_encoding_pool->stop();
-    plot_2d_pool->join();
-    plot_3d_pool->join();
-    gallery_clock_pool->join();
-    gallery_encoding_pool->join();
     return 0;
 }
 }
diff --git a/web_server/src/detail/Gallery_Frame_Clock.cpp b/web_server/src/detail/Gallery_Frame_Clock.cpp
index 091527e..ef25f67 100644
--- a/web_server/src/detail/Gallery_Frame_Clock.cpp
+++ b/web_server/src/detail/Gallery_Frame_Clock.cpp
@@ -1,32 +1,26 @@
 #include "Gallery_Frame_Clock.hpp"
-#include <asio/error_code.hpp>
-#include <asio/error.hpp>
-#include <asio/post.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/strand.hpp>
 #include <atomic>
 #include <chrono>
 #include <cmath>
+#include <condition_variable>
+#include <mutex>
 #include <stdexcept>
+#include <thread>
 #include <utility>
 
 namespace aethera::web::detail {
-struct Gallery_Frame_Clock::Private
-    : std::enable_shared_from_this<Gallery_Frame_Clock::Private> {
-    asio::strand<asio::any_io_executor> strand;
-    asio::steady_timer timer;
-    std::chrono::nanoseconds interval{};                    /* 相邻页面级 tick 的固定单调时间间隔。 */
-    Tick_Handler tick_handler{};                            /* 每个绝对时钟点唯一的业务消费出口。 */
-    Failure_Handler failure_handler{};                      /* 计时任务 Unknown Failure 的隔离出口。 */
-    std::atomic_bool requested{};                           /* 跨线程 start/stop 的唯一请求状态。 */
-    bool running{};                                         /* 仅在 strand 上读写的计时器运行状态。 */
-    std::chrono::steady_clock::time_point origin{};         /* 当前运行周期媒体时间戳的绝对原点。 */
+struct Gallery_Frame_Clock::Private {
+    std::chrono::nanoseconds interval{};
+    Tick_Handler tick_handler{};
+    Failure_Handler failure_handler{};
+    std::mutex lifecycle_mutex{};
+    std::condition_variable_any wake{};
+    std::jthread thread{};
+    std::atomic_bool running{};
 
-    Private(asio::any_io_executor executor, double frame_rate,
-            Tick_Handler value_tick_handler,
+    Private(double frame_rate, Tick_Handler value_tick_handler,
             Failure_Handler value_failure_handler)
-        : strand(asio::make_strand(std::move(executor))), timer(strand),
-          tick_handler(std::move(value_tick_handler)),
+        : tick_handler(std::move(value_tick_handler)),
           failure_handler(std::move(value_failure_handler)) {
         if (!std::isfinite(frame_rate) || frame_rate <= 0.0)
             throw std::invalid_argument("gallery frame rate must be positive");
@@ -38,109 +32,63 @@ struct Gallery_Frame_Clock::Private
             throw std::invalid_argument("gallery frame clock requires a tick handler");
     }
 
-    void begin() {
-        if (!requested.load(std::memory_order_acquire) || running) return;
-        running = true;
-        origin = std::chrono::steady_clock::now();
-        timer.expires_at(origin + interval);
-        arm();
-    }
-
-    void cancel() {
-        running = false;
-        timer.cancel();
-    }
-
     void report(std::exception_ptr failure) noexcept {
-        running = false;
-        requested.store(false, std::memory_order_release);
-        try { timer.cancel(); }
-        catch (...) {}
+        running.store(false, std::memory_order_release);
         if (!failure_handler) return;
         try { failure_handler(std::move(failure)); }
         catch (...) {}
     }
 
-    void arm() {
-        const std::weak_ptr<Private> weak = shared_from_this();
-        timer.async_wait([weak](const asio::error_code& error) {
-            const auto self = weak.lock();
-            if (!self) return;
-            if (error) {
-                if (error != asio::error::operation_aborted)
-                    self->report(std::make_exception_ptr(std::runtime_error(
-                        "gallery frame timer failed: " + error.message())));
+    void run(std::stop_token stop) noexcept {
+        const auto origin = std::chrono::steady_clock::now();
+        std::uint64_t sequence{};
+        auto deadline = origin + interval;
+        while (!stop.stop_requested()) {
+            std::unique_lock lock(lifecycle_mutex);
+            wake.wait_until(lock, stop, deadline, [] { return false; });
+            lock.unlock();
+            if (stop.stop_requested()) break;
+            try {
+                ++sequence;
+                tick_handler(Plot_Render_Tick{
+                    sequence,
+                    std::chrono::duration<double, std::milli>(deadline - origin).count()});
+                deadline += interval;
+                const auto now = std::chrono::steady_clock::now();
+                if (deadline <= now)
+                    deadline += interval * ((now - deadline) / interval + 1);
+            }
+            catch (...) {
+                report(std::current_exception());
                 return;
             }
-            if (!self->running ||
-                !self->requested.load(std::memory_order_acquire)) return;
-            self->fire();
-        });
-    }
-
-    void fire() {
-        try {
-            const auto deadline = timer.expiry();
-            const auto elapsed = deadline - origin;
-            const auto sequence = static_cast<std::uint64_t>(elapsed / interval);
-            auto next = deadline + interval;
-            const auto now = std::chrono::steady_clock::now();
-            if (next <= now) {
-                const auto missed = (now - next) / interval + 1;
-                next += interval * missed;
-            }
-            timer.expires_at(next);
-            arm();
-            tick_handler(Plot_Render_Tick{
-                sequence,
-                std::chrono::duration<double, std::milli>(elapsed).count()});
-        }
-        catch (...) {
-            report(std::current_exception());
         }
+        running.store(false, std::memory_order_release);
     }
 };
 
 Gallery_Frame_Clock::Gallery_Frame_Clock(
-    asio::any_io_executor executor, double frame_rate,
-    Tick_Handler tick_handler, Failure_Handler failure_handler)
-    : d(std::make_shared<Private>(std::move(executor), frame_rate,
-                                  std::move(tick_handler),
+    double frame_rate, Tick_Handler tick_handler,
+    Failure_Handler failure_handler)
+    : d(std::make_shared<Private>(frame_rate, std::move(tick_handler),
                                   std::move(failure_handler))) {}
 
-Gallery_Frame_Clock::~Gallery_Frame_Clock() {
-    stop();
-    d.reset();
-}
+Gallery_Frame_Clock::~Gallery_Frame_Clock() { stop(); }
 
 void Gallery_Frame_Clock::start() {
-    if (d->requested.exchange(true, std::memory_order_acq_rel)) return;
-    const std::weak_ptr<Private> weak = d;
-    try {
-        asio::post(d->strand, [weak] {
-            if (const auto self = weak.lock()) {
-                try { self->begin(); }
-                catch (...) { self->report(std::current_exception()); }
-            }
-        });
-    }
-    catch (...) {
-        d->requested.store(false, std::memory_order_release);
-        throw;
-    }
+    std::lock_guard lock(d->lifecycle_mutex);
+    if (d->running.exchange(true, std::memory_order_acq_rel)) return;
+    d->thread = std::jthread([state = d](std::stop_token stop) {
+        state->run(stop);
+    });
 }
 
 void Gallery_Frame_Clock::stop() noexcept {
-    if (!d || !d->requested.exchange(false, std::memory_order_acq_rel)) return;
-    const std::weak_ptr<Private> weak = d;
-    try {
-        asio::post(d->strand, [weak] {
-            if (const auto self = weak.lock()) {
-                try { self->cancel(); }
-                catch (...) { self->report(std::current_exception()); }
-            }
-        });
-    }
-    catch (...) {}
+    if (!d || !d->running.exchange(false, std::memory_order_acq_rel)) return;
+    d->thread.request_stop();
+    d->wake.notify_all();
+    if (d->thread.joinable() &&
+        d->thread.get_id() != std::this_thread::get_id())
+        d->thread.join();
 }
 }
diff --git a/web_server/src/detail/Gallery_Frame_Clock.hpp b/web_server/src/detail/Gallery_Frame_Clock.hpp
index 92b09c3..a3f857d 100644
--- a/web_server/src/detail/Gallery_Frame_Clock.hpp
+++ b/web_server/src/detail/Gallery_Frame_Clock.hpp
@@ -1,6 +1,5 @@
 #pragma once
 #include "../Plot.hpp"
-#include <asio/any_io_executor.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
@@ -11,8 +10,7 @@ public:
     using Tick_Handler = std::function<void(Plot_Render_Tick)>;
     using Failure_Handler = std::function<void(std::exception_ptr)>;
 
-    Gallery_Frame_Clock(asio::any_io_executor executor, double frame_rate,
-                        Tick_Handler tick_handler,
+    Gallery_Frame_Clock(double frame_rate, Tick_Handler tick_handler,
                         Failure_Handler failure_handler);
     ~Gallery_Frame_Clock();
     Gallery_Frame_Clock(const Gallery_Frame_Clock&) = delete;
diff --git a/web_server/tests/Gallery_Frame_Clock_Tests.cpp b/web_server/tests/Gallery_Frame_Clock_Tests.cpp
index b990e2c..08d94a9 100644
--- a/web_server/tests/Gallery_Frame_Clock_Tests.cpp
+++ b/web_server/tests/Gallery_Frame_Clock_Tests.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <web_server/src/detail/Gallery_Frame_Clock.hpp>
-#include <asio/thread_pool.hpp>
 #include <chrono>
 #include <condition_variable>
 #include <exception>
@@ -10,14 +9,13 @@
 
 namespace aethera::web::detail {
 TEST(Gallery_Frame_Clock, Produces_One_Monotonic_Absolute_Timeline) {
-    asio::thread_pool pool(1);
     std::mutex mutex;
     std::condition_variable condition;
     std::vector<Plot_Render_Tick> ticks;
     std::exception_ptr failure;
     {
         Gallery_Frame_Clock clock(
-            pool.get_executor(), 100.0,
+            100.0,
             [&](Plot_Render_Tick tick) {
                 std::lock_guard lock(mutex);
                 ticks.push_back(tick);
@@ -59,7 +57,5 @@ TEST(Gallery_Frame_Clock, Produces_One_Monotonic_Absolute_Timeline) {
             EXPECT_EQ(ticks.size(), stopped_count);
         }
     }
-    pool.stop();
-    pool.join();
 }
 }