diff --git a/render_2D/render_2D/plottable/Afterglow.hpp b/render_2D/render_2D/plottable/Afterglow.hpp
index 179589b..eb9d817 100644
--- a/render_2D/render_2D/plottable/Afterglow.hpp
+++ b/render_2D/render_2D/plottable/Afterglow.hpp
@@ -15,7 +15,6 @@ struct Afterglow : Def<Afterglow, Renderable_2D,
                        std::shared_ptr<const std::vector<Plot_Value>>>> {
     using Scene_Object = Impl<Render_Scene_2D>; using Frequency_Object = Impl<Frequency_Axis>; using Power_Object = Impl<Numeric_Axis>;
     struct Prop : Prev_Prop {
-        Prop() { cache_enabled = true; }
         std::size_t frequency_point_size{};                        /* 栅格频率列数；零值使用最新频谱尺寸。 */
         std::size_t power_point_size{};                            /* 栅格功率行数；零值使用默认尺寸。 */
         Plot_Partition_Grid partition_grid{};                      /* framebuffer 按列×行显式分块；任一维为零时禁用栅格任务。 */
diff --git a/render_2D/render_2D/plottable/Constellation_Diagram.hpp b/render_2D/render_2D/plottable/Constellation_Diagram.hpp
index 61a3948..18530fb 100644
--- a/render_2D/render_2D/plottable/Constellation_Diagram.hpp
+++ b/render_2D/render_2D/plottable/Constellation_Diagram.hpp
@@ -20,9 +20,6 @@ struct Constellation_Diagram : Def<Constellation_Diagram,
     using Scene_Object = Impl<Render_Scene_2D>;
     using Axis_Object = Impl<Numeric_Axis>;
     struct Prop : Prev_Prop {
-        Prop() {
-            cache_enabled = true;
-        }
         Plot_Partition_Count partition_count{1}; /* 接收点 Paint 子图的显式分块数；零值禁用接收点任务。 */
         Plot_Duration_Milliseconds point_lifetime_ms{1000}; /* 接收点保留时间，单位为毫秒。 */
         Constellation_Diagram_Type type{Constellation_Diagram_Type::psk8}; /* 理想 PSK 锚点数量。 */
diff --git a/render_2D/render_2D/plottable/Frequency_Trace.hpp b/render_2D/render_2D/plottable/Frequency_Trace.hpp
index db294af..6575b05 100644
--- a/render_2D/render_2D/plottable/Frequency_Trace.hpp
+++ b/render_2D/render_2D/plottable/Frequency_Trace.hpp
@@ -19,7 +19,6 @@ struct Frequency_Trace : Def<Frequency_Trace, Renderable_2D,
     using Time_Object = Impl<Time_Axis>;
     using Value_Object = Impl<Numeric_Axis>;
     struct Prop : Prev_Prop {
-        Prop() { cache_enabled = true; }
         Plot_Partition_Count partition_count{1};                    /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
         Pen pen{Color::yellow()};                                   /* 频率轨迹折线样式。 */
         bool operator==(const Prop&) const;
diff --git a/render_2D/render_2D/plottable/Spectrum.hpp b/render_2D/render_2D/plottable/Spectrum.hpp
index 19ceee9..dd08d3b 100644
--- a/render_2D/render_2D/plottable/Spectrum.hpp
+++ b/render_2D/render_2D/plottable/Spectrum.hpp
@@ -24,7 +24,6 @@ struct Spectrum : Def<Spectrum, Renderable_2D,
     using Frequency_Object = Impl<Frequency_Axis>;
     using Power_Object = Impl<Numeric_Axis>;
     struct Prop : Prev_Prop {
-        Prop() { cache_enabled = true; }
         Spectrum_Frequency center_frequency{50.0}; /* 中心频率标记位置，单位为 Hz。 */
         Plot_Partition_Count partition_count{1}; /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
         bool max_hold_visible{}; /* 是否绘制逐点历史最大值曲线。 */
diff --git a/render_2D/render_2D/plottable/Sweep_Spectrum.hpp b/render_2D/render_2D/plottable/Sweep_Spectrum.hpp
index 953851d..75b859a 100644
--- a/render_2D/render_2D/plottable/Sweep_Spectrum.hpp
+++ b/render_2D/render_2D/plottable/Sweep_Spectrum.hpp
@@ -25,7 +25,6 @@ struct Sweep_Spectrum : Def<Sweep_Spectrum, Renderable_2D,
     using Frequency_Object = Impl<Frequency_Axis>;
     using Power_Object = Impl<Numeric_Axis>;
     struct Prop : Prev_Prop {
-        Prop() { cache_enabled = true; }
         std::size_t bins_per_block{};                              /* 每个扫频块期望的功率点数；零值接受首块尺寸。 */
         std::size_t block_count{1};                               /* 一个完整扫频周期包含的块数；零值按 1 处理。 */
         Plot_Partition_Count partition_count{1};                  /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
diff --git a/render_2D/render_2D/plottable/Waterfall.hpp b/render_2D/render_2D/plottable/Waterfall.hpp
index d99dd5f..cefbf55 100644
--- a/render_2D/render_2D/plottable/Waterfall.hpp
+++ b/render_2D/render_2D/plottable/Waterfall.hpp
@@ -22,7 +22,6 @@ struct Waterfall : Def<Waterfall, Renderable_2D,
     using Frequency_Object = Impl<Frequency_Axis>;
     using Time_Object = Impl<Time_Axis>;
     struct Prop : Prev_Prop {
-        Prop() { cache_enabled = true; }
         bool tooltip_enabled{true};                                                     /* 是否响应指针位置显示提示。 */
         Font tooltip_font{};                                                            /* 提示文字字体。 */
         Pen tooltip_text_pen{Color::white()};                                           /* 提示文字样式。 */
@@ -32,7 +31,7 @@ struct Waterfall : Def<Waterfall, Renderable_2D,
         bool visible_range_only{true};                                                  /* 是否按频率轴范围裁剪栅格。 */
         Axis_Range frequency_range{0.0, 10.0};                                          /* 每行频谱覆盖的频率范围。 */
         Axis_Range power_range{0.0, 10.0};                                              /* 颜色映射使用的功率范围。 */
-        Image_Interpolation_Mode interpolation_mode{Image_Interpolation_Mode::nearest}; /* 栅格放大时的图像插值方式。 */
+        Image_Interpolation_Mode interpolation_mode{Image_Interpolation_Mode::bilinear}; /* 栅格放大时的图像插值方式。 */
         Color_Map color_map{};                                                          /* 功率到颜色的映射。 */
         bool operator==(const Prop&) const;
     };
diff --git a/render_2D/render_2D/plottable/common/Raster_Plot.cpp b/render_2D/render_2D/plottable/common/Raster_Plot.cpp
index 66e7ed0..da5c76e 100644
--- a/render_2D/render_2D/plottable/common/Raster_Plot.cpp
+++ b/render_2D/render_2D/plottable/common/Raster_Plot.cpp
@@ -86,18 +86,22 @@ Rect_F raster_paint_region(const Raster_Layout& layout,
         raster_partition(layout, partition_index, grid);
     if (partition.empty()) return {};
     const Rect_F target = layout.target.normalized();
-    const double left = target.x + target.width * partition.first_x /
-        static_cast<double>(layout.width);
-    const double right = target.x + target.width * partition.last_x /
-        static_cast<double>(layout.width);
-    const double top = target.y + target.height * partition.first_y /
-        static_cast<double>(layout.height);
-    const double bottom = target.y + target.height * partition.last_y /
-        static_cast<double>(layout.height);
-    constexpr double overlap{1.0};
-    return {left - overlap, top - overlap,
-            right - left + overlap * 2.0,
-            bottom - top + overlap * 2.0};
+    const auto pixel_boundary = [](double origin, double extent,
+                                   int source_boundary, int source_extent,
+                                   bool last) {
+        const double projected = origin + extent * source_boundary /
+            static_cast<double>(source_extent);
+        return last ? std::ceil(projected) : std::floor(projected);
+    };
+    const double left = pixel_boundary(target.x, target.width,
+        partition.first_x, layout.width, false);
+    const double right = pixel_boundary(target.x, target.width,
+        partition.last_x, layout.width, partition.last_x == layout.width);
+    const double top = pixel_boundary(target.y, target.height,
+        partition.first_y, layout.height, false);
+    const double bottom = pixel_boundary(target.y, target.height,
+        partition.last_y, layout.height, partition.last_y == layout.height);
+    return {left, top, right - left, bottom - top};
 }
 void paint_raster(Painter& painter, const Raster_Layout& layout, std::span<const Pixel> pixels, Image_Interpolation_Mode interpolation) {
     if (layout.valid() && pixels.size() == static_cast<std::size_t>(layout.width) * static_cast<std::size_t>(layout.height)) painter.heatmap(layout.target, layout.width, layout.height, pixels, interpolation);
diff --git a/render_2D/render_2D/plottable/common/Raster_Plot.hpp b/render_2D/render_2D/plottable/common/Raster_Plot.hpp
index ae12de4..fa07bc0 100644
--- a/render_2D/render_2D/plottable/common/Raster_Plot.hpp
+++ b/render_2D/render_2D/plottable/common/Raster_Plot.hpp
@@ -41,7 +41,7 @@ struct Raster_Partition {
     Plot_Partition_Grid grid);
 [[nodiscard]] std::pair<int, int> raster_coordinates(
     const Raster_Layout& layout, int x, int y) noexcept;
-/* 将目标矩形按列×行网格切成 framebuffer 视图；相邻 tile 保留一像素重叠。 */
+/* 将目标矩形切成互斥的整数 framebuffer 视图；每个目标像素只有一个写入者。 */
 [[nodiscard]] Rect_F raster_paint_region(const Raster_Layout& layout,
                                          Plot_Partition_Count partition_index,
                                          Plot_Partition_Grid grid);
diff --git a/render_2D/tests/Partition_Configuration_Test.cpp b/render_2D/tests/Partition_Configuration_Test.cpp
index be5ddb9..7bf7da0 100644
--- a/render_2D/tests/Partition_Configuration_Test.cpp
+++ b/render_2D/tests/Partition_Configuration_Test.cpp
@@ -1,5 +1,8 @@
+#include <render_2D/plottable/Afterglow.hpp>
 #include <render_2D/plottable/Constellation_Diagram.hpp>
+#include <render_2D/plottable/Frequency_Trace.hpp>
 #include <render_2D/plottable/Spectrum.hpp>
+#include <render_2D/plottable/Sweep_Spectrum.hpp>
 #include <render_2D/plottable/Waterfall.hpp>
 #include <render_2D/plottable/common/Raster_Plot.hpp>
 #include <gtest/gtest.h>
@@ -26,6 +29,9 @@ TEST(partition_configuration,
     using Power = Impl<Numeric_Axis>;
     using Time = Impl<Time_Axis>;
     using Spectrum_Object = Impl<Spectrum>;
+    using Trace_Object = Impl<Frequency_Trace>;
+    using Sweep_Object = Impl<Sweep_Spectrum>;
+    using Afterglow_Object = Impl<Afterglow>;
     using Constellation_Object = Impl<Constellation_Diagram>;
     using Waterfall_Object = Impl<Waterfall>;
 
@@ -35,6 +41,10 @@ TEST(partition_configuration,
     auto time = build_object<Time>();
     auto spectrum = build_object<Spectrum_Object>(frequency.get(), power.get(),
                                                   6u);
+    auto trace = build_object<Trace_Object>(time.get(), power.get(), 4u);
+    auto sweep = build_object<Sweep_Object>(frequency.get(), power.get(), 4u);
+    auto afterglow = build_object<Afterglow_Object>(
+        frequency.get(), power.get(), Plot_Partition_Grid{2, 3});
     auto constellation = build_object<Constellation_Object>(
         power.get(), q_axis.get(), 7u);
     auto waterfall = build_object<Waterfall_Object>(
@@ -46,6 +56,12 @@ TEST(partition_configuration,
               7u);
     EXPECT_EQ(waterfall->read_prop<Waterfall::Base_Tag>().partition_grid,
               (Plot_Partition_Grid{2, 3}));
+    EXPECT_FALSE(spectrum->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
+    EXPECT_FALSE(trace->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
+    EXPECT_FALSE(sweep->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
+    EXPECT_FALSE(afterglow->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
+    EXPECT_FALSE(waterfall->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
+    EXPECT_FALSE(constellation->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
 
     spectrum->set<&Spectrum::Prop::partition_count>(3u);
     constellation->set<&Constellation_Diagram::Prop::partition_count>(2u);
@@ -66,6 +82,65 @@ TEST(partition_configuration,
               (Plot_Partition_Grid{0, 2}));
 }
 
+TEST(partition_configuration,
+     raster_grid_matches_a_single_framebuffer_view_without_seams) {
+    const Size canvas{137, 93};
+    const aethera::render_2d::detail::Raster_Layout layout{
+        19, 13, Rect_F{3.25, 5.5, 128.5, 80.25}, false, false, true};
+    std::vector<Pixel> pixels(
+        static_cast<std::size_t>(layout.width) * layout.height);
+    for (int y = 0; y < layout.height; ++y) {
+        for (int x = 0; x < layout.width; ++x) {
+            const auto red = static_cast<Pixel>((x * 255) /
+                                                (layout.width - 1));
+            const auto green = static_cast<Pixel>((y * 255) /
+                                                  (layout.height - 1));
+            pixels[static_cast<std::size_t>(y) * layout.width + x] =
+                0xff000000u | (red << 16u) | (green << 8u) |
+                static_cast<Pixel>((x + y) & 0xff);
+        }
+    }
+
+    Blend2D_Cache single;
+    single.ensure_size(canvas);
+    single.clear();
+    {
+        aethera::render_2d::detail::Painter painter(single, canvas);
+        aethera::render_2d::detail::paint_raster(
+            painter, layout, pixels, Image_Interpolation_Mode::bilinear);
+    }
+
+    Blend2D_Cache partitioned;
+    partitioned.ensure_size(canvas);
+    partitioned.clear();
+    constexpr Plot_Partition_Grid grid{4, 3};
+    for (Plot_Partition_Count index = 0;
+         index < aethera::render_2d::detail::raster_partition_count(grid);
+         ++index) {
+        const Rect_F region =
+            aethera::render_2d::detail::raster_paint_region(
+                layout, index, grid);
+        aethera::render_2d::detail::Painter painter(
+            partitioned, canvas, region);
+        aethera::render_2d::detail::paint_raster(
+            painter, layout, pixels, Image_Interpolation_Mode::bilinear);
+    }
+
+    const Image_View expected = single.view();
+    const Image_View actual = partitioned.view();
+    ASSERT_EQ(actual.width, expected.width);
+    ASSERT_EQ(actual.height, expected.height);
+    for (int y = 0; y < expected.height; ++y) {
+        const auto* expected_row = reinterpret_cast<const Pixel*>(
+            expected.data + static_cast<std::ptrdiff_t>(y) * expected.stride);
+        const auto* actual_row = reinterpret_cast<const Pixel*>(
+            actual.data + static_cast<std::ptrdiff_t>(y) * actual.stride);
+        for (int x = 0; x < expected.width; ++x)
+            EXPECT_EQ(actual_row[x], expected_row[x])
+                << "pixel mismatch at " << x << ", " << y;
+    }
+}
+
 TEST(partition_configuration,
      raster_grid_covers_each_matrix_cell_exactly_once) {
     const aethera::render_2d::detail::Raster_Layout layout{
diff --git a/render_2D/tests/Spectrum_Test.cpp b/render_2D/tests/Spectrum_Test.cpp
index d32ab9d..17bc597 100644
--- a/render_2D/tests/Spectrum_Test.cpp
+++ b/render_2D/tests/Spectrum_Test.cpp
@@ -153,9 +153,7 @@ TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
     EXPECT_FALSE(spectrum->dirty<Paint_Tag>());
     EXPECT_FALSE(frequency->dirty<Paint_Tag>());
     EXPECT_FALSE(power->dirty<Paint_Tag>());
-    spectrum->set<&Renderable_2D::Prop::cache_enabled>(false);
-    output_frame = render_frame(scene.get());
-    EXPECT_TRUE(contains_color(output_frame->image()));
+    EXPECT_FALSE(spectrum->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
     spectrum->set<&Renderable_2D::Prop::cache_enabled>(true);
     output_frame = render_frame(scene.get());
     EXPECT_TRUE(contains_color(output_frame->image()));
diff --git a/web_server/src/Gallery_Plots_2D.cpp b/web_server/src/Gallery_Plots_2D.cpp
index 8d66109..b569243 100644
--- a/web_server/src/Gallery_Plots_2D.cpp
+++ b/web_server/src/Gallery_Plots_2D.cpp
@@ -813,16 +813,16 @@ std::shared_ptr<Plot> make_waterfall_plot() {
     auto update = [scene = scene.get(), raw = waterfall.get(), frequency = frequency.get(), time = time.get()](const Plot_Render_Tick& event, bool demo_data) {
         resize_axes(scene, {static_cast<int>(event.width), static_cast<int>(event.height)}, frequency, time);
         if (!demo_data) return;
-        std::array < double, 192 > values{};
-        for (std::size_t i = 0; i < values.size(); ++i)
-            values[i] = -100.0 + 70.0 * std::exp(-240.0 * std::pow(
-                static_cast<double>(i) / values.size() - 0.5
-                - 0.22 * std::sin(event.time_milliseconds * 0.0006), 2.0));
         constexpr double day_milliseconds = 86'400'000.0;
         const auto tick = time->append_time(Time_Of_Day{
             static_cast<std::int64_t>(
                 std::fmod(std::max(0.0, event.time_milliseconds), day_milliseconds))
         });
+        std::array < double, 192 > values{};
+        for (std::size_t i = 0; i < values.size(); ++i)
+            values[i] = -100.0 + 70.0 * std::exp(-240.0 * std::pow(
+                static_cast<double>(i) / values.size() - 0.5
+                - 0.22 * std::sin(static_cast<double>(tick) * 0.01), 2.0));
         raw->template submit_stream<Waterfall_Stream_Tag>(
             std::make_shared<const Waterfall_Row>(Waterfall_Row{
                 tick, {values.begin(), values.end()}
diff --git a/webapp_gallery/src/app.tsx b/webapp_gallery/src/app.tsx
index 32602c2..2519893 100644
--- a/webapp_gallery/src/app.tsx
+++ b/webapp_gallery/src/app.tsx
@@ -1580,13 +1580,56 @@ function taskflow_graph_analysis(graph: Taskflow_Graph_Trace, executions: Taskfl
         internal_idle_time: Math.max(0, idle_wall_time - initial_wait - completion_tail),
         peak_entry_queue: rows.reduce((maximum, row) => Math.max(maximum, row.worker_queue_size), 0),
         maximum_parallelism,
+        node_count: graph.nodes.length,
         layer_count: width_by_level.size,
         parallel_layer_count: [...width_by_level.values()].filter(width => width > 1).length,
-        longest, longest_unattributed
+        longest, longest_unattributed,
+        longest_duration: longest?.duration_ms ?? 0,
+        longest_unattributed_duration: longest_unattributed
+            ? Math.max(0, longest_unattributed.duration_ms -
+                longest_unattributed.cooperative_wait_ms -
+                longest_unattributed.cpu_duration_ms)
+            : 0
     };
 }
 
-type Distribution_Statistics = {count: number; average: number; variability: number; minimum: number; maximum: number; p95: number; p99: number};
+type Distribution_Statistics = {count: number; average: number; variance: number; variability: number; minimum: number; maximum: number; p95: number; p99: number};
+const taskflow_graph_metric_definitions = [
+    {key: "node_count", label: "DAG 节点", unit: "count", description: "每帧展开前的原生 Taskflow 节点数量。"},
+    {key: "wall_time", label: "Topology 墙钟", unit: "milliseconds", description: "从提交 Taskflow 到整个 Topology 完成的墙钟时间。"},
+    {key: "execution_time", label: "叶子任务墙钟总和", unit: "milliseconds", description: "每帧所有叶子任务执行墙钟之和。"},
+    {key: "module_envelope_time", label: "Module 包络总和", unit: "milliseconds", description: "每帧所有 Taskflow Module Observer 包络之和。"},
+    {key: "cpu_execution_time", label: "叶子任务线程 CPU", unit: "milliseconds", description: "每帧叶子任务独占 Worker 的线程 CPU 时间之和。"},
+    {key: "cpu_cycles_total", label: "叶子任务 CPU 活动", unit: "cycles", description: "每帧叶子任务 QueryThreadCycleTime 活动量之和。"},
+    {key: "cooperative_wait_time", label: "累计协作等待", unit: "milliseconds", description: "每帧 Task_Graph 协作等待墙钟之和。"},
+    {key: "unattributed_wall_time", label: "未归因墙时", unit: "milliseconds", description: "任务体墙钟扣除协作等待和线程 CPU 后的守恒余量。"},
+    {key: "body_wall_time", label: "任务体墙钟并集", unit: "milliseconds", description: "每帧至少有一个任务体执行的时间区间并集。"},
+    {key: "observer_wall_time", label: "Observer 独占墙钟", unit: "milliseconds", description: "只有 Observer 活动、没有任务体执行的时间区间。"},
+    {key: "observer_entry_time", label: "Observer entry 墙钟", unit: "milliseconds", description: "每帧所有 Observer entry 墙钟之和。"},
+    {key: "observer_exit_time", label: "Observer exit 墙钟", unit: "milliseconds", description: "每帧所有 Observer exit 墙钟之和。"},
+    {key: "observer_cpu_time", label: "Observer 实际 CPU", unit: "milliseconds", description: "每帧 Observer entry/exit 真正占用的 Worker CPU 时间。"},
+    {key: "idle_wall_time", label: "无任务墙钟", unit: "milliseconds", description: "Topology 中没有捕获任务体或 Observer 活动的区间。"},
+    {key: "queue_time", label: "累计节点排队", unit: "milliseconds", description: "各节点从前驱完成到进入 Worker 的估算等待之和。"},
+    {key: "initial_wait", label: "首次准入等待", unit: "milliseconds", description: "Topology 提交后首节点进入 Worker 前的等待。"},
+    {key: "internal_idle_time", label: "内部调度空洞", unit: "milliseconds", description: "首尾等待之外没有捕获任务活动的中间空洞。"},
+    {key: "completion_tail", label: "Topology 完成尾部", unit: "milliseconds", description: "末节点 Observer 完成到 Topology 完成回调的尾部。"},
+    {key: "peak_entry_queue", label: "入口队列峰值", unit: "count", description: "节点进入 Worker 时看到的最大本地队列长度。"},
+    {key: "maximum_parallelism", label: "实际最大并行", unit: "count", description: "Observer 时间区间内同时执行的最大节点数量。"},
+    {key: "layer_count", label: "依赖层", unit: "count", description: "每帧 DAG 的依赖层数量。"},
+    {key: "parallel_layer_count", label: "并行层", unit: "count", description: "每帧包含多个可并行节点的依赖层数量。"},
+    {key: "longest_duration", label: "最长节点执行", unit: "milliseconds", description: "每帧最长执行节点的任务体墙钟。"},
+    {key: "longest_unattributed_duration", label: "最长节点未归因墙时", unit: "milliseconds", description: "每帧单节点最大的未归因墙钟。"}
+] as const;
+type Taskflow_Graph_Metric_Key = typeof taskflow_graph_metric_definitions[number]["key"];
+const paint_metric_definitions = [
+    {key: "total", label: "同帧 Paint 总墙钟"},
+    {key: "frame_target", label: "帧目标准备"},
+    {key: "background", label: "背景填充"},
+    {key: "cache_targets", label: "缓存目标准备"},
+    {key: "taskflow", label: "Paint Taskflow 墙钟"},
+    {key: "coordination", label: "Paint 阶段衔接"}
+] as const;
+type Paint_Metric_Key = typeof paint_metric_definitions[number]["key"];
 type Taskflow_Node_Stability = "stable" | "variable" | "missing" | "long_tail";
 type Taskflow_Node_Aggregate = {
     node: Taskflow_Node_Trace; present: number; executed: number; frames: number;
@@ -1596,21 +1639,25 @@ type Taskflow_Node_Aggregate = {
 };
 type Taskflow_Graph_Aggregate = {
     key: string; graph: Taskflow_Graph_Trace; frames: number; samples: number; topology_variants: number;
-    wall: Distribution_Statistics; nodes: Map<string, Taskflow_Node_Aggregate>; edge_presence: Map<string, number>;
+    metrics: Record<Taskflow_Graph_Metric_Key, Distribution_Statistics>;
+    paint_metrics: Record<Paint_Metric_Key, Distribution_Statistics> | null;
+    completed_frames: number; cpu_time_coarse_frames: number;
+    nodes: Map<string, Taskflow_Node_Aggregate>; edge_presence: Map<string, number>;
 };
 
 function distribution_statistics(values: number[]): Distribution_Statistics {
     const sorted = values.filter(Number.isFinite).sort((left, right) => left - right);
-    if (!sorted.length) return {count: 0, average: 0, variability: 0, minimum: 0, maximum: 0, p95: 0, p99: 0};
+    if (!sorted.length) return {count: 0, average: 0, variance: 0, variability: 0, minimum: 0, maximum: 0, p95: 0, p99: 0};
     const average = sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
-    const variability = Math.sqrt(sorted.reduce((sum, value) => sum + (value - average) ** 2, 0) / sorted.length);
+    const variance = sorted.reduce((sum, value) => sum + (value - average) ** 2, 0) / sorted.length;
+    const variability = Math.sqrt(variance);
     const percentile = (ratio: number) => {
         const position = (sorted.length - 1) * ratio;
         const lower = Math.floor(position);
         const upper = Math.ceil(position);
         return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
     };
-    return {count: sorted.length, average, variability, minimum: sorted[0], maximum: sorted.at(-1) ?? sorted[0],
+    return {count: sorted.length, average, variance, variability, minimum: sorted[0], maximum: sorted.at(-1) ?? sorted[0],
         p95: percentile(.95), p99: percentile(.99)};
 }
 
@@ -1618,6 +1665,20 @@ function taskflow_stage_key(graph: Taskflow_Graph_Trace) {
     return `${graph.stage}\u0000${graph.name}`;
 }
 
+function frame_paint_analysis(frame?: Taskflow_Frame_Trace) {
+    const markers = frame?.markers;
+    if (!markers) return null;
+    const interval = (first: string, last: string) =>
+        Math.max(0, (markers[last] ?? 0) - (markers[first] ?? 0));
+    const total = interval("paint_started", "paint_finished");
+    const frame_target = interval("paint_frame_target_started", "paint_frame_target_finished");
+    const background = interval("paint_background_started", "paint_background_finished");
+    const cache_targets = interval("paint_cache_targets_started", "paint_cache_targets_finished");
+    const taskflow = interval("paint_taskflow_started", "paint_taskflow_finished");
+    return {total, frame_target, background, cache_targets, taskflow,
+        coordination: Math.max(0, total - frame_target - background - cache_targets - taskflow)};
+}
+
 function aggregate_taskflow_graph(frames: Taskflow_Frame_Trace[], key: string): Taskflow_Graph_Aggregate | null {
     const samples = frames.flatMap(frame => frame.graphs
         .filter(graph => taskflow_stage_key(graph) === key)
@@ -1629,12 +1690,26 @@ function aggregate_taskflow_graph(frames: Taskflow_Frame_Trace[], key: string):
     const accumulated = new Map<string, Mutable_Node>();
     const edges = new Map<string, number>();
     const topology_signatures = new Set<string>();
-    const wall: number[] = [];
+    const metric_samples = Object.fromEntries(taskflow_graph_metric_definitions.map(
+        definition => [definition.key, [] as number[]])) as Record<Taskflow_Graph_Metric_Key, number[]>;
+    const paint_metric_samples = Object.fromEntries(paint_metric_definitions.map(
+        definition => [definition.key, [] as number[]])) as Record<Paint_Metric_Key, number[]>;
+    let completed_frames = 0;
+    let cpu_time_coarse_frames = 0;
     for (const {frame, graph} of samples) {
         const native_to_id = new Map(graph.nodes.map(node => [node.native_id, node.id]));
         const execution = new Map(frame.executions.map(value => [value.native_id, value]));
         const signature_edges: string[] = [];
-        wall.push(Math.max(0, graph.finished_ms - graph.submitted_ms));
+        const analysis = taskflow_graph_analysis(graph, frame.executions);
+        for (const definition of taskflow_graph_metric_definitions)
+            metric_samples[definition.key].push(analysis[definition.key]);
+        if (analysis.cpu_time_coarse) ++cpu_time_coarse_frames;
+        if (graph.completed) ++completed_frames;
+        if (graph.stage === "render_2d.frame") {
+            const paint = frame_paint_analysis(frame);
+            if (paint) for (const definition of paint_metric_definitions)
+                paint_metric_samples[definition.key].push(paint[definition.key]);
+        }
         for (const node of graph.nodes) {
             const current = accumulated.get(node.id) ?? {template: node, present: 0, executed: 0,
                 duration: [], queue: [], cpu: [], cycles: [], cooperative_wait: [], cpu_time_coarse: false,
@@ -1693,9 +1768,33 @@ function aggregate_taskflow_graph(frames: Taskflow_Frame_Trace[], key: string):
         return node;
     });
     const first = samples[0].graph;
+    const metrics = Object.fromEntries(taskflow_graph_metric_definitions.map(
+        definition => [definition.key, distribution_statistics(metric_samples[definition.key])])) as
+        Record<Taskflow_Graph_Metric_Key, Distribution_Statistics>;
+    const paint_metrics = paint_metric_samples.total.length === 0 ? null :
+        Object.fromEntries(paint_metric_definitions.map(definition => [definition.key,
+            distribution_statistics(paint_metric_samples[definition.key])])) as
+            Record<Paint_Metric_Key, Distribution_Statistics>;
     return {key, frames: frames.length, samples: samples.length, topology_variants: topology_signatures.size,
-        wall: distribution_statistics(wall), nodes, edge_presence: edges,
-        graph: {...first, submitted_ms: 0, finished_ms: distribution_statistics(wall).average, nodes: graph_nodes}};
+        metrics, paint_metrics, completed_frames, cpu_time_coarse_frames, nodes, edge_presence: edges,
+        graph: {...first, submitted_ms: 0, finished_ms: metrics.wall_time.average, nodes: graph_nodes}};
+}
+
+function taskflow_metric_value(value: number, unit: "milliseconds" | "cycles" | "count") {
+    if (unit === "milliseconds") return milliseconds(value);
+    if (unit === "cycles") return cpu_cycles(value);
+    return value.toLocaleString("zh-CN", {maximumFractionDigits: 3});
+}
+
+function taskflow_variance_value(value: number, unit: "milliseconds" | "cycles" | "count") {
+    if (!Number.isFinite(value)) return "--";
+    const suffix = unit === "milliseconds" ? " ms²" : unit === "cycles" ? " cy²" : "";
+    return `${value.toLocaleString("zh-CN", {maximumFractionDigits: 6})}${suffix}`;
+}
+
+function taskflow_distribution_value(statistic: Distribution_Statistics,
+                                     unit: "milliseconds" | "cycles" | "count") {
+    return <>均值 {taskflow_metric_value(statistic.average, unit)} · 方差 {taskflow_variance_value(statistic.variance, unit)} · 范围 [{taskflow_metric_value(statistic.minimum, unit)}, {taskflow_metric_value(statistic.maximum, unit)}]</>;
 }
 
 function taskflow_component_state(node: Taskflow_Node_Trace, components: Component[]) {
@@ -1738,6 +1837,87 @@ function taskflow_node_state(node: Taskflow_Node_Trace, components: Component[],
     return taskflow_render_domain_state(node, frame);
 }
 
+/*
+ * Taskflow Module 是执行包络，不是独立的数据阶段。原生 trace 同时保留
+ * Module 和子图节点用于计时，但 Module 的外部边不会自动出现在子图根/叶
+ * 上。拓扑视图在不改变原始诊断数据的前提下展开 Module：外部前驱连接子图
+ * 根，子图叶连接外部后继，从而显示与实际执行语义一致的一张连通 DAG。
+ */
+function expanded_taskflow_graph(graph: Taskflow_Graph_Trace): Taskflow_Graph_Trace {
+    const by_native_id = new Map(graph.nodes.map(node => [node.native_id, node]));
+    const by_id = new Map(graph.nodes.map(node => [node.id, node]));
+    const children = new Map<string, Taskflow_Node_Trace[]>();
+    for (const node of graph.nodes) if (node.parent_id)
+        children.set(node.parent_id, [...(children.get(node.parent_id) ?? []), node]);
+    const is_module = (node: Taskflow_Node_Trace) => node.type.toLowerCase() === "module";
+    const visible = graph.nodes.filter(node => !is_module(node));
+    const deduplicate = (nodes: Taskflow_Node_Trace[]) =>
+        [...new Map(nodes.map(node => [node.native_id, node])).values()];
+    const resolving = new Set<string>();
+    const resolve_successors = (node: Taskflow_Node_Trace): Taskflow_Node_Trace[] => {
+        const guard = `successor:${node.native_id}`;
+        if (resolving.has(guard)) return [];
+        resolving.add(guard);
+        let result: Taskflow_Node_Trace[] = [];
+        if (node.successors.length) {
+            for (const successor of node.successors) {
+                const target = by_native_id.get(successor);
+                if (target) result.push(...resolve_entry(target));
+            }
+        } else if (node.parent_id) {
+            const parent = by_id.get(node.parent_id);
+            if (parent) result = resolve_successors(parent);
+        }
+        resolving.delete(guard);
+        return deduplicate(result);
+    };
+    const resolve_entry = (node: Taskflow_Node_Trace): Taskflow_Node_Trace[] => {
+        if (!is_module(node)) return [node];
+        const guard = `entry:${node.native_id}`;
+        if (resolving.has(guard)) return [];
+        resolving.add(guard);
+        const direct_children = children.get(node.id) ?? [];
+        const direct_ids = new Set(direct_children.map(child => child.native_id));
+        const roots = direct_children.filter(child =>
+            child.predecessors.every(predecessor => !direct_ids.has(predecessor)));
+        const result = roots.length
+            ? deduplicate(roots.flatMap(root => resolve_entry(root)))
+            : resolve_successors(node);
+        resolving.delete(guard);
+        return result;
+    };
+    const edges = new Set<string>();
+    for (const source of visible) for (const target of resolve_successors(source))
+        if (source.native_id !== target.native_id)
+            edges.add(`${source.native_id}\u0000${target.native_id}`);
+
+    /* Prepare/Paint 属于同一 Renderable 的业务阶段，显式保留这条跨阶段语义
+     * 边；帧目标 setup 仍是所有 Paint 的共同前驱。 */
+    const paint_condition_by_owner = new Map<string, Taskflow_Node_Trace>();
+    for (const node of visible) {
+        const marker = ".paint.condition";
+        if (node.name.endsWith(marker))
+            paint_condition_by_owner.set(node.name.slice(0, -marker.length), node);
+    }
+    for (const node of visible) {
+        const marker = ".prepare.complete";
+        if (!node.name.endsWith(marker)) continue;
+        const target = paint_condition_by_owner.get(node.name.slice(0, -marker.length));
+        if (target) edges.add(`${node.native_id}\u0000${target.native_id}`);
+    }
+
+    const predecessors = new Map<string, string[]>();
+    const successors = new Map<string, string[]>();
+    for (const edge of edges) {
+        const [source, target] = edge.split("\u0000");
+        successors.set(source, [...(successors.get(source) ?? []), target]);
+        predecessors.set(target, [...(predecessors.get(target) ?? []), source]);
+    }
+    return {...graph, nodes: visible.map(node => ({...node, parent_id: "",
+        predecessors: predecessors.get(node.native_id) ?? [],
+        successors: successors.get(node.native_id) ?? []}))};
+}
+
 function Taskflow_Dag({graph, executions, frame, aggregate, components, gallery_state}: {graph: Taskflow_Graph_Trace; executions: Taskflow_Execution_Trace[];
     frame?: Taskflow_Frame_Trace; aggregate?: Taskflow_Graph_Aggregate | null; components: Component[];
     gallery_state?: Gallery_Pipeline_State | null}) {
@@ -1749,21 +1929,24 @@ function Taskflow_Dag({graph, executions, frame, aggregate, components, gallery_
     const [fullscreen, set_fullscreen] = useState(false);
     useEffect(() => {
         let cancelled = false;
-        const node_id = new Map(graph.nodes.map(node => [node.native_id, node.id]));
+        const displayed_graph = expanded_taskflow_graph(graph);
+        const node_id = new Map(displayed_graph.nodes.map(node => [node.native_id, node.id]));
         const execution = new Map(executions.map(value => [value.native_id, value]));
-        const analysis = taskflow_graph_analysis(graph, executions);
+        const analysis = taskflow_graph_analysis(displayed_graph, executions);
         const predecessor_count = new Map<string, number>();
-        for (const node of graph.nodes) predecessor_count.set(node.id, 0);
-        for (const node of graph.nodes) for (const successor of node.successors) {
+        for (const node of displayed_graph.nodes) predecessor_count.set(node.id, 0);
+        for (const node of displayed_graph.nodes) for (const successor of node.successors) {
             const target = node_id.get(successor);
             if (target) predecessor_count.set(target, (predecessor_count.get(target) ?? 0) + 1);
         }
         const flow_edges: Flow_Edge[] = [];
-        for (const node of graph.nodes) for (const successor of node.successors) {
+        for (const node of displayed_graph.nodes) for (const successor of node.successors) {
             const target = node_id.get(successor);
             if (!target) continue;
             const id = `${node.id}->${target}`;
-            const presence = aggregate?.edge_presence.get(id) ?? 1;
+            const presence = aggregate?.edge_presence.get(id) ?? (aggregate
+                ? Math.min(aggregate.nodes.get(node.id)?.present ?? 0,
+                    aggregate.nodes.get(target)?.present ?? 0) : 1);
             // Keep simple 1 -> 1 dependencies as direct vertical segments.
             // Fan-out/fan-in and cross-column dependencies use React Flow's
             // bezier edge instead of SmoothStep. SmoothStep can route unrelated
@@ -1782,7 +1965,7 @@ function Taskflow_Dag({graph, executions, frame, aggregate, components, gallery_
                 "elk.layered.spacing.nodeNodeBetweenLayers": "68", "elk.spacing.nodeNode": "42",
                 "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF"
             },
-            children: graph.nodes.map(node => {
+            children: displayed_graph.nodes.map(node => {
                 const attributes = Object.keys(node.attributes ?? {}).length;
                 const base_height = taskflow_node_state(node, components, frame, gallery_state) ? 250 : aggregate ? 198 : 172;
                 return {id: node.id, width: 300, height: base_height + Math.min(attributes, 6) * 16};
@@ -1790,7 +1973,7 @@ function Taskflow_Dag({graph, executions, frame, aggregate, components, gallery_
             edges: flow_edges.map(edge => ({id: edge.id, sources: [edge.source], targets: [edge.target]}))
         }).then(layout => {
             if (cancelled) return;
-            set_nodes(graph.nodes.map(node => {
+            set_nodes(displayed_graph.nodes.map(node => {
                 const position = layout.children?.find(item => item.id === node.id);
                 const sample = execution.get(node.native_id);
                 const summary = aggregate?.nodes.get(node.id);
@@ -1824,12 +2007,16 @@ function Taskflow_Dag({graph, executions, frame, aggregate, components, gallery_
                 correlation_id: frame?.correlation_id,
                 markers: frame?.markers ?? {},
                 graph,
+                expanded_graph: expanded_taskflow_graph(graph),
                 /* 保留当前选中拓扑，同时把本帧其余真实 Task_Graph 一并复制。
                  * 这样默认停在 render_2d.frame 时，诊断 JSON 里仍能直接检索
                  * gallery.media / FFmpeg.H264.encode，不会误以为媒体拓扑丢失。 */
                 graphs: frame?.graphs ?? [graph],
                 aggregate: aggregate ? {frames: aggregate.frames, samples: aggregate.samples,
-                    topology_variants: aggregate.topology_variants, wall: aggregate.wall,
+                    topology_variants: aggregate.topology_variants,
+                    metrics: aggregate.metrics, paint_metrics: aggregate.paint_metrics,
+                    completed_frames: aggregate.completed_frames,
+                    cpu_time_coarse_frames: aggregate.cpu_time_coarse_frames,
                     nodes: Object.fromEntries(aggregate.nodes)} : undefined,
                 executions: executions.filter(value => native_ids.has(value.native_id)),
                 all_executions: frame?.executions ?? executions
@@ -1940,19 +2127,7 @@ function Taskflow_Frame_Pane({plot, components}: {plot: Plot; components: Compon
         ? aggregate_taskflow_graph(response.frames, stage_key) : null, [response, stage_key]);
     const graph_analysis = useMemo(() => graph && frame
         ? taskflow_graph_analysis(graph, frame.executions) : null, [graph, frame]);
-    const paint_analysis = useMemo(() => {
-        const markers = frame?.markers;
-        if (!markers) return null;
-        const interval = (first: string, last: string) =>
-            Math.max(0, (markers[last] ?? 0) - (markers[first] ?? 0));
-        const total = interval("paint_started", "paint_finished");
-        const frame_target = interval("paint_frame_target_started", "paint_frame_target_finished");
-        const background = interval("paint_background_started", "paint_background_finished");
-        const cache_targets = interval("paint_cache_targets_started", "paint_cache_targets_finished");
-        const taskflow = interval("paint_taskflow_started", "paint_taskflow_finished");
-        return {total, frame_target, background, cache_targets, taskflow,
-            coordination: Math.max(0, total - frame_target - background - cache_targets - taskflow)};
-    }, [frame]);
+    const paint_analysis = useMemo(() => frame_paint_analysis(frame), [frame]);
     return <section className="workspacePane"><Workspace_Header plot={plot} label="Taskflow 帧分析" count={response?.captured ?? 0} busy={busy} on_refresh={() => void load()}/>
         <div className="workspaceBody taskflowFramePane">
             <section className="taskflowCaptureBar"><label>捕获帧数<input type="number" min={1} max={120} value={frame_count}
@@ -1982,8 +2157,17 @@ function Taskflow_Frame_Pane({plot, components}: {plot: Plot; components: Compon
                     <div><dt>波动节点</dt><dd>{[...aggregate.nodes.values()].filter(node => node.stability === "variable").length}</dd></div>
                     <div><dt>缺帧节点</dt><dd>{[...aggregate.nodes.values()].filter(node => node.stability === "missing").length}</dd></div>
                     <div><dt>长尾节点</dt><dd>{[...aggregate.nodes.values()].filter(node => node.stability === "long_tail").length}</dd></div>
-                    <div><dt>Topology 平均 ± 波动</dt><dd>{milliseconds(aggregate.wall.average)} ± {milliseconds(aggregate.wall.variability)}</dd></div>
-                    <div><dt>Topology P95 / P99</dt><dd>{milliseconds(aggregate.wall.p95)} / {milliseconds(aggregate.wall.p99)}</dd></div>
+                    <div><dt>完成帧 / CPU 粗粒度帧</dt><dd>{aggregate.completed_frames} / {aggregate.cpu_time_coarse_frames}</dd></div>
+                    {taskflow_graph_metric_definitions.map(definition => {
+                        const statistic = aggregate.metrics[definition.key];
+                        return <div key={definition.key} title={`${definition.description} 样本 ${statistic.count}；标准差 ${taskflow_metric_value(statistic.variability, definition.unit)}；P95 ${taskflow_metric_value(statistic.p95, definition.unit)}；P99 ${taskflow_metric_value(statistic.p99, definition.unit)}。`}>
+                            <dt>{definition.label}</dt><dd>{taskflow_distribution_value(statistic, definition.unit)}</dd></div>;
+                    })}
+                    {aggregate.paint_metrics ? paint_metric_definitions.map(definition => {
+                        const statistic = aggregate.paint_metrics![definition.key];
+                        return <div key={`paint-${definition.key}`} title={`2D Paint 单帧字段的跨帧统计；样本 ${statistic.count}；标准差 ${milliseconds(statistic.variability)}；P95 ${milliseconds(statistic.p95)}；P99 ${milliseconds(statistic.p99)}。`}>
+                            <dt>{definition.label}</dt><dd>{taskflow_distribution_value(statistic, "milliseconds")}</dd></div>;
+                    }) : null}
                 </dl><Taskflow_Dag graph={aggregate.graph} executions={[]} aggregate={aggregate} components={components} gallery_state={gallery_state}/></>
                 : view_mode === "single" && graph && graph_analysis ? <><dl className="taskflowGraphSummary">
                     <div><dt>业务阶段</dt><dd>{graph.stage}</dd></div><div><dt>DAG 节点</dt><dd>{graph.nodes.length}</dd></div>