diff --git a/crates/asap-aware-mapping/src/cost_model.rs b/crates/asap-aware-mapping/src/cost_model.rs
index 9e92cf60..82a3e97e 100644
--- a/crates/asap-aware-mapping/src/cost_model.rs
+++ b/crates/asap-aware-mapping/src/cost_model.rs
@@ -676,7 +676,7 @@ mod tests {
         SummaryNode {
             expr: SummaryExpr::SummaryAgg {
                 child: std::rc::Rc::new(SummaryNode {
-                    expr: SummaryExpr::KeepPreAsap(Box::new(scan())),
+                    expr: SummaryExpr::KeepPreAsap(Rc::new(scan())),
                     schema: SummarySchema {
                         fields: vec![],
                         time_index: None,
@@ -868,6 +868,7 @@ mod tests {
         let root = Rc::new(scan());
         let target = TargetSubDAG::new(&root);
         let candidate = ReplacementSubDAG {
+            strategy: "TestStrategy",
             replacement: Replacement::Summary(Rc::new(summary_node(SummaryFamilyType::Plain(
                 asap_types::pre_asap::DataType::Float64,
             )))),
@@ -891,6 +892,7 @@ mod tests {
         let target = TargetSubDAG::new(&root);
 
         let cheap = ReplacementSubDAG {
+            strategy: "TestStrategy",
             replacement: Replacement::Summary(Rc::new(summary_node(
                 SummaryFamilyType::ExactAggregate(ExactKind::Sum, ExactParams::Sum),
             ))),
@@ -898,6 +900,7 @@ mod tests {
             rationale: "exact accumulator".into(),
         };
         let pricey = ReplacementSubDAG {
+            strategy: "TestStrategy",
             replacement: Replacement::Summary(Rc::new(summary_node(SummaryFamilyType::StatModel(
                 asap_types::post_asap::StatModelKind::Parametric,
                 asap_types::post_asap::StatModelParams::Parametric {
@@ -936,11 +939,13 @@ mod tests {
         let target = TargetSubDAG::with_consumer_count(&target_root, 20);
 
         let share = ReplacementSubDAG {
+            strategy: "TestStrategy",
             replacement: Replacement::Rewrite(Rc::clone(&target_root)),
             provenance: crate::replacement::ReplacementProvenance::CseShare,
             rationale: "build once and share".into(),
         };
         let recompute = ReplacementSubDAG {
+            strategy: "TestStrategy",
             replacement: Replacement::Rewrite(Rc::new((*target_root).clone())),
             provenance: crate::replacement::ReplacementProvenance::CseRecompute,
             rationale: "build independently".into(),
diff --git a/crates/asap-aware-mapping/src/explanation.rs b/crates/asap-aware-mapping/src/explanation.rs
index 84a5212e..bcfee70a 100644
--- a/crates/asap-aware-mapping/src/explanation.rs
+++ b/crates/asap-aware-mapping/src/explanation.rs
@@ -534,7 +534,8 @@ mod tests {
             .find(|f| f.kind == ExplanationKind::SketchApproximation)
             .expect("expected a sketch finding");
         assert_eq!(
-            sketch.node_hash, expected_hash,
+            Some(sketch.node_hash),
+            expected_hash,
             "ReplacementExplanation::node_hash must match dag_export's DagNode::hash \
              for the same QueryExpr subtree"
         );
diff --git a/crates/asap-aware-mapping/src/grouping.rs b/crates/asap-aware-mapping/src/grouping.rs
index b8aec8c5..c5485f40 100644
--- a/crates/asap-aware-mapping/src/grouping.rs
+++ b/crates/asap-aware-mapping/src/grouping.rs
@@ -200,6 +200,7 @@ impl<'a> HydraGroupingStrategy<'a> {
 
         let patched = with_grouping(node, grouping);
         Some(ReplacementSubDAG {
+            strategy: "HydraGroupingStrategy",
             replacement: Replacement::Summary(patched),
             provenance: crate::replacement::ReplacementProvenance::SummaryImplementation,
             rationale: format!(
diff --git a/crates/asap-aware-mapping/src/lib.rs b/crates/asap-aware-mapping/src/lib.rs
index ad98fdc7..cd52612a 100644
--- a/crates/asap-aware-mapping/src/lib.rs
+++ b/crates/asap-aware-mapping/src/lib.rs
@@ -175,6 +175,7 @@ pub mod grouping;
 pub mod replacement;
 pub mod rewrite;
 pub mod rollup;
+pub mod topk_reuse;
 
 pub use cost_model::{CostModel, DefaultCostModel};
 pub use explanation::{
@@ -189,3 +190,4 @@ pub use replacement::{
     MAX_SEARCH_ITERATIONS,
 };
 pub use rewrite::AvgToSumOverCountStrategy;
+pub use topk_reuse::TopKLimitReuseStrategy;
diff --git a/crates/asap-aware-mapping/src/replacement.rs b/crates/asap-aware-mapping/src/replacement.rs
index 257455c7..e18a9a50 100644
--- a/crates/asap-aware-mapping/src/replacement.rs
+++ b/crates/asap-aware-mapping/src/replacement.rs
@@ -365,6 +365,7 @@ use thiserror::Error;
 use crate::cost_model::{CostModel, CseCandidate, DefaultCostModel, ShareDecision};
 use crate::grouping::HydraGroupingStrategy;
 use crate::rollup::RollupStrategy;
+use crate::topk_reuse::TopKLimitReuseStrategy;
 
 /// Errors from the pre-ASAP → post-ASAP replacement/construction path
 /// ([`realize_child`] and [`keep_pre_asap`]). Moved here from the former
@@ -446,6 +447,10 @@ pub enum Replacement {
 #[derive(Debug, Clone)]
 pub struct ReplacementSubDAG {
     pub replacement: Replacement,
+    /// Name of the [`ReplacementStrategy`] that proposed this candidate.
+    /// Search fills this from `ReplacementStrategy::name`; consumers must not
+    /// infer it from the replacement's shape or provenance.
+    pub strategy: &'static str,
     /// Machine-readable origin/role of this alternative. Selection uses this
     /// instead of inferring strategy semantics from replacement shape or
     /// pointer identity when several strategies contribute to one memo group.
@@ -476,6 +481,16 @@ pub enum ReplacementProvenance {
 /// don't match, so a caller that skips the `matches` check first still gets a
 /// safe (merely uninformative) answer instead of a crash.
 pub trait ReplacementStrategy {
+    /// Stable, human-readable strategy name carried into every proposed
+    /// candidate and ultimately into planner diagnostics/visualizations.
+    fn name(&self) -> &'static str {
+        let short = std::any::type_name::<Self>()
+            .rsplit("::")
+            .next()
+            .expect("a Rust type name always has a final segment");
+        short.split_once('<').map_or(short, |(base, _)| base)
+    }
+
     /// Does this strategy have any replacement to offer for `target`?
     fn matches(&self, target: &TargetSubDAG<'_>) -> bool;
 
@@ -1093,6 +1108,7 @@ impl ReplacementStrategy for SketchAlgorithmStrategy<'_> {
                 let rationale = describe_implementation(intent, &implementation);
                 let node = construct_summary(target.root, implementation, self.cost_model).ok()?;
                 Some(ReplacementSubDAG {
+                    strategy: "SketchAlgorithmStrategy",
                     replacement: Replacement::Summary(node),
                     provenance: ReplacementProvenance::SummaryImplementation,
                     rationale,
@@ -1219,10 +1235,14 @@ pub(crate) fn realize_child(
 /// candidate for a target, or a deployment wants to force a node its own
 /// runtime can't actually implement — through the same fallback this
 /// crate's own dispatch uses, without duplicating the schema-lift logic.
-pub fn keep_pre_asap(expr: &QueryExpr) -> Result<Rc<SummaryNode>, ImplementError> {
+pub fn keep_pre_asap(expr: &Rc<QueryExpr>) -> Result<Rc<SummaryNode>, ImplementError> {
+    keep_pre_asap_rc(Rc::clone(expr))
+}
+
+fn keep_pre_asap_rc(expr: Rc<QueryExpr>) -> Result<Rc<SummaryNode>, ImplementError> {
     let schema = expr.output_schema()?;
     Ok(Rc::new(SummaryNode {
-        expr: SummaryExpr::KeepPreAsap(Box::new(expr.clone())),
+        expr: SummaryExpr::KeepPreAsap(expr),
         schema: lift(&schema),
     }))
 }
@@ -1292,7 +1312,7 @@ pub(crate) fn construct_summary(
             }
         }
     }
-    keep_pre_asap(expr)
+    keep_pre_asap_rc(Rc::new(expr.clone()))
 }
 
 /// Translate an [`Implementation`] into the `(family, needs a
@@ -1493,6 +1513,7 @@ impl ReplacementStrategy for SharedSubtreeStrategy {
         let count = target.consumer_count;
         vec![
             ReplacementSubDAG {
+                strategy: "SharedSubtreeStrategy",
                 // The already-interned `Rc` itself: reusing it verbatim *is*
                 // "build once and share" — no new node to construct.
                 replacement: Replacement::Rewrite(Rc::clone(target.root)),
@@ -1504,6 +1525,7 @@ impl ReplacementStrategy for SharedSubtreeStrategy {
                 ),
             },
             ReplacementSubDAG {
+                strategy: "SharedSubtreeStrategy",
                 // A structurally-identical but freshly-allocated `Rc`: same
                 // value (`PartialEq`), deliberately *not* the same pointer,
                 // representing "undo the sharing and recompute independently".
@@ -2528,6 +2550,14 @@ fn search_cse_workload_with<'s, Id>(
         })
         .collect();
     let rollup_strategy = RollupStrategy::new(&siblings);
+    let limits: Vec<Rc<QueryExpr>> = order
+        .iter()
+        .filter_map(|ptr| {
+            let node = &nodes[ptr];
+            matches!(node.as_ref(), QueryExpr::Limit { .. }).then(|| Rc::clone(node))
+        })
+        .collect();
+    let topk_reuse_strategy = TopKLimitReuseStrategy::new(&limits);
 
     let mut groups: HashMap<*const QueryExpr, MemoGroup> = HashMap::new();
     for ptr in &order {
@@ -2565,11 +2595,32 @@ fn search_cse_workload_with<'s, Id>(
             let mut proposed = Vec::new();
             for strategy in strategies {
                 if strategy.matches(&target) {
-                    proposed.extend(strategy.replacements(&target));
+                    let name = strategy.name();
+                    proposed.extend(strategy.replacements(&target).into_iter().map(
+                        |mut candidate| {
+                            candidate.strategy = name;
+                            candidate
+                        },
+                    ));
                 }
             }
             if rollup_strategy.matches(&target) {
-                proposed.extend(rollup_strategy.replacements(&target));
+                let name = rollup_strategy.name();
+                proposed.extend(rollup_strategy.replacements(&target).into_iter().map(
+                    |mut candidate| {
+                        candidate.strategy = name;
+                        candidate
+                    },
+                ));
+            }
+            if topk_reuse_strategy.matches(&target) {
+                let name = topk_reuse_strategy.name();
+                proposed.extend(topk_reuse_strategy.replacements(&target).into_iter().map(
+                    |mut candidate| {
+                        candidate.strategy = name;
+                        candidate
+                    },
+                ));
             }
 
             for candidate in &proposed {
@@ -4314,16 +4365,19 @@ mod tests {
         let mut group = MemoGroup::new(Rc::clone(&target), 2);
         group.candidates = vec![
             ReplacementSubDAG {
+                strategy: "TestStrategy",
                 replacement: Replacement::Rewrite(Rc::clone(&target)),
                 provenance: ReplacementProvenance::CseShare,
                 rationale: "share".into(),
             },
             ReplacementSubDAG {
+                strategy: "TestStrategy",
                 replacement: Replacement::Rewrite(Rc::new(target.as_ref().clone())),
                 provenance: ReplacementProvenance::CseRecompute,
                 rationale: "recompute".into(),
             },
             ReplacementSubDAG {
+                strategy: "TestStrategy",
                 replacement: Replacement::Rewrite(Rc::new(QueryExpr::CurrentTimestamp)),
                 provenance: ReplacementProvenance::LogicalRewrite,
                 rationale: "different rewrite strategy".into(),
@@ -4578,6 +4632,7 @@ mod tests {
 
             fn replacements(&self, _target: &TargetSubDAG<'_>) -> Vec<ReplacementSubDAG> {
                 vec![ReplacementSubDAG {
+                    strategy: "ReplaceFilterChild",
                     replacement: Replacement::Rewrite(Rc::new(QueryExpr::Dedup {
                         cols: vec![0],
                         child: Rc::new(metric_scan(&["replacement"])),
@@ -4799,6 +4854,7 @@ mod tests {
                 child: Rc::new(fresh_inner_layer),
             };
             vec![ReplacementSubDAG {
+                strategy: "AlwaysGrowingStrategy",
                 replacement: Replacement::Rewrite(Rc::new(outer_wrapper)),
                 provenance: ReplacementProvenance::LogicalRewrite,
                 rationale: format!("pathological candidate #{n}"),
diff --git a/crates/asap-aware-mapping/src/rewrite.rs b/crates/asap-aware-mapping/src/rewrite.rs
index 92e39d6e..0f8a5bbb 100644
--- a/crates/asap-aware-mapping/src/rewrite.rs
+++ b/crates/asap-aware-mapping/src/rewrite.rs
@@ -229,6 +229,7 @@ impl ReplacementStrategy for AvgToSumOverCountStrategy {
             return Vec::new();
         };
         vec![ReplacementSubDAG {
+            strategy: "AvgToSumOverCountStrategy",
             replacement: Replacement::Rewrite(rewritten),
             provenance: crate::replacement::ReplacementProvenance::LogicalRewrite,
             rationale:
diff --git a/crates/asap-aware-mapping/src/rollup.rs b/crates/asap-aware-mapping/src/rollup.rs
index cc43e36f..5dc3c81e 100644
--- a/crates/asap-aware-mapping/src/rollup.rs
+++ b/crates/asap-aware-mapping/src/rollup.rs
@@ -372,6 +372,7 @@ fn build_rollup(
     };
 
     Some(ReplacementSubDAG {
+        strategy: "RollupStrategy",
         replacement: Replacement::Rewrite(Rc::new(rewritten)),
         provenance: crate::replacement::ReplacementProvenance::LogicalRewrite,
         rationale: format!(
diff --git a/crates/asap-aware-mapping/src/topk_reuse.rs b/crates/asap-aware-mapping/src/topk_reuse.rs
new file mode 100644
index 00000000..8329569d
--- /dev/null
+++ b/crates/asap-aware-mapping/src/topk_reuse.rs
@@ -0,0 +1,168 @@
+//! Workload-aware reuse between compatible ordered limits.
+//!
+//! If two queries rank the same input and request top-k results with
+//! `small_k < large_k`, the smaller result is exactly the first `small_k`
+//! rows of the larger result.  This strategy therefore replaces
+//! `Limit(small_k, Sort(X))` with `Limit(small_k, Limit(large_k, Sort(X)))`.
+
+use std::rc::Rc;
+
+use asap_types::pre_asap::QueryExpr;
+
+use crate::replacement::{
+    Replacement, ReplacementProvenance, ReplacementStrategy, ReplacementSubDAG, TargetSubDAG,
+};
+
+/// Derives a smaller top-k result from a compatible larger top-k sibling.
+pub struct TopKLimitReuseStrategy {
+    limits: Vec<Rc<QueryExpr>>,
+}
+
+impl TopKLimitReuseStrategy {
+    pub fn new(limits: &[Rc<QueryExpr>]) -> Self {
+        Self {
+            limits: limits.to_vec(),
+        }
+    }
+
+    fn larger_sources<'a>(&'a self, target: &TargetSubDAG<'_>) -> Vec<&'a Rc<QueryExpr>> {
+        let QueryExpr::Limit {
+            n: target_n,
+            offset: 0,
+            child: target_child,
+        } = target.root.as_ref()
+        else {
+            return Vec::new();
+        };
+
+        let mut sources: Vec<_> = self
+            .limits
+            .iter()
+            .filter(|candidate| {
+                if Rc::ptr_eq(candidate, target.root) {
+                    return false;
+                }
+                let QueryExpr::Limit {
+                    n,
+                    offset: 0,
+                    child,
+                } = candidate.as_ref()
+                else {
+                    return false;
+                };
+                n > target_n
+                    && (Rc::ptr_eq(child, target_child) || child.as_ref() == target_child.as_ref())
+            })
+            .collect();
+        // Prefer the smallest sufficient materialized top-k when several
+        // larger siblings are available.
+        sources.sort_by_key(|source| match source.as_ref() {
+            QueryExpr::Limit { n, .. } => *n,
+            _ => unreachable!(),
+        });
+        sources
+    }
+}
+
+impl ReplacementStrategy for TopKLimitReuseStrategy {
+    fn matches(&self, target: &TargetSubDAG<'_>) -> bool {
+        !self.larger_sources(target).is_empty()
+    }
+
+    fn replacements(&self, target: &TargetSubDAG<'_>) -> Vec<ReplacementSubDAG> {
+        let QueryExpr::Limit {
+            n: target_n,
+            offset: 0,
+            ..
+        } = target.root.as_ref()
+        else {
+            return Vec::new();
+        };
+
+        self.larger_sources(target)
+            .into_iter()
+            .map(|source| {
+                let source_n = match source.as_ref() {
+                    QueryExpr::Limit { n, .. } => *n,
+                    _ => unreachable!(),
+                };
+                ReplacementSubDAG {
+                    strategy: "TopKLimitReuseStrategy",
+                    replacement: Replacement::Rewrite(Rc::new(QueryExpr::Limit {
+                        n: *target_n,
+                        offset: 0,
+                        child: Rc::clone(source),
+                    })),
+                    provenance: ReplacementProvenance::LogicalRewrite,
+                    rationale: format!(
+                        "derives top-{target_n} from the compatible shared top-{source_n} result; both rank the identical input with the same ordering"
+                    ),
+                }
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use asap_types::pre_asap::{Schema, Source};
+
+    fn scan_named(metric: &str) -> Rc<QueryExpr> {
+        Rc::new(QueryExpr::Scan {
+            source: Source::TimeSeries {
+                metric: metric.into(),
+            },
+            predicates: vec![],
+            schema: Schema::with_time_index(vec![], 0, vec![]),
+        })
+    }
+
+    #[test]
+    fn smaller_limit_reuses_larger_compatible_limit() {
+        let child = scan_named("m");
+        let small = Rc::new(QueryExpr::Limit {
+            n: 5,
+            offset: 0,
+            child: Rc::clone(&child),
+        });
+        let large = Rc::new(QueryExpr::Limit {
+            n: 10,
+            offset: 0,
+            child,
+        });
+        let strategy = TopKLimitReuseStrategy::new(&[Rc::clone(&small), Rc::clone(&large)]);
+        let replacements = strategy.replacements(&TargetSubDAG::new(&small));
+        assert_eq!(replacements.len(), 1);
+        let Replacement::Rewrite(rewrite) = &replacements[0].replacement else {
+            panic!()
+        };
+        let QueryExpr::Limit { n: 5, child, .. } = rewrite.as_ref() else {
+            panic!()
+        };
+        assert!(Rc::ptr_eq(child, &large));
+    }
+
+    #[test]
+    fn offset_or_different_input_is_not_reused() {
+        let a = scan_named("a");
+        let b = scan_named("b");
+        let small = Rc::new(QueryExpr::Limit {
+            n: 5,
+            offset: 0,
+            child: a,
+        });
+        let large = Rc::new(QueryExpr::Limit {
+            n: 10,
+            offset: 0,
+            child: b,
+        });
+        let offset = Rc::new(QueryExpr::Limit {
+            n: 20,
+            offset: 1,
+            child: scan_named("a"),
+        });
+        let strategy = TopKLimitReuseStrategy::new(&[Rc::clone(&small), large, offset]);
+        assert!(!strategy.matches(&TargetSubDAG::new(&small)));
+    }
+}
diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 168bc740..3dd7dde5 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -18,15 +18,50 @@
 //   cargo run -p asap-lower --bin dag_export -- \
 //       --epsilon 0.01 --sql "SELECT quantile(0.99, latency) FROM metrics" --name p99
 //
-// `--catalog <name>` is optional (default `metrics`) and applies to every
-// `--sql` query in the run — pick the schema matching whatever domain corpus
-// you're feeding in. One of `metrics` (the built-in `metrics`/`hosts` demo
-// schema this binary has always used), `packets` (matches
-// `frontend-sql/tests/data_quality_check/data/synthetic_packet_trace_queries.sql`),
-// or `netflow` (matches `frontend-sql/tests/netflow/data/netflow.sql`).
-// `--promql` queries ignore `--catalog` entirely (PromQL has no table schema).
-
-use asap_types::dag_export::{self, DagGraph, DagNote, NamedGraph, WorkloadGraph};
+// `--post-asap` is optional and off by default. When passed, this binary
+// additionally runs `asap_aware_mapping::replacement::search_workload` (this
+// binary took no strategies of its own — `default_strategies()` already
+// includes `AvgToSumOverCountStrategy` as of #282) over every lowered query
+// and ranks each discovered `MemoGroup` via `PlanSpace::cost_sorted`. The
+// best-ranked
+// candidate per group feeds two additive outputs:
+//
+//   - one `asap_types::dag_export::TargetReplacement` per group on whichever
+//     query's `NamedGraph.replacements` contains that target node (matched
+//     by `DagNode::hash` + structural equality, the same collision-safe
+//     pattern `annotate_with_explanations` below already uses for notes) —
+//     a small, self-contained "before -> after" pair per replacement site;
+//   - one merged `NamedGraph.post_graph`: a single flattened graph per
+//     query with every winning candidate spliced directly into the query's
+//     own pre-ASAP shape in place, built via
+//     `asap_types::dag_export::export_post_asap`.
+//
+// Together these surface every one of the four concrete replacement kinds:
+// the sketch family `SketchAlgorithmStrategy`/`HydraGroupingStrategy` bound,
+// the CSE share/recompute choice `SharedSubtreeStrategy` found, the
+// workload-aware roll-up `RollupStrategy` derived, and the `avg ->
+// sum/count` rewrite `AvgToSumOverCountStrategy` proposes. Without
+// `--post-asap`, every existing invocation of this binary produces
+// byte-identical output to before (`NamedGraph.replacements` is empty and
+// `post_graph` is `None`, both skipped from the JSON entirely in that
+// case). E.g.:
+//   cargo run -p asap-lower --bin dag_export -- \
+//       --post-asap --epsilon 0.01 \
+//       --sql "SELECT quantile(0.95, latency) FROM metrics" --name q1
+
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::time::Instant;
+
+use asap_aware_mapping::cost_model::DefaultCostModel;
+use asap_aware_mapping::replacement::{search_workload, Replacement, ReplacementSubDAG};
+use asap_types::dag_export::{
+    self, DagDecision, DagGraph, DagNote, NamedGraph, PostAsapSubstitution, TargetReplacement,
+    TargetReplacementAfter, WorkloadGraph,
+};
+use asap_types::post_asap::SummaryExpr;
+use asap_types::pre_asap::cse::{structural_hash, HashCache};
+use asap_types::pre_asap::query_expr::QueryExpr;
 use asap_types::pre_asap::schema::{Column, DataType, Schema};
 use asap_types::types::AccuracyTarget;
 
@@ -37,21 +72,17 @@ enum Lang {
     PromQl,
 }
 
-fn col(name: &str, dtype: DataType) -> Column {
-    Column::new(name, dtype, false)
-}
-
-fn metrics_catalog() -> SqlCatalog {
+fn default_catalog() -> SqlCatalog {
     SqlCatalog::new()
         .with_table(
             "metrics",
             Schema::with_time_index(
                 vec![
-                    col("ts", DataType::Timestamp),
-                    col("service", DataType::Utf8),
-                    col("region", DataType::Utf8),
-                    col("latency", DataType::Float64),
-                    col("bytes", DataType::Int64),
+                    Column::new("ts", DataType::Timestamp, false),
+                    Column::new("service", DataType::Utf8, false),
+                    Column::new("region", DataType::Utf8, false),
+                    Column::new("latency", DataType::Float64, false),
+                    Column::new("bytes", DataType::Int64, false),
                 ],
                 0,
                 vec![],
@@ -60,66 +91,76 @@ fn metrics_catalog() -> SqlCatalog {
         .with_table(
             "hosts",
             Schema::new(vec![
-                col("service", DataType::Utf8),
-                col("region", DataType::Utf8),
+                Column::new("service", DataType::Utf8, false),
+                Column::new("region", DataType::Utf8, false),
             ]),
         )
 }
 
-/// Matches `synthetic_packet_trace_queries.sql`'s `packets` table.
-fn packets_catalog() -> SqlCatalog {
-    SqlCatalog::new().with_table(
-        "packets",
-        Schema::new(vec![
-            col("srcip", DataType::Utf8),
-            col("dstip", DataType::Utf8),
-            col("srcport", DataType::Int64),
-            col("dstport", DataType::Int64),
-            col("proto", DataType::Utf8),
-            col("time", DataType::Float64),
-            col("pkt_len", DataType::Int64),
-        ]),
-    )
-}
-
-/// Matches `netflow.sql`'s `netflow_table` table.
-fn netflow_catalog() -> SqlCatalog {
-    SqlCatalog::new().with_table(
-        "netflow_table",
-        Schema::with_time_index(
-            vec![
-                col("time", DataType::Timestamp),
-                col("srcip", DataType::Utf8),
-                col("dstip", DataType::Utf8),
-                col("srcport", DataType::Int64),
-                col("dstport", DataType::Int64),
-                col("proto", DataType::Utf8),
-                col("pkt_len", DataType::Int64),
-            ],
-            0,
-            vec![],
-        ),
-    )
-}
-
-fn catalog_by_name(name: &str) -> SqlCatalog {
-    match name {
-        "metrics" => metrics_catalog(),
-        "packets" => packets_catalog(),
-        "netflow" => netflow_catalog(),
-        other => panic!("unknown --catalog {other:?} — expected one of: metrics, packets, netflow"),
+fn catalog(custom: &[String]) -> SqlCatalog {
+    let mut catalog = default_catalog();
+    for raw in custom {
+        let value: serde_json::Value = serde_json::from_str(raw)
+            .unwrap_or_else(|error| panic!("--table-schema must be valid JSON: {error}"));
+        let name = value["name"]
+            .as_str()
+            .expect("--table-schema.name must be a string");
+        let columns = value["columns"]
+            .as_array()
+            .expect("--table-schema.columns must be an array");
+        let columns: Vec<Column> = columns
+            .iter()
+            .map(|column| {
+                let column_name = column["name"]
+                    .as_str()
+                    .expect("column.name must be a string");
+                let data_type = match column["type"]
+                    .as_str()
+                    .expect("column.type must be a string")
+                    .to_ascii_lowercase()
+                    .as_str()
+                {
+                    "timestamp" => DataType::Timestamp,
+                    "utf8" | "string" => DataType::Utf8,
+                    "float64" | "double" => DataType::Float64,
+                    "int64" | "bigint" => DataType::Int64,
+                    other => panic!("unsupported column type {other:?}"),
+                };
+                Column::new(
+                    column_name,
+                    data_type,
+                    column["nullable"].as_bool().unwrap_or(true),
+                )
+            })
+            .collect();
+        let schema = match value.get("time_index").and_then(|index| index.as_u64()) {
+            Some(index) => Schema::with_time_index(columns, index as usize, vec![]),
+            None => Schema::new(columns),
+        };
+        catalog = catalog.with_table(name, schema);
     }
+    catalog
 }
 
 /// Parses `--sql "<query>" --name "<label>"` / `--promql "<query>" --name
 /// "<label>"` pairs off argv, in the order given, plus one optional global
-/// `--epsilon <f64>`. `--name` is optional and applies to the immediately
-/// preceding `--sql`/`--promql`.
-fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, SqlCatalog) {
+/// `--epsilon <f64>` and one optional global `--post-asap` flag. `--name` is
+/// optional and applies to the immediately preceding `--sql`/`--promql`.
+struct ParsedArgs {
+    entries: Vec<(String, Lang, String)>,
+    accuracy: AccuracyTarget,
+    post_asap: bool,
+    progress: bool,
+    table_schemas: Vec<String>,
+}
+
+fn parse_args() -> ParsedArgs {
     let mut entries: Vec<(String, Lang, String)> = Vec::new();
     let mut pending: Option<(Lang, String)> = None;
     let mut accuracy = AccuracyTarget::Exact;
-    let mut catalog_name = "metrics".to_string();
+    let mut post_asap = false;
+    let mut progress = false;
+    let mut table_schemas = Vec::new();
     let mut args = std::env::args().skip(1);
 
     fn flush(entries: &mut Vec<(String, Lang, String)>, pending: &mut Option<(Lang, String)>) {
@@ -154,19 +195,34 @@ fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, SqlCatalog) {
                     .unwrap_or_else(|_| panic!("--epsilon must be a float, got {raw:?}"));
                 accuracy = AccuracyTarget::Epsilon(epsilon);
             }
-            "--catalog" => {
-                catalog_name = args.next().expect("--catalog requires a value");
+            "--post-asap" => {
+                post_asap = true;
+            }
+            "--progress" => {
+                progress = true;
+            }
+            "--table-schema" => {
+                table_schemas.push(args.next().expect("--table-schema requires JSON"));
             }
             other => panic!("unrecognized argument: {other}"),
         }
     }
     flush(&mut entries, &mut pending);
-    (entries, accuracy, catalog_by_name(&catalog_name))
+    ParsedArgs {
+        entries,
+        accuracy,
+        post_asap,
+        progress,
+        table_schemas,
+    }
 }
 
 /// Attach workload-wide replacement explanations to their exact graph nodes.
-/// `node_hash` is only a narrowing filter; `source_expr == target` is the
-/// collision-safe identity check.
+/// `node_hash` is only a narrowing filter; `source_expr == Some(target)` is
+/// the collision-safe identity check (`source_expr` is `None` only for a
+/// post-ASAP-originated node inside a `--post-asap` `post_graph`, which this
+/// function is never called on — every node it sees, from an ordinary
+/// [`dag_export::export`], carries `Some`).
 fn annotate_with_explanations(
     graph: &mut DagGraph,
     explanations: &[asap_aware_mapping::ReplacementExplanation],
@@ -174,7 +230,9 @@ fn annotate_with_explanations(
 ) {
     for (i, explanation) in explanations.iter().enumerate() {
         for node in graph.nodes.iter_mut() {
-            if node.hash == explanation.node_hash && node.source_expr == *explanation.target {
+            if node.hash == Some(explanation.node_hash)
+                && node.source_expr.as_ref() == Some(explanation.target.as_ref())
+            {
                 node.notes.push(DagNote {
                     kind: format!("{:?}", explanation.kind),
                     reason: explanation.reason.clone(),
@@ -185,20 +243,399 @@ fn annotate_with_explanations(
     }
 }
 
+/// One `MemoGroup`'s best-ranked candidate, kept alongside its own `target`
+/// and `cost` — the unit both [`PostAsapResults::replacements`] and
+/// [`PostAsapResults::post_graphs`] are built from, so the two outputs can
+/// never disagree about which candidate won for a given target.
+struct Winner<'a> {
+    target: &'a Rc<QueryExpr>,
+    candidate: &'a ReplacementSubDAG,
+    cost: f64,
+}
+
+/// Short explanation intended for a selected winner in node-level UI. The
+/// candidate's full rationale remains available in pre-ASAP applicability
+/// notes; repeating that exhaustive prose on every post-ASAP region node
+/// obscures the actual decision.
+fn decision_rationale(winner: &Winner<'_>) -> String {
+    match winner.candidate.strategy {
+        "AvgToSumOverCountStrategy" => {
+            "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT."
+                .to_string()
+        }
+        "SharedSubtreeStrategy" => match winner.candidate.provenance {
+            asap_aware_mapping::replacement::ReplacementProvenance::CseShare => {
+                "Builds the repeated subtree once and shares it across consumers.".to_string()
+            }
+            asap_aware_mapping::replacement::ReplacementProvenance::CseRecompute => {
+                "Recomputes the subtree per consumer because that has the lower estimated cost."
+                    .to_string()
+            }
+            _ => "Chooses the lowest-cost handling of the repeated subtree.".to_string(),
+        },
+        "RollupStrategy" => {
+            "Answers this aggregate from a compatible finer-grained aggregate.".to_string()
+        }
+        "TopKLimitReuseStrategy" => {
+            "Derives this smaller top-k from a compatible larger top-k result shared by the workload."
+                .to_string()
+        }
+        _ => {
+            let summary = winner
+                .candidate
+                .rationale
+                .split_once(" — ")
+                .map_or(winner.candidate.rationale.as_str(), |(summary, _)| summary);
+            summary
+                .split_once(" (asap_")
+                .map_or(summary, |(plain, _)| plain)
+                .to_string()
+        }
+    }
+}
+
+/// Find the index into `winners` (if any) whose `target` is structurally
+/// identical to `expr` — `by_hash` is only a narrowing filter (keyed by
+/// [`structural_hash`]); `expr == target` is the collision-safe identity
+/// check, the same two-step discipline [`annotate_with_explanations`] and
+/// this file's original single-target matching already use. Returns an
+/// index rather than a `&Winner` directly so a caller can both use the
+/// match and record it (e.g. `matched[i] = true`) without juggling a second
+/// way to name the same winner.
+fn lookup_winner(
+    by_hash: &HashMap<u64, Vec<usize>>,
+    winners: &[Winner<'_>],
+    cache: &mut HashCache,
+    expr: &QueryExpr,
+) -> Option<usize> {
+    let hash = structural_hash(expr, cache);
+    by_hash
+        .get(&hash)?
+        .iter()
+        .copied()
+        .find(|&i| expr == winners[i].target.as_ref())
+}
+
+/// Build a [`TargetReplacement`] for `winner`, matching this file's own
+/// per-target `before`/`after` construction.
+fn target_replacement(
+    decision_id: u32,
+    target_pre_id: u32,
+    winner: &Winner<'_>,
+) -> TargetReplacement {
+    let strategy = winner.candidate.strategy.to_string();
+    let before = dag_export::export(winner.target);
+    let after = match &winner.candidate.replacement {
+        Replacement::Summary(node) => {
+            TargetReplacementAfter::Summary(dag_export::export_summary(node))
+        }
+        Replacement::Rewrite(rewritten) => {
+            TargetReplacementAfter::Rewrite(dag_export::export(rewritten))
+        }
+    };
+    TargetReplacement {
+        decision_id,
+        target_pre_id,
+        strategy,
+        rationale: decision_rationale(winner),
+        rank: 0,
+        cost: winner.cost,
+        before,
+        after,
+    }
+}
+
+/// The two additive `--post-asap` outputs — see this file's top-of-file
+/// usage doc for what each is for.
+struct PostAsapResults {
+    /// One `(query_name, TargetReplacement)` pair per discovered replacement
+    /// site whose target node is found in that query's own exported graph. A
+    /// target can in principle be reachable from more than one query's root
+    /// after CSE (a shared subtree), in which case it yields one pair per
+    /// matching query, each with that query's own `target_pre_id`.
+    replacements: Vec<(String, TargetReplacement)>,
+    /// One merged, whole-query [`DagGraph`] per query, built via
+    /// [`dag_export::export_post_asap`] — every winning candidate spliced
+    /// directly into that query's own pre-ASAP shape in place.
+    post_graphs: Vec<(String, DagGraph)>,
+}
+
+/// Assign collision-free, explicit identities to structurally equal nodes
+/// across a set of exported query graphs. The full canonical subtree string
+/// is the equality key; the compact integer is what JSON consumers receive.
+/// Consequently the viewer never needs to guess identity from labels,
+/// hashes, or a client-side node signature.
+fn assign_workload_node_ids(graphs: &mut [&mut DagGraph]) {
+    fn key_for(id: u32, graph: &DagGraph, memo: &mut HashMap<u32, String>) -> String {
+        if let Some(key) = memo.get(&id) {
+            return key.clone();
+        }
+        let node = &graph.nodes[id as usize];
+        let child_keys: Vec<_> = node
+            .children
+            .iter()
+            .map(|child| key_for(*child, graph, memo))
+            .collect();
+        let key = serde_json::to_string(&(node.kind, &node.detail, &node.schema, child_keys))
+            .expect("exported DAG node content is serializable");
+        memo.insert(id, key.clone());
+        key
+    }
+
+    let mut ids = HashMap::<String, u32>::new();
+    let mut next_id = 0_u32;
+    for graph in graphs.iter_mut() {
+        let mut memo = HashMap::new();
+        let keys: Vec<_> = graph
+            .nodes
+            .iter()
+            .map(|node| key_for(node.id, graph, &mut memo))
+            .collect();
+        for (node, key) in graph.nodes.iter_mut().zip(keys) {
+            let id = *ids.entry(key).or_insert_with(|| {
+                let id = next_id;
+                next_id += 1;
+                id
+            });
+            node.workload_node_id = Some(id);
+        }
+    }
+}
+
+/// Run `asap_aware_mapping::replacement::search_workload` (its own
+/// `default_strategies()` — which includes `AvgToSumOverCountStrategy` as of
+/// #282 — is exactly the strategy set this binary wants; no custom list
+/// needed) over every lowered query, rank each discovered `MemoGroup` via
+/// `PlanSpace::cost_sorted`, and build both `--post-asap` outputs from the
+/// exact same set of winning candidates (see [`Winner`]), so the flat
+/// `replacements` list and the merged `post_graph` can never disagree about
+/// which candidate won for a given target.
+fn run_post_asap_with_progress(
+    lowered_queries: &[(String, String, QueryExpr)],
+    progress: bool,
+) -> PostAsapResults {
+    let mapping_started = Instant::now();
+    if progress {
+        eprintln!("[3/4] ASAP-aware mapping is running…");
+    }
+    let roots: Vec<(String, Rc<QueryExpr>)> = lowered_queries
+        .iter()
+        .map(|(name, _, qe)| (name.clone(), Rc::new(qe.clone())))
+        .collect();
+    let space = search_workload(roots);
+    let ranked_groups = space.cost_sorted(&DefaultCostModel);
+
+    // A group's top candidate can be `keep_pre_asap`'s own conservative
+    // fallback — `Replacement::Summary(SummaryNode { expr:
+    // KeepPreAsap(Rc::new(target.clone())), .. })` — the *whole target*
+    // wrapped as unbound, e.g. for a multi-measure/`HAVING`-bearing
+    // aggregate, or (the case that actually surfaces this: `STDDEV_POP`/
+    // `AVG`/`VARIANCE` dispatch to `Implementation::PassThrough` with no
+    // alternative at all, per `implementations_for_with`'s own doc) an
+    // intent with no summary realization whatsoever. This isn't a
+    // replacement decision — it's `SketchAlgorithmStrategy` saying "nothing
+    // to bind here" — the identical "no-op candidate" concept
+    // `explanation.rs`'s own `sketch_finding_reason` already excludes from
+    // being reported as a finding ("a candidate list containing only the
+    // trivial no-op realization... isn't an opportunity, it's just the
+    // target's existing shape reflected back"). Filtered out here for a
+    // second, load-bearing reason beyond just matching that precedent:
+    // `export_post_asap`'s `find_winner` re-checks every node reached
+    // inside a spliced-in `KeepPreAsap` payload (by design, so a target
+    // nested underneath one still gets found) — if that payload structurally
+    // *is* the enclosing target, `find_winner` immediately matches the same
+    // winner again, forever. Treating this candidate as "no winner" (same
+    // as an empty candidate list) avoids ever handing `export_post_asap` a
+    // winner that can't help but recurse into itself.
+    let winners: Vec<Winner<'_>> = ranked_groups
+        .iter()
+        .filter_map(|group| {
+            let candidate = group.candidates.first()?;
+            if matches!(
+                &candidate.replacement,
+                Replacement::Summary(node) if matches!(node.expr, SummaryExpr::KeepPreAsap(_))
+            ) {
+                return None;
+            }
+            Some(Winner {
+                target: group.target,
+                candidate,
+                cost: group.costs[0],
+            })
+        })
+        .collect();
+
+    // `by_hash` only narrows the search; `lookup_winner`'s own structural
+    // equality check is the real decision — see that function's doc.
+    let mut by_hash_cache = HashCache::new();
+    let mut by_hash: HashMap<u64, Vec<usize>> = HashMap::new();
+    for (i, winner) in winners.iter().enumerate() {
+        let hash = structural_hash(winner.target, &mut by_hash_cache);
+        by_hash.entry(hash).or_default().push(i);
+    }
+    if progress {
+        eprintln!(
+            "[3/4] ASAP-aware mapping done in {:.2} ms",
+            mapping_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
+
+    // ---- Merged, whole-query `post_graph`, one per query ---------------
+    //
+    // Built *before* the flat `replacements` pass below, not after: a
+    // winner whose target only exists inside another winner's own
+    // `Replacement::Rewrite` output (e.g. the `sum`/`count` aggregates
+    // `AvgToSumOverCountStrategy`'s rewrite exposes, which
+    // `default_strategies()` — #282 — now discovers and independently
+    // sketch-ranks in the same search pass) can never appear in any query's
+    // *original*, pre-rewrite `graph` — there's nothing wrong with that
+    // winner, it's just nested. `post_graph` is where it's expected to
+    // surface instead (`export_post_asap`'s recursive `find_winner`
+    // threading walks straight through a rewritten subtree and re-checks
+    // every node inside it too), so the flat-`replacements` pass below
+    // checks there before deciding a miss is a real anomaly worth a
+    // warning.
+    if progress {
+        eprintln!("[4/4] Post-ASAP DAG generation is running…");
+    }
+    let post_started = Instant::now();
+    let mut post_graph_cache = HashCache::new();
+    let mut find_winner = |expr: &QueryExpr| -> Option<PostAsapSubstitution> {
+        let i = lookup_winner(&by_hash, &winners, &mut post_graph_cache, expr)?;
+        let winner = &winners[i];
+        let decision = DagDecision {
+            id: i as u32,
+            strategy: winner.candidate.strategy.to_string(),
+            rationale: decision_rationale(winner),
+            rank: 0,
+            cost: winner.cost,
+            role: "replacement_region",
+        };
+        Some(match &winners[i].candidate.replacement {
+            Replacement::Rewrite(rc) => PostAsapSubstitution::Rewrite {
+                replacement: Rc::clone(rc),
+                decision,
+            },
+            Replacement::Summary(rc) => PostAsapSubstitution::Summary {
+                replacement: Rc::clone(rc),
+                decision,
+            },
+        })
+    };
+    let post_graphs: Vec<(String, DagGraph)> = lowered_queries
+        .iter()
+        .map(|(name, _, qe)| {
+            (
+                name.clone(),
+                dag_export::export_post_asap(qe, &mut find_winner),
+            )
+        })
+        .collect();
+
+    // ---- Flat per-target `replacements`, one list per query -----------
+    //
+    // Independently re-export every query's own graph for matching — a
+    // fresh `export` per query, not reused from `main`'s own already-built
+    // `NamedGraph`s, so this function stays self-contained and callable on
+    // its own (see this file's `#[cfg(test)]` module). Deliberately anchored
+    // to the *original* `graph` only (never `post_graph`) — `target_pre_id`
+    // is documented as an id into `NamedGraph.graph.nodes`, so a nested
+    // secondary target (see above) never gets a flat entry of its own here:
+    // it's already visible, in place, inside its parent's own `after`
+    // subtree and inside `post_graph` as a whole.
+    let mut lookup_cache = HashCache::new();
+    let mut replacements = Vec::new();
+    let mut matched = vec![false; winners.len()];
+    for (name, _, qe) in lowered_queries {
+        let graph = dag_export::export(qe);
+        for node in &graph.nodes {
+            let Some(source_expr) = node.source_expr.as_ref() else {
+                continue; // never true for a plain `export` — defensive only.
+            };
+            if let Some(i) = lookup_winner(&by_hash, &winners, &mut lookup_cache, source_expr) {
+                replacements.push((
+                    name.clone(),
+                    target_replacement(i as u32, node.id, &winners[i]),
+                ));
+                matched[i] = true;
+            }
+        }
+    }
+
+    // A winner can legitimately stay unmatched here: `default_strategies()`
+    // (#282) means `AvgToSumOverCountStrategy`'s rewrite output (and
+    // similarly `RollupStrategy`'s) can expose a brand-new `sum`/`count`
+    // descendant that the *same* search pass then independently discovers
+    // and ranks — a real winner, but one with no node anywhere in any
+    // query's original, pre-rewrite `graph` to attach a flat entry to
+    // (`target_pre_id` is documented as an id into `graph.nodes`
+    // specifically). This isn't a data loss: `export_post_asap` still
+    // splices that winner in, in place, inside `post_graph` — see this
+    // function's own construction of `post_graphs` above, which walks
+    // straight through a rewritten subtree and resolves every nested
+    // winner too, recursively. So an unmatched winner here is expected,
+    // not necessarily a bug, whenever it's downstream of some other
+    // winner's own `Replacement::Rewrite` — logged as an FYI rather than a
+    // warning, since telling the two cases apart precisely would mean
+    // reimplementing `search`'s own private descendant-discovery walk
+    // (`discover_new_descendant_targets` in `asap_aware_mapping::replacement`,
+    // not exposed) a second time here just to double-check something
+    // `post_graph`'s own construction already handled correctly.
+    for (winner, matched) in winners.iter().zip(&matched) {
+        if !matched {
+            let strategy = winner.candidate.strategy;
+            eprintln!(
+                "dag_export: post-asap replacement ({strategy}) has no node in any query's \
+                 original graph — expected for a winner exposed only inside another winner's \
+                 own rewrite output (e.g. a sum/count descendant of an avg rewrite); still \
+                 present in that query's post_graph"
+            );
+        }
+    }
+    if progress {
+        eprintln!(
+            "[4/4] Post-ASAP DAG generation done in {:.2} ms",
+            post_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
+
+    PostAsapResults {
+        replacements,
+        post_graphs,
+    }
+}
+
+#[cfg(test)]
+fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapResults {
+    run_post_asap_with_progress(lowered_queries, false)
+}
+
 #[tokio::main]
 async fn main() {
-    let (entries, accuracy, catalog) = parse_args();
+    let ParsedArgs {
+        entries,
+        accuracy,
+        post_asap,
+        progress,
+        table_schemas,
+    } = parse_args();
+    let sql_catalog = catalog(&table_schemas);
+    let planner_started = Instant::now();
     if entries.is_empty() {
         eprintln!(
-            "usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] [--catalog <metrics|packets|netflow>] ..."
+            "usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] [--post-asap] ..."
         );
         std::process::exit(1);
     }
 
     let mut lowered_queries = Vec::new();
+    let lowering_started = Instant::now();
+    if progress {
+        eprintln!("[1/4] Parsing and lowering SQL/PromQL queries…");
+    }
     for (name, lang, query) in entries {
         let lowered = match lang {
-            Lang::Sql => lower_sql(&query, &catalog, accuracy.clone())
+            Lang::Sql => lower_sql(&query, &sql_catalog, accuracy.clone())
                 .await
                 .map_err(|e| e.to_string()),
             Lang::PromQl => lower_promql(&query, accuracy.clone()).map_err(|e| e.to_string()),
@@ -210,7 +647,17 @@ async fn main() {
             Err(e) => eprintln!("skipping {name:?} — lowering failed: {e}"),
         }
     }
+    if progress {
+        eprintln!(
+            "[1/4] Parsing and lowering done in {:.2} ms",
+            lowering_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
 
+    let pre_started = Instant::now();
+    if progress {
+        eprintln!("[2/4] Pre-ASAP DAG generation is running…");
+    }
     let explanations = asap_aware_mapping::explain_replacements(
         lowered_queries
             .iter()
@@ -219,13 +666,15 @@ async fn main() {
     );
     let mut matched = vec![false; explanations.len()];
     let mut queries = Vec::new();
-    for (name, source, qe) in lowered_queries {
-        let mut graph = dag_export::export(&qe);
+    for (name, source, qe) in &lowered_queries {
+        let mut graph = dag_export::export(qe);
         annotate_with_explanations(&mut graph, &explanations, &mut matched);
         queries.push(NamedGraph {
-            name,
-            source: Some(source),
+            name: name.clone(),
+            source: Some(source.clone()),
             graph,
+            replacements: Vec::new(),
+            post_graph: None,
         });
     }
     for (explanation, matched) in explanations.iter().zip(matched) {
@@ -236,8 +685,46 @@ async fn main() {
             );
         }
     }
+    if progress {
+        eprintln!(
+            "[2/4] Pre-ASAP DAG generation done in {:.2} ms",
+            pre_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
+
+    if post_asap {
+        let results = run_post_asap_with_progress(&lowered_queries, progress);
+        for (query_name, replacement) in results.replacements {
+            if let Some(named) = queries.iter_mut().find(|q| q.name == query_name) {
+                named.replacements.push(replacement);
+            }
+        }
+        for (query_name, post_graph) in results.post_graphs {
+            if let Some(named) = queries.iter_mut().find(|q| q.name == query_name) {
+                named.post_graph = Some(post_graph);
+            }
+        }
+    }
+
+    {
+        let mut pre_graphs: Vec<_> = queries.iter_mut().map(|query| &mut query.graph).collect();
+        assign_workload_node_ids(&mut pre_graphs);
+    }
+    {
+        let mut post_graphs: Vec<_> = queries
+            .iter_mut()
+            .filter_map(|query| query.post_graph.as_mut())
+            .collect();
+        assign_workload_node_ids(&mut post_graphs);
+    }
 
     let workload = WorkloadGraph { queries };
+    if progress {
+        eprintln!(
+            "Total planner time: {:.2} ms",
+            planner_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
     println!("{}", serde_json::to_string_pretty(&workload).unwrap());
 }
 
@@ -282,10 +769,264 @@ mod tests {
             lower_promql("sum(rate(other_metric[5m]))", AccuracyTarget::Epsilon(0.01)).unwrap();
         let mut graph = dag_export::export(&unrelated);
         for node in &mut graph.nodes {
-            node.hash = explanation.node_hash;
+            node.hash = Some(explanation.node_hash);
         }
         let mut matched = vec![false; explanations.len()];
         annotate_with_explanations(&mut graph, &explanations, &mut matched);
         assert!(graph.nodes.iter().all(|n| n.notes.is_empty()));
     }
+
+    /// The `--post-asap` code path, exercised directly (not through the CLI):
+    /// a workload with one sketch-approximable quantile aggregate and one
+    /// `avg` aggregate must produce at least one `TargetReplacement` with
+    /// `after: TargetReplacementAfter::Summary(..)` (the bound sketch) and
+    /// at least one with `after: TargetReplacementAfter::Rewrite(..)` (the
+    /// `avg -> sum/count` rewrite) — see [`run_post_asap`]. Also checks that
+    /// a non-empty `post_graph` comes back for every query, since that's the
+    /// other `--post-asap` output `main` wires up.
+    #[tokio::test]
+    async fn post_asap_run_produces_both_summary_and_rewrite_replacements() {
+        let cat = default_catalog();
+        let sketch_query = lower_sql(
+            "SELECT approx_percentile_cont(latency, 0.95) FROM metrics",
+            &cat,
+            AccuracyTarget::Epsilon(0.01),
+        )
+        .await
+        .unwrap();
+        let avg_query = lower_sql(
+            "SELECT service, AVG(latency) FROM metrics GROUP BY service",
+            &cat,
+            AccuracyTarget::Epsilon(0.01),
+        )
+        .await
+        .unwrap();
+
+        let lowered_queries = vec![
+            (
+                "sketch".to_string(),
+                "SELECT approx_percentile_cont(latency, 0.95) FROM metrics".to_string(),
+                sketch_query,
+            ),
+            (
+                "avg".to_string(),
+                "SELECT service, AVG(latency) FROM metrics GROUP BY service".to_string(),
+                avg_query,
+            ),
+        ];
+
+        let results = run_post_asap(&lowered_queries);
+
+        assert!(
+            results
+                .replacements
+                .iter()
+                .any(|(_, r)| matches!(r.after, TargetReplacementAfter::Summary(_))),
+            "expected at least one Summary replacement (the sketch-bound quantile aggregate): {:?}",
+            results
+                .replacements
+                .iter()
+                .map(|(name, r)| (name.clone(), r.strategy.clone()))
+                .collect::<Vec<_>>()
+        );
+        assert!(
+            results
+                .replacements
+                .iter()
+                .any(|(_, r)| matches!(r.after, TargetReplacementAfter::Rewrite(_))),
+            "expected at least one Rewrite replacement (the avg -> sum/count rewrite): {:?}",
+            results
+                .replacements
+                .iter()
+                .map(|(name, r)| (name.clone(), r.strategy.clone()))
+                .collect::<Vec<_>>()
+        );
+        // The avg rewrite's own strategy label must disambiguate correctly
+        // (not fall through to "Rollup", the other LogicalRewrite shape).
+        assert!(results
+            .replacements
+            .iter()
+            .any(|(_, r)| r.strategy == "AvgToSumOverCountStrategy"));
+
+        assert_eq!(results.post_graphs.len(), 2, "one post_graph per query");
+        for (name, graph) in &results.post_graphs {
+            assert!(
+                !graph.nodes.is_empty(),
+                "post_graph for {name:?} must not be empty"
+            );
+        }
+        let avg_post = &results
+            .post_graphs
+            .iter()
+            .find(|(name, _)| name == "avg")
+            .expect("avg post graph")
+            .1;
+        assert_eq!(
+            avg_post
+                .nodes
+                .iter()
+                .filter(|node| node.kind == "Scan")
+                .count(),
+            1,
+            "AVG's SUM and COUNT branches must retain their shared input as one DAG node"
+        );
+        let decisions: Vec<_> = results
+            .post_graphs
+            .iter()
+            .flat_map(|(_, graph)| graph.nodes.iter().filter_map(|node| node.decision.as_ref()))
+            .collect();
+        assert!(
+            !decisions.is_empty(),
+            "post_graph nodes must carry explicit strategy metadata"
+        );
+        for decision in decisions {
+            assert!(!decision.strategy.is_empty());
+            assert!(!decision.rationale.is_empty());
+        }
+    }
+
+    #[test]
+    fn workload_node_ids_make_smaller_topk_reuse_explicit() {
+        let small = lower_promql(
+            "topk(5, rate(http_requests_total[5m]))",
+            AccuracyTarget::Epsilon(0.01),
+        )
+        .unwrap();
+        let large = lower_promql(
+            "topk(10, rate(http_requests_total[5m]))",
+            AccuracyTarget::Epsilon(0.01),
+        )
+        .unwrap();
+        let lowered = vec![
+            (
+                "q3".into(),
+                "topk(5, rate(http_requests_total[5m]))".into(),
+                small,
+            ),
+            (
+                "q4".into(),
+                "topk(10, rate(http_requests_total[5m]))".into(),
+                large,
+            ),
+        ];
+        let mut results = run_post_asap(&lowered);
+        let mut graph_refs: Vec<_> = results
+            .post_graphs
+            .iter_mut()
+            .map(|(_, graph)| graph)
+            .collect();
+        assign_workload_node_ids(&mut graph_refs);
+
+        let q3 = &results
+            .post_graphs
+            .iter()
+            .find(|(name, _)| name == "q3")
+            .unwrap()
+            .1;
+        let q4 = &results
+            .post_graphs
+            .iter()
+            .find(|(name, _)| name == "q4")
+            .unwrap()
+            .1;
+        let q3_root = &q3.nodes[q3.root as usize];
+        assert_eq!(q3_root.label, "Limit(5)");
+        assert_eq!(
+            q3_root
+                .decision
+                .as_ref()
+                .map(|decision| decision.strategy.as_str()),
+            Some("TopKLimitReuseStrategy")
+        );
+        let q3_large = &q3.nodes[q3_root.children[0] as usize];
+        let q4_large = &q4.nodes[q4.root as usize];
+        assert_eq!(q3_large.label, "Limit(10)");
+        assert_eq!(q3_large.workload_node_id, q4_large.workload_node_id);
+    }
+
+    #[tokio::test]
+    async fn join_demo_explicitly_shares_metrics_scan_with_grouped_query() {
+        let cat = default_catalog();
+        let q1 = lower_sql(
+            "SELECT service, COUNT(*) FROM metrics GROUP BY service",
+            &cat,
+            AccuracyTarget::Exact,
+        )
+        .await
+        .unwrap();
+        let q6 = lower_sql(
+            "SELECT metrics.service, COUNT(*) FROM metrics JOIN hosts ON metrics.service = hosts.service GROUP BY metrics.service",
+            &cat,
+            AccuracyTarget::Exact,
+        )
+        .await
+        .unwrap();
+        let mut q1_graph = dag_export::export(&q1);
+        let mut q6_graph = dag_export::export(&q6);
+        assign_workload_node_ids(&mut [&mut q1_graph, &mut q6_graph]);
+        let q1_scan = q1_graph
+            .nodes
+            .iter()
+            .find(|node| node.label == "Scan(metrics)")
+            .unwrap();
+        let q6_scan = q6_graph
+            .nodes
+            .iter()
+            .find(|node| node.label == "Scan(metrics)")
+            .unwrap();
+        assert_eq!(q1_scan.workload_node_id, q6_scan.workload_node_id);
+        assert!(q6_graph.nodes.iter().any(|node| node.kind == "Join"));
+    }
+
+    /// Regression test for a real stack overflow found via manual testing
+    /// against real corpus queries (a `STDDEV_POP` aggregate, which — like
+    /// `AVG` — dispatches to `Implementation::PassThrough` with no
+    /// alternative strategy of its own, so its *only* candidate is
+    /// `keep_pre_asap`'s conservative fallback: `Replacement::Summary`
+    /// wrapping the *entire target* as `SummaryExpr::KeepPreAsap`).
+    /// `run_post_asap` must not treat that as a real winner: splicing it
+    /// into `export_post_asap` would recurse forever, since `find_winner`
+    /// re-checks every node inside a spliced `KeepPreAsap` payload by
+    /// design, and this payload structurally *is* the enclosing target — a
+    /// fresh `find_winner` call finds the identical winner again,
+    /// unconditionally, every time. Filtering this shape out of `winners`
+    /// (same "no-op candidate" concept `explanation.rs`'s own
+    /// `sketch_finding_reason` already excludes from being a finding) is
+    /// what keeps this terminating: this test's only assertion that matters
+    /// is that `run_post_asap` returns at all instead of overflowing the
+    /// stack.
+    #[tokio::test]
+    async fn post_asap_does_not_recurse_forever_on_a_trivial_keep_pre_asap_winner() {
+        let cat = default_catalog();
+        let stddev_query = lower_sql(
+            "SELECT STDDEV_POP(latency) FROM metrics",
+            &cat,
+            AccuracyTarget::Epsilon(0.01),
+        )
+        .await
+        .unwrap();
+        let lowered_queries = vec![(
+            "stddev".to_string(),
+            "SELECT STDDEV_POP(latency) FROM metrics".to_string(),
+            stddev_query,
+        )];
+
+        let results = run_post_asap(&lowered_queries);
+
+        // A trivial keep_pre_asap winner must be filtered before it ever
+        // becomes a flat `TargetReplacement` — there's no real replacement
+        // to report for a target with no alternative at all.
+        assert!(
+            results.replacements.is_empty(),
+            "a target whose only candidate is the trivial keep_pre_asap fallback \
+             shouldn't produce a flat replacement entry: {:?}",
+            results
+                .replacements
+                .iter()
+                .map(|(name, r)| (name.clone(), r.strategy.clone()))
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(results.post_graphs.len(), 1);
+        assert!(!results.post_graphs[0].1.nodes.is_empty());
+    }
 }
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 33e9f131..252d319a 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -41,8 +41,12 @@
 //! `asap_types` itself never constructs a `DagNote` — see [`DagNode::notes`]
 //! for the layering rule this keeps.
 
+use std::collections::HashMap;
+use std::rc::Rc;
+
 use serde::Serialize;
 
+use crate::post_asap::{SummaryExpr, SummaryNode};
 use crate::pre_asap::cse::{structural_hash, HashCache};
 use crate::pre_asap::query_expr::{QueryExpr, Source};
 
@@ -57,22 +61,51 @@ pub struct DagNode {
     /// Short human-readable summary for a node's collapsed on-graph label.
     pub label: String,
     pub detail: serde_json::Value,
+    /// Output schema carried by every exported node. Edge renderers use the
+    /// child node's schema as the schema flowing along child → consumer.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
     /// Child node ids, in the variant's field order (e.g. `Join` is
     /// `[left, right]`).
     pub children: Vec<u32>,
+    /// Explicit workload-wide identity assigned by a higher-level exporter.
+    /// Viewers use this field to union nodes and must not reconstruct a
+    /// structural signature client-side.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workload_node_id: Option<u32>,
     /// [`structural_hash`](crate::pre_asap::cse::structural_hash) of the
     /// subtree rooted at this node — the exact same function `cse`'s
     /// `InternTable` uses to bucket CSE candidates, so two nodes hash
     /// equally here iff they would land in the same `InternTable` bucket.
     /// See the module doc for what a hash match here does and doesn't
     /// guarantee.
-    pub hash: u64,
+    ///
+    /// `None` for the same reason `source_expr` is `None` — a post-ASAP-
+    /// originated node in an [`export_post_asap`] merged graph has no
+    /// `QueryExpr` to hash. Omitted from JSON entirely (rather than, say,
+    /// serialized as `0`) so a consumer's shared-subtree-by-hash pass can
+    /// tell "no hash" apart from a real hash that happens to collide with a
+    /// placeholder — `0` is a legal `structural_hash` output, not a safe
+    /// sentinel.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hash: Option<u64>,
     /// Exact source expression for in-process annotation matching. It is not
     /// part of the JSON format: callers first narrow by `hash`, then compare
     /// this value structurally to avoid treating a hash collision as node
     /// identity.
+    ///
+    /// `None` for a node with no corresponding pre-ASAP `QueryExpr` at all —
+    /// only possible for a post-ASAP-originated node inside a merged
+    /// [`export_post_asap`] graph (a `SummaryAgg`/`SummaryJoin`/… node has no
+    /// single `QueryExpr` it corresponds to). Every node [`export`] itself
+    /// produces is pre-ASAP by construction and always carries `Some`.
+    #[serde(skip)]
+    pub source_expr: Option<QueryExpr>,
+    /// In-process identity of the source `QueryExpr`. Unlike `source_expr`'s
+    /// structural value, this preserves an `Rc` child reached from multiple
+    /// parents so post-ASAP flattening can retain true DAG sharing.
     #[serde(skip)]
-    pub source_expr: QueryExpr,
+    source_ptr: Option<usize>,
     /// Arbitrary reporting-layer annotations for this node — e.g. why a
     /// replacement exists here. `asap_types` never populates this itself
     /// (it has no notion of a "replacement" at all — see the module doc's
@@ -82,6 +115,11 @@ pub struct DagNode {
     /// by default, so every existing [`export`] caller and test is unaffected.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub notes: Vec<DagNote>,
+    /// Explicit workload-level decision that produced or carried this node.
+    /// Present only in `post_graph`; consumers must read this rather than
+    /// infer strategy provenance from labels, hashes, or graph similarity.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub decision: Option<DagDecision>,
 }
 
 /// One reporting-layer annotation attached to a [`DagNode`] by a higher
@@ -102,6 +140,20 @@ pub struct DagNote {
     pub reason: String,
 }
 
+/// Self-contained explanation of a winning workload-level post-ASAP
+/// decision, serialized directly on every node it produced or carried.
+#[derive(Debug, Clone, Serialize)]
+pub struct DagDecision {
+    pub id: u32,
+    pub strategy: String,
+    pub rationale: String,
+    pub rank: usize,
+    pub cost: f64,
+    /// `replacement_root` for the node replacing the pre-ASAP target;
+    /// `replacement_region` for its generated or carried descendants.
+    pub role: &'static str,
+}
+
 /// One query's exported graph. `nodes[root as usize]` is the tree's root.
 #[derive(Debug, Clone, Serialize)]
 pub struct DagGraph {
@@ -120,6 +172,33 @@ pub struct NamedGraph {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub source: Option<String>,
     pub graph: DagGraph,
+    /// Concrete post-ASAP replacement sites discovered for this query — see
+    /// [`TargetReplacement`]. Always empty coming out of anything in this
+    /// module (same layering rule as [`DagNode::notes`]: `asap_types` never
+    /// runs `asap-aware-mapping`'s search itself); a higher layer populates
+    /// this after the fact, e.g. the `dag_export` devtools binary's
+    /// `--post-asap` flag. Omitted from the JSON entirely when empty, so
+    /// every existing producer/consumer of `NamedGraph` (in particular every
+    /// invocation of `dag_export` without `--post-asap`) keeps emitting and
+    /// parsing exactly the same shape it always has.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub replacements: Vec<TargetReplacement>,
+    /// One merged "whole query, but post-ASAP" graph — see
+    /// [`export_post_asap`] for how a higher layer builds this. Unlike
+    /// [`TargetReplacement::before`]/`::after` (small, self-contained
+    /// before/after pairs, one per independently-discovered replacement
+    /// site), this is a single flattened [`DagGraph`] spanning the whole
+    /// query: every node that has no winning replacement renders as an
+    /// ordinary pre-ASAP [`DagNode`] (same shape [`export`] itself
+    /// produces), and every node that does splices in its winning
+    /// candidate's shape instead — a rewritten [`QueryExpr`] subtree, or a
+    /// bound `SummaryNode` subtree, rendered inline in the very same node
+    /// list. `None` unless a higher layer explicitly built one (e.g. the
+    /// `dag_export` devtools binary's `--post-asap` flag); omitted from the
+    /// JSON entirely when absent, so every existing producer/consumer of
+    /// `NamedGraph` is unaffected.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub post_graph: Option<DagGraph>,
 }
 
 /// A batch of named queries — the shape the viewer's multi-query / compare
@@ -131,6 +210,303 @@ pub struct WorkloadGraph {
     pub queries: Vec<NamedGraph>,
 }
 
+// ── Post-ASAP replacement export — a second, layering-seam-shaped feature ──
+//
+// Everything below this point is the post-ASAP counterpart of the pre-ASAP
+// flattening above: [`export_summary`] flattens a `SummaryNode` the same way
+// [`export`] flattens a `QueryExpr`, and [`TargetReplacement`] is the
+// generic, crate-agnostic "one replacement site, before and after" shape a
+// higher layer (`asap-aware-mapping`, via the `dag_export` devtools binary's
+// `--post-asap` flag) populates after running its own search — the exact
+// same layering rule [`DagNode::notes`]'s doc above already states: this
+// module never runs `asap_aware_mapping::replacement::search_workload_with`
+// itself, never picks a "winning" candidate, and has no opinion on what a
+// `ReplacementProvenance` or a cost model even is. It only defines shapes
+// concrete and serializable enough for a higher layer to fill in, and for
+// `tools/dag-viewer` to render without needing to know anything about
+// `asap-aware-mapping`'s own vocabulary.
+//
+// A single whole-query "post-ASAP tree" isn't attempted here, and isn't
+// representable in the current type system either: `SummaryExpr` has no
+// variant letting a `SummaryNode` be embedded back inside a plain
+// `QueryExpr`'s child slot (`QueryExpr`'s own children are always
+// `Rc<QueryExpr>`, never `Rc<SummaryNode>`), so there is no way to splice a
+// post-ASAP binding back into its original pre-ASAP tree in place. Inventing
+// a bridge type for that is a real `asap_types`/`asap-aware-mapping` IR
+// design decision, well beyond what a devtools visualization export should
+// decide unilaterally. Instead, each independently-discovered replacement
+// target gets its own small, self-contained `before`/`after` pair — the
+// target's own pre-ASAP subtree, and either the winning `SummaryNode` or the
+// winning rewritten `QueryExpr`, both of which *are* fully representable
+// today via [`export`]/[`export_summary`] as-is.
+
+/// One flattened post-ASAP node — the [`SummaryExpr`] analogue of
+/// [`DagNode`]. `detail` holds this node's own scalar fields (the summarized
+/// column, the summary family, grouping strategy, sketch-query kind, …) —
+/// everything except its `SummaryNode` children, which live in `children`
+/// instead.
+///
+/// Unlike [`DagNode`], this carries no `hash`/`source_expr` pair: nothing in
+/// this module ever needs to re-identify a particular `SummaryDagNode` the
+/// way `DagNode::hash` lets a higher layer re-identify a pre-ASAP node (a
+/// `SummaryNode` is always freshly exported for exactly one
+/// [`TargetReplacementAfter::Summary`] site, never matched back against a
+/// separately-exported graph the way pre-ASAP notes are).
+///
+/// Several of `SummaryExpr`'s own fields (`SummaryFamilyType`,
+/// `GroupingStrategy`, `SketchQuery`) derive neither `Serialize` nor
+/// `Deserialize` in `asap_types::post_asap` — they carry no reporting
+/// obligation there, since nothing before this module ever needed to
+/// serialize a post-ASAP node. Rather than adding `Serialize` impls to
+/// `post_asap`'s own core types purely for this devtools-facing export (a
+/// change to that module's own public API contract, out of scope for a
+/// reporting concern), this module renders those particular fields into
+/// `detail` via their `Debug` formatting instead — human-readable, and
+/// sufficient for the display purpose `detail` exists for on every other
+/// node in this file (see [`DagNode::detail`]'s own doc), at the cost of
+/// those particular fields being opaque strings rather than structured JSON
+/// on the `SummaryDagNode` side of the export.
+#[derive(Debug, Clone, Serialize)]
+pub struct SummaryDagNode {
+    pub id: u32,
+    /// The `SummaryExpr` variant name (e.g. `"SummaryAgg"`).
+    pub kind: &'static str,
+    /// Short human-readable summary for a node's collapsed on-graph label.
+    pub label: String,
+    pub detail: serde_json::Value,
+    /// Child node ids, in the variant's field order (e.g. `SummaryJoin` is
+    /// `[outer, inner]`).
+    pub children: Vec<u32>,
+}
+
+/// One post-ASAP `SummaryNode` tree, flattened the same way [`DagGraph`]
+/// flattens a pre-ASAP `QueryExpr` tree.
+#[derive(Debug, Clone, Serialize)]
+pub struct SummaryDagGraph {
+    pub nodes: Vec<SummaryDagNode>,
+    pub root: u32,
+}
+
+/// Flatten a [`SummaryNode`] the same way [`export`] flattens a `QueryExpr`
+/// — post-order, one [`SummaryDagNode`] per [`SummaryExpr`] variant, no
+/// memoization of repeated `Rc<SummaryNode>` references (a shared
+/// sub-expression reachable through two parents is flattened twice, into two
+/// separate node entries — the same "this is a flattened tree view, not a
+/// pointer-identity-preserving graph" behavior [`build`] already has for
+/// `QueryExpr`).
+///
+/// A `KeepPreAsap(inner)` leaf embeds the *whole* pre-ASAP subtree beneath it
+/// as a nested [`DagGraph`] (via [`export(inner)`](export)) inside its own
+/// `detail` field (`{"pre_asap_subgraph": <DagGraph>}`) rather than trying to
+/// flatten it into this same node list — [`DagNode`] and [`SummaryDagNode`]
+/// are different types with different id spaces, so mixing them into one
+/// `Vec` isn't type-safe; nesting is. `label` for a `KeepPreAsap` node is
+/// `format!("KeepPreAsap({kind})")`, where `kind` is the inner subtree's own
+/// top-level `DagNode::kind`.
+pub fn export_summary(node: &SummaryNode) -> SummaryDagGraph {
+    let mut nodes = Vec::new();
+    let root = build_summary(node, &mut nodes);
+    SummaryDagGraph { nodes, root }
+}
+
+fn push_summary_node(
+    nodes: &mut Vec<SummaryDagNode>,
+    kind: &'static str,
+    label: String,
+    detail: serde_json::Value,
+    children: Vec<u32>,
+) -> u32 {
+    let id = nodes.len() as u32;
+    nodes.push(SummaryDagNode {
+        id,
+        kind,
+        label,
+        detail,
+        children,
+    });
+    id
+}
+
+/// A short, human-readable label for a [`crate::post_asap::SummaryFamilyType`]
+/// (e.g. `"Sketch(Kll)"`, `"ExactAggregate(Sum)"`) — for
+/// [`SummaryDagNode::label`] text on a `SummaryAgg`/`SummaryJoin` node. Not
+/// exhaustive prose (mirrors `asap_aware_mapping::replacement::describe_intent`'s
+/// own "this is a label, not a decision" stance) — every variant is covered,
+/// but via `Debug` for the inner kind rather than hand-written prose per
+/// algorithm.
+fn family_label(family: &crate::post_asap::SummaryFamilyType) -> String {
+    use crate::post_asap::SummaryFamilyType;
+    match family {
+        SummaryFamilyType::Plain(dtype) => format!("Plain({dtype:?})"),
+        SummaryFamilyType::ExactAggregate(kind, _) => format!("ExactAggregate({kind:?})"),
+        SummaryFamilyType::Sketch(kind, _grouping) => format!("Sketch({:?})", kind.algorithm()),
+        SummaryFamilyType::Sample(kind, _) => format!("Sample({kind:?})"),
+        SummaryFamilyType::Wavelet(kind, _) => format!("Wavelet({kind:?})"),
+        SummaryFamilyType::StatModel(kind, _) => format!("StatModel({kind:?})"),
+    }
+}
+
+/// `(kind, label, detail)` for every [`SummaryExpr`] variant *except*
+/// [`SummaryExpr::KeepPreAsap`] — that variant has no `SummaryDagNode`/
+/// `DagNode` of its own (see [`build_summary`]/[`build_summary_hybrid`], its
+/// only two callers, both of which special-case it before ever reaching
+/// this function). Factored out so [`build_summary`] (nests a `KeepPreAsap`
+/// leaf's pre-ASAP subtree as its own [`SummaryDagGraph`]) and
+/// [`build_summary_hybrid`] (splices that same subtree directly into a
+/// shared [`DagGraph`] node list — see [`export_post_asap`]) can't drift
+/// apart on how every *other* variant's own shape is described, since
+/// nothing about that description differs between the two.
+fn summary_shape(expr: &SummaryExpr) -> (&'static str, String, serde_json::Value) {
+    match expr {
+        SummaryExpr::KeepPreAsap(_) => {
+            unreachable!("summary_shape's callers special-case KeepPreAsap before calling it")
+        }
+        SummaryExpr::SummaryAgg {
+            family,
+            col,
+            reduction,
+            grouping,
+            ..
+        } => {
+            let label = format!("SummaryAgg({})", family_label(family));
+            let detail = serde_json::json!({
+                "family": format!("{family:?}"),
+                "col": col,
+                "reduction": reduction,
+                "grouping": format!("{grouping:?}"),
+            });
+            ("SummaryAgg", label, detail)
+        }
+        SummaryExpr::SummaryJoin { key, family, .. } => {
+            let label = format!("SummaryJoin({})", family_label(family));
+            let detail = serde_json::json!({
+                "key": key,
+                "family": format!("{family:?}"),
+            });
+            ("SummaryJoin", label, detail)
+        }
+        SummaryExpr::SummarySubtract { .. } => (
+            "SummarySubtract",
+            "SummarySubtract".into(),
+            serde_json::json!({}),
+        ),
+        SummaryExpr::SummaryDelete { key, .. } => {
+            let detail = serde_json::json!({ "key": key });
+            ("SummaryDelete", "SummaryDelete".into(), detail)
+        }
+        SummaryExpr::SummaryEstimate { query, .. } => {
+            let label = format!("SummaryEstimate({query:?})");
+            let detail = serde_json::json!({ "query": format!("{query:?}") });
+            ("SummaryEstimate", label, detail)
+        }
+        SummaryExpr::SummaryMerge { children } => {
+            let label = format!("SummaryMerge({} children)", children.len());
+            ("SummaryMerge", label, serde_json::json!({}))
+        }
+    }
+}
+
+/// `expr`'s own `Rc<SummaryNode>` children, in the variant's field order
+/// (e.g. `SummaryJoin` is `[outer, inner]`) — empty for
+/// [`SummaryExpr::KeepPreAsap`], which has no `SummaryNode` children at all
+/// (only a boxed pre-ASAP `QueryExpr`). Shared by [`build_summary`] and
+/// [`build_summary_hybrid`] for the same reason [`summary_shape`] is.
+fn summary_children(expr: &SummaryExpr) -> Vec<&Rc<SummaryNode>> {
+    match expr {
+        SummaryExpr::KeepPreAsap(_) => vec![],
+        SummaryExpr::SummaryAgg { child, .. } => vec![child],
+        SummaryExpr::SummaryJoin { outer, inner, .. } => vec![outer, inner],
+        SummaryExpr::SummarySubtract { left, right } => vec![left, right],
+        SummaryExpr::SummaryDelete { summary_input, .. } => vec![summary_input],
+        SummaryExpr::SummaryEstimate { summary_input, .. } => vec![summary_input],
+        SummaryExpr::SummaryMerge { children } => children.iter().collect(),
+    }
+}
+
+/// Recursively flatten `node`, appending [`SummaryDagNode`]s to `nodes` in
+/// post-order (children pushed before their parent), and return the pushed
+/// root's id. Exhaustive over every [`SummaryExpr`] variant, matching this
+/// file's own exhaustive style for `QueryExpr` in [`build`].
+fn build_summary(node: &SummaryNode, nodes: &mut Vec<SummaryDagNode>) -> u32 {
+    if let SummaryExpr::KeepPreAsap(inner) = &node.expr {
+        let pre_asap_subgraph = export(inner);
+        let inner_kind = pre_asap_subgraph.nodes[pre_asap_subgraph.root as usize].kind;
+        let label = format!("KeepPreAsap({inner_kind})");
+        let detail = serde_json::json!({ "pre_asap_subgraph": pre_asap_subgraph });
+        return push_summary_node(nodes, "KeepPreAsap", label, detail, vec![]);
+    }
+    let children: Vec<u32> = summary_children(&node.expr)
+        .into_iter()
+        .map(|child| build_summary(child, nodes))
+        .collect();
+    let (kind, label, detail) = summary_shape(&node.expr);
+    push_summary_node(nodes, kind, label, detail, children)
+}
+
+/// One replacement site a higher layer (the `dag_export` binary) found by
+/// running `asap_aware_mapping::replacement::search_workload_with` +
+/// `PlanSpace::cost_sorted` and picking the best-ranked candidate for one
+/// `MemoGroup` — `asap_types` never runs that search itself (same layering
+/// rule as [`DagNote`]: this crate defines the shape, a higher crate
+/// populates it).
+#[derive(Debug, Clone, Serialize)]
+pub struct TargetReplacement {
+    /// Stable id of this workload-level winning decision. Nodes in
+    /// [`NamedGraph::post_graph`] produced by this decision carry the same id,
+    /// so renderers can explain a clicked post-ASAP node without guessing by
+    /// label, hash, or graph shape.
+    pub decision_id: u32,
+    /// Id of the [`DagNode`] (in this query's own `graph.nodes`, i.e. the
+    /// [`NamedGraph`] this `TargetReplacement` is attached to) this
+    /// replacement's `before` subtree is rooted at.
+    pub target_pre_id: u32,
+    /// Human label for which strategy proposed the winning candidate —
+    /// e.g. `"Sketch"` / `"HydraGrouping"` / `"SharedSubtree"` /
+    /// `"AvgToSumCountRewrite"` / `"Rollup"`. The higher layer derives this from
+    /// `ReplacementProvenance` plus which strategy's shape actually
+    /// produced the winning candidate; `asap_types` has no opinion on the
+    /// string values here at all — purely a display label.
+    pub strategy: String,
+    /// The winning candidate's own human-readable rationale (reused
+    /// verbatim from `ReplacementSubDAG::rationale` by the higher layer,
+    /// not re-derived here).
+    pub rationale: String,
+    /// This candidate's rank among its `MemoGroup`'s alternatives after
+    /// `PlanSpace::cost_sorted` (`0` = best). Exposed so a renderer can show
+    /// "this was the best of N candidates" without re-deriving the ranking.
+    pub rank: usize,
+    /// This candidate's own estimated cost, straight off
+    /// `RankedGroup::costs` — `f64::NAN` whenever the plugged-in cost model
+    /// doesn't estimate a numeric cost for this candidate shape (see that
+    /// field's own doc upstream).
+    pub cost: f64,
+    /// The target's own pre-ASAP subtree, before replacement — literally
+    /// `export(target)` for the `MemoGroup`'s own `target`, reused as-is.
+    pub before: DagGraph,
+    pub after: TargetReplacementAfter,
+}
+
+/// What a [`TargetReplacement`] became — either a genuine post-ASAP binding
+/// or a still-pre-ASAP-shaped structural rewrite, mirroring
+/// `asap_aware_mapping::replacement::Replacement`'s own two variants.
+///
+/// Serializes as `{"kind": "Summary"|"Rewrite", "graph": {...}}` (serde's
+/// adjacently-tagged representation for a `#[serde(tag = "kind", content =
+/// "graph")]` enum) — this exact shape is a cross-team contract with
+/// `tools/dag-viewer`'s fixture data, so it isn't incidental: changing it
+/// needs coordinating with that side, not just a local refactor here.
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "kind", content = "graph")]
+pub enum TargetReplacementAfter {
+    /// A `Replacement::Summary` candidate — a genuine post-ASAP binding.
+    Summary(SummaryDagGraph),
+    /// A `Replacement::Rewrite` candidate — still pre-ASAP shaped (CSE
+    /// share/recompute, `AvgToSumOverCountStrategy`, and `RollupStrategy`
+    /// all produce this kind), so this reuses [`DagGraph`]/[`export`] too,
+    /// not a new type.
+    Rewrite(DagGraph),
+}
+
 /// Flatten `expr` into a [`DagGraph`].
 pub fn export(expr: &QueryExpr) -> DagGraph {
     let mut nodes = Vec::new();
@@ -139,10 +515,120 @@ pub fn export(expr: &QueryExpr) -> DagGraph {
     // real work across this pass instead of re-walking an already-hashed
     // shared descendant once per node that references it.
     let mut cache = HashCache::new();
-    let root = build(expr, &mut nodes, &mut cache);
+    // No substitution: an ordinary pre-ASAP export never splices anything
+    // in — see `build`'s own doc for why it always takes a `find_winner`
+    // callback regardless (so `export_post_asap` can share this exact
+    // per-variant traversal instead of duplicating it).
+    let root = build(expr, &mut nodes, &mut cache, &mut |_| None);
     DagGraph { nodes, root }
 }
 
+/// What a higher layer found for one specific pre-ASAP node when building a
+/// merged post-ASAP graph via [`export_post_asap`] — see that function's own
+/// doc for the full design. `asap_types` has no opinion on *how* this is
+/// decided (that's `asap_aware_mapping::replacement::search_workload_with` +
+/// `PlanSpace::cost_sorted`'s job, a higher layer, exactly the layering rule
+/// [`DagNode::notes`] already states); it only defines the shape a decision
+/// comes back in.
+#[derive(Debug, Clone)]
+pub enum PostAsapSubstitution {
+    /// This exact node has a winning `Replacement::Rewrite` — keep building
+    /// from `.0` instead of the original node. Still pre-ASAP shaped, so
+    /// [`build`] renders it via the same ordinary `DagNode` path — see
+    /// [`build`]'s own doc for why `.0`'s own top level is rendered without
+    /// re-querying `find_winner` on it (its descendants still are).
+    Rewrite {
+        replacement: Rc<QueryExpr>,
+        decision: DagDecision,
+    },
+    /// This exact node has a winning `Replacement::Summary` — switch to
+    /// rendering `.0`'s bound `SummaryNode` shape from here down, via
+    /// [`build_summary_hybrid`].
+    Summary {
+        replacement: Rc<SummaryNode>,
+        decision: DagDecision,
+    },
+}
+
+/// Build one merged "whole query, but post-ASAP" [`DagGraph`] by walking
+/// `root`'s ordinary pre-ASAP shape and, at every node, asking `find_winner`
+/// whether *that exact node* has a winning replacement — if so, splicing
+/// the replacement's own shape in at that position instead, in the very
+/// same flattened node list (not a nested sub-graph the way
+/// [`TargetReplacement::before`]/`::after` — small, independent, per-site
+/// before/after pairs — already do; see this file's "Post-ASAP replacement
+/// export" section doc for why *that* design doesn't attempt a single
+/// whole-query composite, and why this one can: this is a synthetic
+/// id/edge list, the same kind of thing [`DagGraph`] already is for the
+/// pre-ASAP side, not a real `QueryExpr`/`SummaryNode` value with a type
+/// system to satisfy).
+///
+/// `find_winner` is the whole layering seam: `asap_types` never runs
+/// `asap_aware_mapping::replacement::search_workload_with` or
+/// `PlanSpace::cost_sorted` itself, and has no idea what a `MemoGroup` or a
+/// `ReplacementProvenance` is — it only asks, for one node at a time, "did a
+/// higher layer already decide something for you?" A caller (e.g. the
+/// `dag_export` devtools binary) builds this closure once per workload
+/// search, over whatever hash/structural-equality lookup it already needs
+/// for [`TargetReplacement`] discovery, and passes it in here unchanged.
+///
+/// `find_winner` is deliberately consulted only once per node, at the
+/// moment [`build`] first reaches it — **not** re-consulted on a
+/// substitution's own immediate top level (only on that substitution's
+/// *descendants*, which get an ordinary fresh call same as any other node).
+/// This matters for correctness, not just efficiency:
+/// `SharedSubtreeStrategy`'s own "build once and share" candidate is
+/// `Replacement::Rewrite(Rc::clone(target))` — literally the *same* value
+/// as the target it's a candidate for. Re-querying `find_winner` on that
+/// candidate's own top level would find the identical group and its
+/// identical winning candidate again, recursing forever. Skipping the
+/// re-query at exactly that one level is what makes this termination-safe
+/// for every registered strategy, not just the ones that happen not to
+/// return the target itself as a candidate.
+pub fn export_post_asap(
+    root: &QueryExpr,
+    find_winner: &mut dyn FnMut(&QueryExpr) -> Option<PostAsapSubstitution>,
+) -> DagGraph {
+    let mut nodes = Vec::new();
+    let mut cache = HashCache::new();
+    let root_id = build(root, &mut nodes, &mut cache, find_winner);
+    deduplicate_pointer_shared_nodes(nodes, root_id)
+}
+
+fn deduplicate_pointer_shared_nodes(nodes: Vec<DagNode>, root: u32) -> DagGraph {
+    let mut by_source_ptr = HashMap::<usize, u32>::new();
+    let mut old_to_new = vec![0_u32; nodes.len()];
+    let mut deduplicated = Vec::with_capacity(nodes.len());
+
+    for mut node in nodes {
+        node.children = node
+            .children
+            .into_iter()
+            .map(|child| old_to_new[child as usize])
+            .collect();
+        if let Some(existing) = node
+            .source_ptr
+            .and_then(|source_ptr| by_source_ptr.get(&source_ptr).copied())
+        {
+            old_to_new[node.id as usize] = existing;
+            continue;
+        }
+        let old_id = node.id;
+        let new_id = deduplicated.len() as u32;
+        node.id = new_id;
+        if let Some(source_ptr) = node.source_ptr {
+            by_source_ptr.insert(source_ptr, new_id);
+        }
+        old_to_new[old_id as usize] = new_id;
+        deduplicated.push(node);
+    }
+
+    DagGraph {
+        nodes: deduplicated,
+        root: old_to_new[root as usize],
+    }
+}
+
 /// Push one flattened node for `expr`. `expr` is the *whole* subtree this
 /// node represents (not just its own fields) — `hash` is
 /// [`structural_hash(expr)`](structural_hash), the identical function and
@@ -159,20 +645,103 @@ fn push_node(
     children: Vec<u32>,
 ) -> u32 {
     let id = nodes.len() as u32;
-    let hash = structural_hash(expr, cache);
+    let hash = Some(structural_hash(expr, cache));
     nodes.push(DagNode {
         id,
         kind,
         label,
         detail,
+        schema: expr
+            .output_schema()
+            .ok()
+            .and_then(|schema| serde_json::to_value(schema).ok()),
         children,
+        workload_node_id: None,
         hash,
-        source_expr: expr.clone(),
+        source_expr: Some(expr.clone()),
+        source_ptr: Some(expr as *const QueryExpr as usize),
         notes: Vec::new(),
+        decision: None,
     });
     id
 }
 
+/// Push one flattened node with no corresponding pre-ASAP `QueryExpr` at
+/// all — a post-ASAP-originated node inside [`export_post_asap`]'s merged
+/// graph (a `SummaryAgg`/`SummaryJoin`/… node, via [`build_summary_hybrid`]).
+/// `hash`/`source_expr`-based re-identification (see [`DagNode::hash`]'s own
+/// doc) has no meaning for a node with no `QueryExpr` behind it, so this
+/// pushes a fixed placeholder hash (`0`) and `source_expr: None` rather than
+/// inventing a hash over `SummaryExpr` (which, unlike `QueryExpr`, has no
+/// [`structural_hash`]-equivalent function at all — see [`SummaryDagNode`]'s
+/// own doc on why `SummaryExpr`'s fields don't even derive `Hash`/`PartialEq`
+/// consistently enough to build one).
+fn push_summary_originated_node(
+    nodes: &mut Vec<DagNode>,
+    kind: &'static str,
+    label: String,
+    detail: serde_json::Value,
+    children: Vec<u32>,
+) -> u32 {
+    let id = nodes.len() as u32;
+    nodes.push(DagNode {
+        id,
+        kind,
+        label,
+        detail,
+        schema: None,
+        children,
+        workload_node_id: None,
+        hash: None,
+        source_expr: None,
+        source_ptr: None,
+        notes: Vec::new(),
+        decision: None,
+    });
+    id
+}
+
+/// The [`build_summary`]/[`build_summary_hybrid`] counterpart of [`build`]
+/// for a bound [`SummaryNode`] reached while building
+/// [`export_post_asap`]'s merged graph: appends into the *same* `nodes:
+/// Vec<DagNode>` list `build` itself is filling, instead of a separate
+/// [`SummaryDagGraph`]. A `KeepPreAsap(inner)` leaf recurses back into
+/// [`build`] on `inner` (the general pre-ASAP entry, `find_winner` included)
+/// rather than nesting a `{"pre_asap_subgraph": ...}` blob the way
+/// [`build_summary`] does — so the merged graph reads as one seamless graph
+/// with no dead ends, and so a target reachable underneath a `KeepPreAsap`
+/// wrapper (a nested aggregate a strategy independently found a
+/// replacement for, say) still gets spliced in correctly.
+fn build_summary_hybrid(
+    node: &SummaryNode,
+    nodes: &mut Vec<DagNode>,
+    cache: &mut HashCache,
+    find_winner: &mut dyn FnMut(&QueryExpr) -> Option<PostAsapSubstitution>,
+) -> u32 {
+    if let SummaryExpr::KeepPreAsap(inner) = &node.expr {
+        return build(inner, nodes, cache, find_winner);
+    }
+    let children: Vec<u32> = summary_children(&node.expr)
+        .into_iter()
+        .map(|child| build_summary_hybrid(child, nodes, cache, find_winner))
+        .collect();
+    let (kind, label, detail) = summary_shape(&node.expr);
+    let id = push_summary_originated_node(nodes, kind, label, detail, children);
+    nodes[id as usize].schema = Some(summary_schema_json(&node.schema));
+    id
+}
+
+fn summary_schema_json(schema: &crate::post_asap::SummarySchema) -> serde_json::Value {
+    serde_json::json!({
+        "fields": schema.fields.iter().map(|field| serde_json::json!({
+            "name": field.name,
+            "dtype": format!("{:?}", field.dtype),
+            "nullable": field.nullable,
+        })).collect::<Vec<_>>(),
+        "time_index": schema.time_index,
+    })
+}
+
 fn source_label(source: &Source) -> String {
     match source {
         Source::Table { table_ref } => table_ref.clone(),
@@ -190,7 +759,79 @@ fn source_label(source: &Source) -> String {
 /// serializes it as opaque `detail` JSON via `Predicate`/`ProjectItem`/
 /// `AggIntent`'s own `Serialize` impl, same as before the merge — a scalar
 /// subtree was never a separate DAG node, so this doesn't change that.
-fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u32 {
+///
+/// `find_winner` is [`export_post_asap`]'s substitution seam, threaded
+/// through every recursive call (including [`export`]'s own, which always
+/// passes a closure that returns `None`) so both entry points share this
+/// exact traversal instead of maintaining two copies of it. `build` itself
+/// only ever calls `find_winner` once, right here at the top, before
+/// dispatching into the ordinary per-variant match below — see
+/// [`export_post_asap`]'s own doc for why a substitution's own immediate
+/// result is rendered via that match directly (recursing into its children
+/// through `build` again, so *they* still get a fresh `find_winner` call)
+/// rather than by looping back through this check a second time.
+fn build(
+    expr: &QueryExpr,
+    nodes: &mut Vec<DagNode>,
+    cache: &mut HashCache,
+    find_winner: &mut dyn FnMut(&QueryExpr) -> Option<PostAsapSubstitution>,
+) -> u32 {
+    match find_winner(expr) {
+        Some(PostAsapSubstitution::Rewrite {
+            replacement,
+            decision,
+        }) => {
+            let first = nodes.len();
+            let root = build_no_recheck(&replacement, nodes, cache, find_winner);
+            for node in &mut nodes[first..] {
+                if node.decision.is_none() {
+                    let mut node_decision = decision.clone();
+                    node_decision.role = if node.id == root {
+                        "replacement_root"
+                    } else {
+                        "replacement_region"
+                    };
+                    node.decision = Some(node_decision);
+                }
+            }
+            return root;
+        }
+        Some(PostAsapSubstitution::Summary {
+            replacement,
+            decision,
+        }) => {
+            let first = nodes.len();
+            let root = build_summary_hybrid(&replacement, nodes, cache, find_winner);
+            for node in &mut nodes[first..] {
+                if node.decision.is_none() {
+                    let mut node_decision = decision.clone();
+                    node_decision.role = if node.id == root {
+                        "replacement_root"
+                    } else {
+                        "replacement_region"
+                    };
+                    node.decision = Some(node_decision);
+                }
+            }
+            return root;
+        }
+        None => {}
+    }
+    build_no_recheck(expr, nodes, cache, find_winner)
+}
+
+/// The actual per-variant match [`build`] dispatches to once it has decided
+/// (by consulting `find_winner` exactly once) which `QueryExpr` value to
+/// render at this position — either `expr` itself (unchanged), or a winning
+/// `Replacement::Rewrite`'s own target. Every recursive call here goes back
+/// through [`build`] (not this function), so every child gets its own fresh
+/// `find_winner` query.
+fn build_no_recheck(
+    expr: &QueryExpr,
+    nodes: &mut Vec<DagNode>,
+    cache: &mut HashCache,
+    find_winner: &mut dyn FnMut(&QueryExpr) -> Option<PostAsapSubstitution>,
+) -> u32 {
     match expr {
         QueryExpr::Scan {
             source,
@@ -241,7 +882,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             vec![],
         ),
         QueryExpr::PromqlVectorFromScalar(child) => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             push_node(
                 nodes,
                 expr,
@@ -253,7 +894,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::PromqlScalarFromVector(child) => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             push_node(
                 nodes,
                 expr,
@@ -265,7 +906,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::PromqlRelabel { dst, value, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "dst": dst, "value": value });
             push_node(
                 nodes,
@@ -278,7 +919,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::PromqlInfoEnrich { selector, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "selector": selector });
             push_node(
                 nodes,
@@ -291,7 +932,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::PromqlSeriesSample { by, kind, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "by": by, "kind": kind });
             push_node(
                 nodes,
@@ -304,7 +945,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::Filter { pred, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "pred": pred });
             push_node(
                 nodes,
@@ -321,7 +962,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             qualifier,
             child,
         } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "cols": cols, "qualifier": qualifier });
             push_node(
                 nodes,
@@ -340,7 +981,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             having,
             child,
         } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({
                 "reduction": reduction,
                 "measures": measures,
@@ -358,7 +999,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::Dedup { cols, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "cols": cols });
             push_node(
                 nodes,
@@ -371,7 +1012,10 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::Concat { children } => {
-            let ids: Vec<u32> = children.iter().map(|c| build(c, nodes, cache)).collect();
+            let ids: Vec<u32> = children
+                .iter()
+                .map(|c| build(c, nodes, cache, find_winner))
+                .collect();
             let label = format!("Concat({} branches)", ids.len());
             push_node(
                 nodes,
@@ -389,8 +1033,8 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             left,
             right,
         } => {
-            let l = build(left, nodes, cache);
-            let r = build(right, nodes, cache);
+            let l = build(left, nodes, cache, find_winner);
+            let r = build(right, nodes, cache, find_winner);
             let detail = serde_json::json!({ "kind": kind, "pred": pred });
             push_node(
                 nodes,
@@ -408,8 +1052,8 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             left,
             right,
         } => {
-            let l = build(left, nodes, cache);
-            let r = build(right, nodes, cache);
+            let l = build(left, nodes, cache, find_winner);
+            let r = build(right, nodes, cache, find_winner);
             let detail = serde_json::json!({ "kind": kind, "all": all });
             push_node(
                 nodes,
@@ -426,7 +1070,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             partition_by,
             child,
         } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "keys": keys, "partition_by": partition_by });
             push_node(
                 nodes,
@@ -439,7 +1083,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::Limit { n, offset, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "n": n, "offset": offset });
             push_node(
                 nodes,
@@ -456,7 +1100,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             resolution,
             child,
         } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "range": range, "resolution": resolution });
             push_node(
                 nodes,
@@ -469,7 +1113,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::TimeRange { range, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "range": range });
             push_node(
                 nodes,
@@ -482,7 +1126,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             )
         }
         QueryExpr::TimeShift { shift, child } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({ "shift": shift });
             push_node(
                 nodes,
@@ -503,7 +1147,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             output_name,
             child,
         } => {
-            let c = build(child, nodes, cache);
+            let c = build(child, nodes, cache, find_winner);
             let detail = serde_json::json!({
                 "func": func,
                 "args": args,
@@ -528,8 +1172,8 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             rhs,
             vector_match,
         } => {
-            let l = build(lhs, nodes, cache);
-            let r = build(rhs, nodes, cache);
+            let l = build(lhs, nodes, cache, find_winner);
+            let r = build(rhs, nodes, cache, find_winner);
             let detail = serde_json::json!({ "op": op.to_string(), "vector_match": vector_match });
             push_node(
                 nodes,
@@ -598,20 +1242,24 @@ mod tests {
         assert!(graph.nodes[0].children.is_empty());
     }
 
-    /// `export` itself never populates `notes` — that's a higher layer's
-    /// job (see the module doc) — and an empty `notes` must not appear in
-    /// the serialized JSON at all, so every existing consumer of `export`'s
-    /// output (in particular `tools/dag-viewer`, which predates this field)
-    /// keeps parsing the same shape it always has.
+    /// `export` itself never populates higher-layer annotations. Empty
+    /// annotations must not appear in serialized JSON, so ordinary (non-ASAP)
+    /// exports retain their existing shape.
     #[test]
-    fn export_never_populates_notes_and_it_is_omitted_from_json() {
+    fn export_omits_empty_higher_layer_annotations() {
         let graph = export(&scan("metrics", value_col()));
         assert!(graph.nodes[0].notes.is_empty());
+        assert!(graph.nodes[0].decision.is_none());
+        assert!(graph.nodes[0].schema.is_some());
         let json = serde_json::to_string(&graph.nodes[0]).unwrap();
         assert!(
             !json.contains("notes"),
             "empty `notes` must be skipped, not serialized as `[]`: {json}"
         );
+        assert!(
+            !json.contains("decision"),
+            "empty `decision` must be skipped, not serialized as `null`: {json}"
+        );
     }
 
     #[test]
@@ -726,7 +1374,7 @@ mod tests {
         let graph = export(&leaf);
         assert_eq!(
             graph.nodes[graph.root as usize].hash,
-            structural_hash(&leaf, &mut HashCache::new()),
+            Some(structural_hash(&leaf, &mut HashCache::new())),
             "dag_export's root hash must equal cse::structural_hash(&leaf, &mut HashCache::new()) directly"
         );
     }
@@ -754,7 +1402,7 @@ mod tests {
         let graph = export(&root);
         assert_eq!(
             graph.nodes[graph.root as usize].hash,
-            structural_hash(&root, &mut HashCache::new()),
+            Some(structural_hash(&root, &mut HashCache::new())),
             "Filter root hash must match cse::structural_hash(&root, &mut HashCache::new())"
         );
 
@@ -762,7 +1410,7 @@ mod tests {
         let agg_node = &graph.nodes[filter.children[0] as usize];
         assert_eq!(
             agg_node.hash,
-            structural_hash(&agg, &mut HashCache::new()),
+            Some(structural_hash(&agg, &mut HashCache::new())),
             "the exported Aggregate node's hash must match cse::structural_hash \
              on the Aggregate subtree it represents, not just the root"
         );
diff --git a/crates/types/src/post_asap/expr.rs b/crates/types/src/post_asap/expr.rs
index 1111f5d2..2402b22c 100644
--- a/crates/types/src/post_asap/expr.rs
+++ b/crates/types/src/post_asap/expr.rs
@@ -23,7 +23,7 @@ pub struct SummaryNode {
 /// Sketch-bound IR produced by post-ASAP binding rules. Those rules
 /// selectively replace logical aggregates and joins in the pre-ASAP
 /// `QueryExpr` with their summary-bound counterparts; everything not
-/// rewritten passes through as `KeepPreAsap(Box<QueryExpr>)`.
+/// rewritten passes through as `KeepPreAsap(Rc<QueryExpr>)`.
 ///
 /// Traversing from the root node yields a DAG; shared sub-expressions appear
 /// as multiple `Rc` references to the same `SummaryNode`.
@@ -33,7 +33,7 @@ pub enum SummaryExpr {
     /// post-ASAP form (e.g. `Filter`, `Project`, `Sort`). Output schema is
     /// the inner node's schema, lifted to `SummarySchema` with all fields as
     /// `SummaryFamilyType::Plain`.
-    KeepPreAsap(Box<QueryExpr>),
+    KeepPreAsap(Rc<QueryExpr>),
 
     /// Summary aggregation. Post-ASAP binding chose `family` — which
     /// summary family (exact accumulator, sketch, sample, wavelet, or
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index b952fac7..1c3fd694 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -1,263 +1,105 @@
-# ASAP query DAG viewer
+# ASAP Pre/Post-ASAP DAG viewer
 
-Interactive viewer for the pre-ASAP query IR (`QueryExpr`), for manual IR
-review/debugging, eyeballing common shapes across a corpus, and spotting shared sub-DAGs across queries.
+The viewer has one visualization mode: **Pre/Post-ASAP**.
 
-## Generate a graph
+- Select one query to see that query's complete pre-ASAP and post-ASAP DAGs.
+- Select multiple queries to see two workload-union DAGs: one pre-ASAP union
+  and one post-ASAP union. Nodes with the same exporter-assigned workload
+  identity are collapsed while query roots and ownership are retained.
+- Pre-ASAP nodes show only their original IR content.
+- Post-ASAP nodes show their translated IR content and the explicit planner
+  decision carried by that node.
+- Click any edge to inspect its schema, source and target nodes, and how the
+  target operation derives its output schema in the details panel.
+- The details panel shows the selected workload's bound table/metric schemas
+  and can be resized by dragging its left edge.
 
-```sh
-cargo run -p asap-devtools --bin dag_export -- \
-  --sql "SELECT service, COUNT(*) FROM metrics GROUP BY service" --name q1 \
-  --sql "SELECT service, AVG(latency) FROM metrics GROUP BY service" --name q2 \
-  --promql "topk(5, rate(http_requests_total[5m]))" --name q3 \
-  > /tmp/dag.json
-```
-
-`--name` is optional (defaults to `q<n>`). Repeat `--sql`/`--promql` for as
-many queries as you want in one file — they all land in one `WorkloadGraph`.
-You can also load several separate JSON files into the viewer at once (drag
-multiple files, or run the exporter more than once); their queries are merged.
-Add `--epsilon <f64>` to also populate `notes` with sketch-approximation
-findings — see "Replacement explanations (`notes`)" below.
-
-`--sql` queries lower against a fixed demo schema, selected with `--catalog
-<name>` (default `metrics`, the built-in `metrics`/`hosts` schema this tool
-has always used). Pass `--catalog packets` or `--catalog netflow` to instead
-match the tables in `frontend-sql/tests/data_quality_check/data/synthetic_packet_trace_queries.sql`
-or `frontend-sql/tests/netflow/data/netflow.sql`, so those in-repo corpora can
-be exported query-for-query instead of only against the built-in schema.
-`--promql` queries ignore `--catalog` (PromQL has no table schema).
-
-## Open the viewer
-
-This is a static page with no server or build step — open `index.html`
-directly in a browser (`file://tools/dag-viewer/index.html`), or serve the
-directory (`python3 -m http.server` from here) if your browser blocks local
-JS module loads. Drop the generated JSON onto the page, or use the file
-picker.
+There are no separate Single, Compare, or Union modes.
 
-- Click a node to inspect its full field detail in the side panel.
-- Multiple loaded queries show up as tabs across the top ("Single" mode,
-  the default). Nodes that are structurally identical to a node in *another*
-  loaded query get a blue ring — toggle this off with "Highlight shared
-  subtrees".
-- Each query's root node (its final output) gets a small red badge.
-- A node whose `notes` array is non-empty gets a small colored badge in the
-  bottom-right corner — click the node to see each note's kind and reason in
-  the side panel. See "Replacement explanations (`notes`)" below.
-- Node color/icon is driven by category — see the legend in the side panel,
-  or `node-style.js` for the underlying `kind -> category` table.
-- Once two or more queries are loaded, switch to **Compare** or **Union**
-  mode (buttons next to the drop zone) to see them together instead of one
-  at a time — see below.
+## Interactive query editor
 
-## Render a standalone page from Python
-
-`index.html` needs a browser attached — dropping a file onto it, or a
-sibling `dag.json` it can `fetch()`. Neither works if you're generating a
-graph from an environment with no browser to look at it in (piped over SSH,
-a CI job, an agent session): `render.py` bakes a `dag_export` JSON straight
-into a single portable HTML file instead, with the query data and every
-vendored script inlined — open the output directly, nothing else to fetch:
+From the repository root:
 
 ```sh
-cargo run -p asap-devtools --bin dag_export -- --sql "..." --name q1 \
-  | python3 tools/dag-viewer/render.py -o rendered.html
-
-# or from files already on disk, opening straight into Union mode:
-python3 tools/dag-viewer/render.py dag1.json dag2.json -o rendered.html --mode union
+python3 tools/dag-viewer/server.py
 ```
 
-It's the exact same UI as `index.html` — `--mode` just pre-selects every
-loaded query and switches the page's *initial* view; Single/Compare/Union,
-click-to-inspect, and the highlight toggle all still work after it opens.
-`index.html` and `render.py`'s output share one copy of the interaction
-logic (`viewer.js`) and the category table (`node-style.js`), so anything
-below in this doc — the mode descriptions, the shared-hash caveats — applies
-to both equally.
-
-Node/edge transitions (mode switches, the shared-subtree ring, layout on
-load) are animated in both — see `viewer.js`'s `LAYOUT_ANIMATION` and the
-`transition-property` entries in `buildCyStyle()` if you want to retune or
-disable that.
-
-Per-node cost isn't rendered anywhere in either page — `dag_export` doesn't
-emit one today (no cost estimator is wired into pre-ASAP IR yet). The side
-panel already dumps a clicked node's full `detail` verbatim, so a future
-`cost` field added there would show up with no viewer change needed.
-
-## Visual style and node categories
-
-Node colors, icons, and shapes are adapted from
-[`ProjectASAP/bgp-query-dag-explorer`](https://github.com/ProjectASAP/bgp-query-dag-explorer)'s
-visual language, applied to the real `QueryExpr` IR instead of that repo's
-hardcoded BGP query set. `tools/dag-viewer/node-style.js` is the single
-source of truth for which of `QueryExpr`'s ~24 node kinds belongs to which of
-the 9 categories (data / filter / derive / aggregate / window / join / set /
-sort / bind) — edit that file to reclassify a kind or retune the palette;
-nothing else in `index.html` needs to change.
-
-## Compare and Union mode
-
-Once two or more queries are loaded, the mode toggle next to the drop zone
-switches between three views:
-
-- **Single** (default) — one query's DAG at a time, selected via the tabs.
-  Unchanged from before.
-- **Compare** — every checked query gets its own lane (a dashed box titled
-  with the query's name), laid out side by side. A dashed line connects
-  nodes across lanes whenever their structural hash matches, so "what's
-  shared vs. query-specific" is a line you can trace instead of a ring you
-  have to hunt for one node at a time.
-- **Union** — the checked queries are merged into a single graph. Any node
-  whose hash is shared by two or more of them is drawn once, and edges from
-  every query that reaches that node converge onto it, instead of each
-  query drawing its own disconnected copy of the shared subtree. A merged
-  node gets a double border; the side panel lists which queries it's
-  present in (and, if it's more than one query's root, all of them).
+Open <http://127.0.0.1:8000>, expand **Query editor**, add SQL or PromQL
+queries, choose an epsilon, and click **Plan selected workload**. The backend
+runs the real pipeline:
 
-Switching into Compare or Union the first time selects every currently
-loaded query by default; use the checkboxes in the tab bar to narrow it
-down (each mode needs at least two selected, or it shows a hint instead of
-an empty graph). The selection is remembered when you switch back to
-Single and later back to Compare/Union.
+1. SQL/PromQL parsing and lowering
+2. pre-ASAP DAG generation
+3. ASAP-aware mapping
+4. post-ASAP DAG generation
 
-Branching is the normal case here, not an edge case: `QueryExpr` graphs have
-real branching at arbitrary depth (`Merge`/`Concat` with N children,
-`Join`/`SetOp`/`BinaryOp` with two, `LetBinding` with two structurally
-different children), and Union mode's merge can give a single node several
-parents at once — e.g. two queries whose `Aggregate` differs but whose
-underlying `Scan` is identical converge two different parents onto that one
-`Scan` node. `dagre` lays out multi-parent DAGs natively, so no special
-casing was needed for that beyond building the merged node/edge set
-correctly. Compare mode's lanes use `cytoscape.js`'s compound-node support
-(each lane is a parent node containing that query's nodes); the dashed
-cross-lane links are added to the graph *after* the per-lane layout runs,
-so they're purely visual and never distort which lane a node lands in.
+The editor includes built-in `metrics` and `hosts` table schemas. Enable the
+schemas each SQL query uses with its checkboxes, or add a table with custom
+columns using one readable `name TYPE [NOT NULL]` declaration per line and
+an optional time-index column. The compact `name:type!` form remains accepted
+for compatibility. These definitions are passed to `dag_export` and used by the SQL
+binder; they are not display-only metadata. PromQL keeps its open metric
+model and shows an inferred schema based on the labels and values used by the
+query. The sidebar groups identical input schemas and lists every selected
+query that uses each one.
 
-This is the same lane-based interaction model as the reference repo
-mentioned in [issue #186](https://github.com/ProjectASAP/ASAPPlanner/issues/186)
-(`ProjectASAP/bgp-query-dag-explorer`), adapted for real DAGs: that repo's
-layout assumes each query is a flat, linear list of `steps`, which doesn't
-carry over as-is once a query can branch.
+The Python terminal streams those stages while they run. The server binds to
+localhost by default and invokes `dag_export` with an argv array, not a
+shell command.
 
-### "Shared" here means matching hash, not real CSE
+## Export JSON directly
 
-Compare and Union mode build on the exact same signal as the single-view
-highlighting described below: a node is "shared"/"merged" if its structural
-hash matches a node in another selected query. It is **not** real `Rc`
-identity and **not** the output of a real common-subexpression-elimination
-pass — see the next section for why, and don't read the UI's "shared" /
-"merged" language as claiming otherwise.
-
-## Shared-subtree highlighting is a real-hash proxy, not real CSE (yet)
-
-The highlight (and Compare/Union mode's notion of "shared") is computed by
-matching each node's `hash` across queries (a node is "shared" once its
-hash shows up under ≥ 2 distinct query names).
-That `hash` is no longer a viewer-only reimplementation: as of issue #223
-stage 3, `dag_export`'s per-node `hash` is computed by calling
-`asap_types::pre_asap::cse::structural_hash` directly — the exact same
-function, on the exact same input, that
-`asap_types::pre_asap::cse::share_common_subtrees`'s `InternTable` uses to
-bucket its own merge candidates (`crates/types/src/dag_export.rs`,
-`crates/types/src/pre_asap/cse.rs`). Two nodes with equal `hash` here really
-are exactly the pair `InternTable::intern` would go on to run its
-`PartialEq` check against.
-
-It's still a **proxy**, though, for two independent reasons — a hash match
-here does not by itself mean `share_common_subtrees` ran and actually merged
-those nodes onto one `Rc`:
-
-1. **The `PartialEq` + legality gate isn't re-run.** `structural_hash` is
-   deliberately only a coarse bucketing filter (hash collisions are
-   possible, and never disambiguated here); the viewer trusts a hash match
-   as "structurally identical" without also re-checking `PartialEq` or
-   `Schema::has_unique_key()` the way `InternTable::intern` does before
-   actually sharing an `Rc`. A node with no provable unique key (e.g. an
-   ungrouped `Aggregate`) can still show up highlighted here even though
-   real CSE would never hoist it.
-2. **No real `Rc` identity crosses this tool's process boundaries.** Each
-   `--sql`/`--promql` query given to the `dag_export` binary is lowered and
-   exported independently — `share_common_subtrees` is never actually
-   invoked in this path — and the viewer's own multi-file-load feature
-   merges JSON produced by entirely separate `dag_export` invocations (or
-   even separate machines/times). There is no `Rc<QueryExpr>` for the
-   viewer to compare pointer identity on; hash equality is the only signal
-   available to it, by construction, regardless of how the hash is
-   computed.
+```sh
+cargo run -p asap-devtools --bin dag_export -- \
+  --post-asap --epsilon 0.01 \
+  --sql "SELECT service, COUNT(*) FROM metrics GROUP BY service" --name q1 \
+  > /tmp/dag.json
+```
 
-Closing this fully — real `Rc::ptr_eq`-based highlighting reflecting an
-actual `share_common_subtrees` run — would mean threading `Rc` pointer
-identity from a single in-process `share_common_subtrees` call through
-`dag_export`'s node-flattening and into the exported JSON (a new field
-alongside `hash`), and having the `dag_export` binary actually call
-`share_common_subtrees` across all queries given in one invocation before
-exporting. That's a reasonable follow-up but a materially bigger change than
-this hash-unification step (new export API, binary changes, and a viewer
-highlighting-logic change) and orthogonal to it, so it's left for a future
-issue rather than folded into #223 stage 3.
+Load the JSON with the page's file picker. A post-ASAP visualization requires
+`--post-asap`; ordinary exports intentionally omit `post_graph`.
 
-## Replacement explanations (`notes`)
+## Standalone HTML
 
-Each `DagNode` in the exported JSON carries a `notes` field:
+```sh
+python3 tools/dag-viewer/render.py /tmp/dag.json -o /tmp/dag.html
+```
 
-```jsonc
-"notes": [
-  { "kind": "SketchApproximation", "reason": "quantile(q=0.99) realizes as a Kll sketch — …" }
-]
+The renderer embeds the workload and vendored JavaScript into one file. It
+always opens in Pre/Post-ASAP mode; there is no `--mode` option.
+
+## JSON contract
+
+`NamedGraph.graph` is the original pre-ASAP DAG. `NamedGraph.post_graph`
+is the complete translated DAG. Every post-ASAP node produced or carried by
+a selected replacement directly contains:
+
+```json
+{
+  "decision": {
+    "id": 7,
+    "strategy": "SketchAlgorithmStrategy",
+    "rationale": "count realizes as a Cms sketch",
+    "rank": 0,
+    "cost": 3.0,
+    "role": "replacement_root"
+  }
+}
 ```
 
-`notes` is `Vec<DagNote>` (`crates/types/src/dag_export.rs`), omitted from the
-JSON entirely when empty — which is the common case, and always true unless
-the export was run with `--epsilon` (see below). `asap_types::dag_export`
-itself never populates this field; it exists purely as a layering seam so a
-*higher* crate can annotate an already-exported graph without `asap_types`
-knowing anything about that crate's concepts (`asap_types` is a lower crate
-`asap-aware-mapping` depends on, never the reverse).
+The viewer reads this explicit metadata. It never guesses a strategy or
+workload-sharing identity from a node label, hash, or client-side signature.
+The exporter assigns `workload_node_id`; union rendering reads that mapping
+directly.
 
-The one populator today is `dag_export`'s own devtools binary
-(`crates/devtools/src/bin/dag_export.rs`): after exporting each query, it
-calls `asap_aware_mapping::explain_replacements` (issue #257) on the same
-`QueryExpr` and, for every `ReplacementExplanation` returned, finds the
-`DagNode` candidates whose `hash` equals the explanation's `node_hash`, then
-confirms structural equality between the node's in-process source expression
-and the explanation target before pushing a `DagNote { kind, reason }`. The
-hash is a narrowing filter, not identity; the equality check makes annotation
-matching collision-safe.
-`kind` is the `Debug` form of `asap_aware_mapping::ExplanationKind`
-(`"SketchApproximation"` or `"CommonSubexpressionReuse"` today,
-`#[non_exhaustive]` — a future variant just shows up as its own tag, no
-viewer change required); `reason` is that explanation's own rationale text,
-verbatim.
+Node boxes use concrete IR fields: aggregate measures/grouping, sort keys,
+filter predicates, projections, sources, summary families, and readout
+queries. Category icons are deliberately omitted so they cannot be confused
+with IR text.
 
-`SketchApproximation` notes only appear when the export ran with an
-approximate accuracy target: `dag_export`'s default is
-`AccuracyTarget::Exact` (nothing to approximate, so nothing to report), so
-you need the exporter's own `--epsilon <f64>` flag to see one, e.g.:
+## Tests
 
 ```sh
-cargo run -p asap-devtools --bin dag_export -- \
-  --epsilon 0.01 --sql "SELECT quantile(0.99, latency) FROM metrics" --name p99 \
-  > /tmp/dag.json
+python3 -m unittest discover -s tools/dag-viewer -p test_render.py
+cargo test -p asap-devtools --bin dag_export
 ```
-
-`CommonSubexpressionReuse` notes don't need `--epsilon`: they come from a
-subtree repeated within one query (e.g. the same branch appearing on both
-sides of a `BinaryOp`), which `share_common_subtrees` can detect regardless
-of accuracy target.
-
-In the viewer, a node with non-empty `notes` gets a small colored badge in
-its bottom-right corner (color keyed to `kind` — see `node-style.js`'s
-`NOTE_KIND_COLOR`); click the node to see each note's kind and full reason
-text in the side panel, the same "click for detail" pattern the rest of the
-side panel already uses for a node's `detail`/root/shared-subtree status.
-
-## Vendored dependencies
-
-`cytoscape.min.js`, `dagre.min.js`, and `cytoscape-dagre.js` are vendored here
-(not CDN-fetched) so the page works fully offline and doesn't drift with
-upstream releases. All three are MIT-licensed:
-- <https://github.com/cytoscape/cytoscape.js>
-- <https://github.com/dagrejs/dagre>
-- <https://github.com/cytoscape/cytoscape.js-dagre>
diff --git a/tools/dag-viewer/RUNNING.md b/tools/dag-viewer/RUNNING.md
index 68901f8c..c86c83e8 100644
--- a/tools/dag-viewer/RUNNING.md
+++ b/tools/dag-viewer/RUNNING.md
@@ -76,4 +76,6 @@ A node with a blue ring is structurally identical to a node in another loaded qu
 
 The side panel also shows the query's SQL or PromQL text under "Query source," plus a legend for every node category.
 
-Once two or more queries are loaded, the Single/Compare/Union buttons in the header switch between viewing one query at a time (default), several side by side in lanes with shared-subtree links drawn between them, or merged into one graph with shared nodes collapsed. See "Compare and Union mode" in README.md for details.
+The viewer has one **Pre/Post-ASAP** mode. Select one query for its two DAGs,
+or select multiple queries to union the selected workload into one pre-ASAP
+DAG and one post-ASAP DAG.
diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index 4de7e77d..401aa0a8 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -54,7 +54,45 @@
                 }
               }
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
             "children": [],
+            "workload_node_id": 0,
             "hash": 2606922452740434172
           },
           {
@@ -80,14 +118,38 @@
                 ]
               }
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
             "children": [
               0
             ],
+            "workload_node_id": 1,
             "hash": 12396162568747900801,
             "notes": [
               {
                 "kind": "SketchApproximation",
-                "reason": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with); count realizes as a CountSketch sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)"
+                "reason": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with); count realizes as a CountSketch sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with); count realizes as a shared HydraCms structure over Cms serving every subpopulation of this grouped aggregate, instead of one Cms instance per distinct `by` key — legal because this aggregate has a non-empty subpopulation concept and Cms has a modeled Hydra variant (asap_types::post_asap::hydra_kind_for); whether it's *worth* the shared/independent trade-off for the actual subpopulation cardinality is a CostModel's call, not this strategy's; count realizes as a shared HydraCountSketch structure over CountSketch serving every subpopulation of this grouped aggregate, instead of one CountSketch instance per distinct `by` key — legal because this aggregate has a non-empty subpopulation concept and CountSketch has a modeled Hydra variant (asap_types::post_asap::hydra_kind_for); whether it's *worth* the shared/independent trade-off for the actual subpopulation cardinality is a CostModel's call, not this strategy's"
               }
             ]
           },
@@ -112,19 +174,333 @@
               ],
               "qualifier": null
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
             "children": [
               1
             ],
+            "workload_node_id": 2,
             "hash": 17063396757587155626
           }
         ],
         "root": 2
-      }
-    },
-    {
-      "name": "q2",
-      "source": "SELECT service, AVG(latency) FROM metrics GROUP BY service",
-      "graph": {
+      },
+      "replacements": [
+        {
+          "decision_id": 0,
+          "target_pre_id": 1,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "count realizes as a Cms sketch",
+          "rank": 0,
+          "cost": 3.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(metrics)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "latency",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "bytes",
+                        "nullable": false,
+                        "table": "metrics"
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "Table": {
+                      "table_ref": "metrics"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "latency",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "bytes",
+                      "nullable": false,
+                      "table": "metrics"
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 2606922452740434172
+              },
+              {
+                "id": 1,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "accuracy": {
+                        "Epsilon": 0.01
+                      },
+                      "kind": "count"
+                    }
+                  ],
+                  "output_names": [
+                    "count(*)"
+                  ],
+                  "reduction": {
+                    "Reduce": [
+                      1
+                    ]
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "count(*)",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": null,
+                  "unique_keys": [
+                    [
+                      0
+                    ]
+                  ]
+                },
+                "children": [
+                  0
+                ],
+                "hash": 12396162568747900801
+              }
+            ],
+            "root": 1
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "KeepPreAsap",
+                  "label": "KeepPreAsap(Scan)",
+                  "detail": {
+                    "pre_asap_subgraph": {
+                      "nodes": [
+                        {
+                          "children": [],
+                          "detail": {
+                            "predicates": [],
+                            "schema": {
+                              "closed": true,
+                              "columns": [
+                                {
+                                  "dtype": "timestamp",
+                                  "name": "ts",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "utf8",
+                                  "name": "service",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "utf8",
+                                  "name": "region",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "float64",
+                                  "name": "latency",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "int64",
+                                  "name": "bytes",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                }
+                              ],
+                              "time_index": 0,
+                              "unique_keys": []
+                            },
+                            "source": {
+                              "Table": {
+                                "table_ref": "metrics"
+                              }
+                            }
+                          },
+                          "hash": 2606922452740434172,
+                          "id": 0,
+                          "kind": "Scan",
+                          "label": "Scan(metrics)",
+                          "schema": {
+                            "closed": true,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "service",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "region",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "latency",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "int64",
+                                "name": "bytes",
+                                "nullable": false,
+                                "table": "metrics"
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        }
+                      ],
+                      "root": 0
+                    }
+                  },
+                  "children": []
+                },
+                {
+                  "id": 1,
+                  "kind": "SummaryAgg",
+                  "label": "SummaryAgg(Sketch(Cms))",
+                  "detail": {
+                    "col": "SampleValue",
+                    "family": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+                    "grouping": "PerSubpopulationInstance",
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "children": [
+                    0
+                  ]
+                },
+                {
+                  "id": 2,
+                  "kind": "SummaryEstimate",
+                  "label": "SummaryEstimate(PointCount { key: SampleValue, value: None })",
+                  "detail": {
+                    "query": "PointCount { key: SampleValue, value: None }"
+                  },
+                  "children": [
+                    1
+                  ]
+                }
+              ],
+              "root": 2
+            }
+          }
+        }
+      ],
+      "post_graph": {
         "nodes": [
           {
             "id": 0,
@@ -175,37 +551,134 @@
                 }
               }
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
             "children": [],
-            "hash": 2606922452740434172
+            "workload_node_id": 0,
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_region"
+            }
           },
           {
             "id": 1,
-            "kind": "Aggregate",
-            "label": "Aggregate(1 measures)",
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(Sketch(Cms))",
             "detail": {
-              "having": null,
-              "measures": [
-                {
-                  "col": 3,
-                  "kind": "avg"
-                }
-              ],
-              "output_names": [
-                "avg(metrics.latency)"
-              ],
+              "col": "SampleValue",
+              "family": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+              "grouping": "PerSubpopulationInstance",
               "reduction": {
                 "Reduce": [
                   1
                 ]
               }
             },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+                  "name": "count(*)",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
             "children": [
               0
             ],
-            "hash": 5109904469838189862
+            "workload_node_id": 1,
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_region"
+            }
           },
           {
             "id": 2,
+            "kind": "SummaryEstimate",
+            "label": "SummaryEstimate(PointCount { key: SampleValue, value: None })",
+            "detail": {
+              "query": "PointCount { key: SampleValue, value: None }"
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "Plain(Int64)",
+                  "name": "count(*)",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 2,
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 3,
             "kind": "Project",
             "label": "Project(2 cols)",
             "detail": {
@@ -225,126 +698,4274 @@
               ],
               "qualifier": null
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
             "children": [
-              1
+              2
             ],
-            "hash": 5277207484379927121
+            "workload_node_id": 3,
+            "hash": 17063396757587155626
           }
         ],
-        "root": 2
+        "root": 3
       }
     },
     {
-      "name": "q3",
-      "source": "topk(5, rate(http_requests_total[5m]))",
+      "name": "q2",
+      "source": "SELECT service, AVG(latency) FROM metrics GROUP BY service",
       "graph": {
         "nodes": [
           {
             "id": 0,
             "kind": "Scan",
-            "label": "Scan(http_requests_total)",
+            "label": "Scan(metrics)",
             "detail": {
               "predicates": [],
               "schema": {
-                "closed": false,
+                "closed": true,
                 "columns": [
                   {
                     "dtype": "timestamp",
                     "name": "ts",
                     "nullable": false,
-                    "table": null
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "metrics"
                   },
                   {
                     "dtype": "float64",
-                    "name": "value",
+                    "name": "latency",
                     "nullable": false,
-                    "table": null
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "int64",
+                    "name": "bytes",
+                    "nullable": false,
+                    "table": "metrics"
                   }
                 ],
                 "time_index": 0,
                 "unique_keys": []
               },
               "source": {
-                "TimeSeries": {
-                  "metric": "http_requests_total"
+                "Table": {
+                  "table_ref": "metrics"
                 }
               }
             },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
             "children": [],
-            "hash": 16569634401303792668
+            "workload_node_id": 0,
+            "hash": 2606922452740434172
           },
           {
             "id": 1,
-            "kind": "TimeRange",
-            "label": "TimeRange(300s)",
-            "detail": {
-              "range": {
-                "nanos": 0,
-                "secs": 300
-              }
-            },
-            "children": [
-              0
-            ],
-            "hash": 12007712336004404578
-          },
-          {
-            "id": 2,
             "kind": "Aggregate",
             "label": "Aggregate(1 measures)",
             "detail": {
               "having": null,
               "measures": [
                 {
-                  "kind": "rate"
+                  "col": 3,
+                  "kind": "avg"
                 }
               ],
               "output_names": [
-                ""
+                "avg(metrics.latency)"
               ],
-              "reduction": "PerEntity"
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "avg(metrics.latency)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
             },
             "children": [
-              1
+              0
             ],
-            "hash": 12607242477503010192
+            "workload_node_id": 3,
+            "hash": 5109904469838189862
           },
           {
-            "id": 3,
-            "kind": "Sort",
-            "label": "Sort(1 keys)",
+            "id": 2,
+            "kind": "Project",
+            "label": "Project(2 cols)",
             "detail": {
-              "keys": [
+              "cols": [
                 {
-                  "ascending": false,
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
                   "expr": {
                     "Column": 1
-                  },
-                  "nulls_first": false
+                  }
                 }
               ],
-              "partition_by": []
+              "qualifier": null
             },
-            "children": [
-              2
-            ],
-            "hash": 3760917937445997010
-          },
-          {
-            "id": 4,
-            "kind": "Limit",
-            "label": "Limit(5)",
-            "detail": {
-              "n": 5,
-              "offset": 0
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "avg(metrics.latency)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
             },
             "children": [
-              3
+              1
             ],
-            "hash": 7672123412300577486
+            "workload_node_id": 4,
+            "hash": 5277207484379927121
           }
         ],
-        "root": 4
+        "root": 2
+      },
+      "replacements": [
+        {
+          "decision_id": 1,
+          "target_pre_id": 1,
+          "strategy": "AvgToSumOverCountStrategy",
+          "rationale": "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT.",
+          "rank": 0,
+          "cost": 2.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(metrics)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "latency",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "bytes",
+                        "nullable": false,
+                        "table": "metrics"
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "Table": {
+                      "table_ref": "metrics"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "latency",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "bytes",
+                      "nullable": false,
+                      "table": "metrics"
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 2606922452740434172
+              },
+              {
+                "id": 1,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "col": 3,
+                      "kind": "avg"
+                    }
+                  ],
+                  "output_names": [
+                    "avg(metrics.latency)"
+                  ],
+                  "reduction": {
+                    "Reduce": [
+                      1
+                    ]
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "avg(metrics.latency)",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": null,
+                  "unique_keys": [
+                    [
+                      0
+                    ]
+                  ]
+                },
+                "children": [
+                  0
+                ],
+                "hash": 5109904469838189862
+              }
+            ],
+            "root": 1
+          },
+          "after": {
+            "kind": "Rewrite",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "Scan",
+                  "label": "Scan(metrics)",
+                  "detail": {
+                    "predicates": [],
+                    "schema": {
+                      "closed": true,
+                      "columns": [
+                        {
+                          "dtype": "timestamp",
+                          "name": "ts",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "utf8",
+                          "name": "service",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "utf8",
+                          "name": "region",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "float64",
+                          "name": "latency",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "int64",
+                          "name": "bytes",
+                          "nullable": false,
+                          "table": "metrics"
+                        }
+                      ],
+                      "time_index": 0,
+                      "unique_keys": []
+                    },
+                    "source": {
+                      "Table": {
+                        "table_ref": "metrics"
+                      }
+                    }
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "latency",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "bytes",
+                        "nullable": false,
+                        "table": "metrics"
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [],
+                  "hash": 2606922452740434172
+                },
+                {
+                  "id": 1,
+                  "kind": "Aggregate",
+                  "label": "Aggregate(1 measures)",
+                  "detail": {
+                    "having": null,
+                    "measures": [
+                      {
+                        "col": 3,
+                        "kind": "sum"
+                      }
+                    ],
+                    "output_names": [],
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "sum",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": null,
+                    "unique_keys": [
+                      [
+                        0
+                      ]
+                    ]
+                  },
+                  "children": [
+                    0
+                  ],
+                  "hash": 18377191452169790973
+                },
+                {
+                  "id": 2,
+                  "kind": "Project",
+                  "label": "Project(2 cols)",
+                  "detail": {
+                    "cols": [
+                      {
+                        "alias": null,
+                        "expr": {
+                          "Column": 0
+                        }
+                      },
+                      {
+                        "alias": "avg(metrics.latency)",
+                        "expr": {
+                          "Cast": {
+                            "expr": {
+                              "Column": 1
+                            },
+                            "to": "float64",
+                            "try_cast": false
+                          }
+                        }
+                      }
+                    ],
+                    "qualifier": null
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "avg(metrics.latency)",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": null,
+                    "unique_keys": [
+                      [
+                        0
+                      ]
+                    ]
+                  },
+                  "children": [
+                    1
+                  ],
+                  "hash": 11401885529025699918
+                },
+                {
+                  "id": 3,
+                  "kind": "Scan",
+                  "label": "Scan(metrics)",
+                  "detail": {
+                    "predicates": [],
+                    "schema": {
+                      "closed": true,
+                      "columns": [
+                        {
+                          "dtype": "timestamp",
+                          "name": "ts",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "utf8",
+                          "name": "service",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "utf8",
+                          "name": "region",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "float64",
+                          "name": "latency",
+                          "nullable": false,
+                          "table": "metrics"
+                        },
+                        {
+                          "dtype": "int64",
+                          "name": "bytes",
+                          "nullable": false,
+                          "table": "metrics"
+                        }
+                      ],
+                      "time_index": 0,
+                      "unique_keys": []
+                    },
+                    "source": {
+                      "Table": {
+                        "table_ref": "metrics"
+                      }
+                    }
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "latency",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "bytes",
+                        "nullable": false,
+                        "table": "metrics"
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [],
+                  "hash": 2606922452740434172
+                },
+                {
+                  "id": 4,
+                  "kind": "Aggregate",
+                  "label": "Aggregate(1 measures)",
+                  "detail": {
+                    "having": null,
+                    "measures": [
+                      {
+                        "accuracy": "Exact",
+                        "kind": "count"
+                      }
+                    ],
+                    "output_names": [],
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "count",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": null,
+                    "unique_keys": [
+                      [
+                        0
+                      ]
+                    ]
+                  },
+                  "children": [
+                    3
+                  ],
+                  "hash": 6760740959892251122
+                },
+                {
+                  "id": 5,
+                  "kind": "BinaryOp",
+                  "label": "BinaryOp(/)",
+                  "detail": {
+                    "op": "/",
+                    "vector_match": null
+                  },
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "avg(metrics.latency)",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": null,
+                    "unique_keys": [
+                      [
+                        0
+                      ]
+                    ]
+                  },
+                  "children": [
+                    2,
+                    4
+                  ],
+                  "hash": 16391872732257280252
+                }
+              ],
+              "root": 5
+            }
+          }
+        }
+      ],
+      "post_graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(metrics)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": true,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "latency",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "int64",
+                    "name": "bytes",
+                    "nullable": false,
+                    "table": "metrics"
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "Table": {
+                  "table_ref": "metrics"
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 0,
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 6,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 1,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(ExactAggregate(Sum))",
+            "detail": {
+              "col": {
+                "Qualified": {
+                  "name": "latency",
+                  "table": "metrics"
+                }
+              },
+              "family": "ExactAggregate(Sum, Sum)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Sum, Sum)",
+                  "name": "sum",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 4,
+            "decision": {
+              "id": 6,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 2,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": "avg(metrics.latency)",
+                  "expr": {
+                    "Cast": {
+                      "expr": {
+                        "Column": 1
+                      },
+                      "to": "float64",
+                      "try_cast": false
+                    }
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "avg(metrics.latency)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 5,
+            "hash": 11401885529025699918,
+            "decision": {
+              "id": 1,
+              "strategy": "AvgToSumOverCountStrategy",
+              "rationale": "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT.",
+              "rank": 0,
+              "cost": 2.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 3,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(ExactAggregate(Count))",
+            "detail": {
+              "col": "SampleValue",
+              "family": "ExactAggregate(Count, Count)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Count, Count)",
+                  "name": "count",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 6,
+            "decision": {
+              "id": 7,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as an exact Count accumulator",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 4,
+            "kind": "BinaryOp",
+            "label": "BinaryOp(/)",
+            "detail": {
+              "op": "/",
+              "vector_match": null
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "avg(metrics.latency)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              2,
+              3
+            ],
+            "workload_node_id": 7,
+            "hash": 16391872732257280252,
+            "decision": {
+              "id": 1,
+              "strategy": "AvgToSumOverCountStrategy",
+              "rationale": "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT.",
+              "rank": 0,
+              "cost": 2.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 5,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 1
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "avg(metrics.latency)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              4
+            ],
+            "workload_node_id": 8,
+            "hash": 5277207484379927121
+          }
+        ],
+        "root": 5
+      }
+    },
+    {
+      "name": "q3",
+      "source": "topk(5, rate(http_requests_total[5m]))",
+      "graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(http_requests_total)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": false,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": null
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "value",
+                    "nullable": false,
+                    "table": null
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "TimeSeries": {
+                  "metric": "http_requests_total"
+                }
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 5,
+            "hash": 16569634401303792668
+          },
+          {
+            "id": 1,
+            "kind": "TimeRange",
+            "label": "TimeRange(300s)",
+            "detail": {
+              "range": {
+                "nanos": 0,
+                "secs": 300
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 6,
+            "hash": 12007712336004404578
+          },
+          {
+            "id": 2,
+            "kind": "Aggregate",
+            "label": "Aggregate(1 measures)",
+            "detail": {
+              "having": null,
+              "measures": [
+                {
+                  "kind": "rate"
+                }
+              ],
+              "output_names": [
+                ""
+              ],
+              "reduction": "PerEntity"
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 7,
+            "hash": 12607242477503010192
+          },
+          {
+            "id": 3,
+            "kind": "Sort",
+            "label": "Sort(1 keys)",
+            "detail": {
+              "keys": [
+                {
+                  "ascending": false,
+                  "expr": {
+                    "Column": 1
+                  },
+                  "nulls_first": false
+                }
+              ],
+              "partition_by": []
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 8,
+            "hash": 3760917937445997010
+          },
+          {
+            "id": 4,
+            "kind": "Limit",
+            "label": "Limit(5)",
+            "detail": {
+              "n": 5,
+              "offset": 0
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 9,
+            "hash": 7672123412300577486
+          }
+        ],
+        "root": 4
+      },
+      "replacements": [
+        {
+          "decision_id": 3,
+          "target_pre_id": 2,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "Rate realizes as an exact Rate accumulator",
+          "rank": 0,
+          "cost": 4.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(http_requests_total)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "TimeSeries": {
+                      "metric": "http_requests_total"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 16569634401303792668
+              },
+              {
+                "id": 1,
+                "kind": "TimeRange",
+                "label": "TimeRange(300s)",
+                "detail": {
+                  "range": {
+                    "nanos": 0,
+                    "secs": 300
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  0
+                ],
+                "hash": 12007712336004404578
+              },
+              {
+                "id": 2,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "kind": "rate"
+                    }
+                  ],
+                  "output_names": [
+                    ""
+                  ],
+                  "reduction": "PerEntity"
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  1
+                ],
+                "hash": 12607242477503010192
+              }
+            ],
+            "root": 2
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "KeepPreAsap",
+                  "label": "KeepPreAsap(TimeRange)",
+                  "detail": {
+                    "pre_asap_subgraph": {
+                      "nodes": [
+                        {
+                          "children": [],
+                          "detail": {
+                            "predicates": [],
+                            "schema": {
+                              "closed": false,
+                              "columns": [
+                                {
+                                  "dtype": "timestamp",
+                                  "name": "ts",
+                                  "nullable": false,
+                                  "table": null
+                                },
+                                {
+                                  "dtype": "float64",
+                                  "name": "value",
+                                  "nullable": false,
+                                  "table": null
+                                }
+                              ],
+                              "time_index": 0,
+                              "unique_keys": []
+                            },
+                            "source": {
+                              "TimeSeries": {
+                                "metric": "http_requests_total"
+                              }
+                            }
+                          },
+                          "hash": 16569634401303792668,
+                          "id": 0,
+                          "kind": "Scan",
+                          "label": "Scan(http_requests_total)",
+                          "schema": {
+                            "closed": false,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": null
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "value",
+                                "nullable": false,
+                                "table": null
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        },
+                        {
+                          "children": [
+                            0
+                          ],
+                          "detail": {
+                            "range": {
+                              "nanos": 0,
+                              "secs": 300
+                            }
+                          },
+                          "hash": 12007712336004404578,
+                          "id": 1,
+                          "kind": "TimeRange",
+                          "label": "TimeRange(300s)",
+                          "schema": {
+                            "closed": false,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": null
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "value",
+                                "nullable": false,
+                                "table": null
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        }
+                      ],
+                      "root": 1
+                    }
+                  },
+                  "children": []
+                },
+                {
+                  "id": 1,
+                  "kind": "SummaryAgg",
+                  "label": "SummaryAgg(ExactAggregate(Rate))",
+                  "detail": {
+                    "col": "SampleValue",
+                    "family": "ExactAggregate(Rate, Rate)",
+                    "grouping": "PerSubpopulationInstance",
+                    "reduction": "PerEntity"
+                  },
+                  "children": [
+                    0
+                  ]
+                }
+              ],
+              "root": 1
+            }
+          }
+        },
+        {
+          "decision_id": 2,
+          "target_pre_id": 4,
+          "strategy": "TopKLimitReuseStrategy",
+          "rationale": "Derives this smaller top-k from a compatible larger top-k result shared by the workload.",
+          "rank": 0,
+          "cost": 5.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(http_requests_total)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "TimeSeries": {
+                      "metric": "http_requests_total"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 16569634401303792668
+              },
+              {
+                "id": 1,
+                "kind": "TimeRange",
+                "label": "TimeRange(300s)",
+                "detail": {
+                  "range": {
+                    "nanos": 0,
+                    "secs": 300
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  0
+                ],
+                "hash": 12007712336004404578
+              },
+              {
+                "id": 2,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "kind": "rate"
+                    }
+                  ],
+                  "output_names": [
+                    ""
+                  ],
+                  "reduction": "PerEntity"
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  1
+                ],
+                "hash": 12607242477503010192
+              },
+              {
+                "id": 3,
+                "kind": "Sort",
+                "label": "Sort(1 keys)",
+                "detail": {
+                  "keys": [
+                    {
+                      "ascending": false,
+                      "expr": {
+                        "Column": 1
+                      },
+                      "nulls_first": false
+                    }
+                  ],
+                  "partition_by": []
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  2
+                ],
+                "hash": 3760917937445997010
+              },
+              {
+                "id": 4,
+                "kind": "Limit",
+                "label": "Limit(5)",
+                "detail": {
+                  "n": 5,
+                  "offset": 0
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  3
+                ],
+                "hash": 7672123412300577486
+              }
+            ],
+            "root": 4
+          },
+          "after": {
+            "kind": "Rewrite",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "Scan",
+                  "label": "Scan(http_requests_total)",
+                  "detail": {
+                    "predicates": [],
+                    "schema": {
+                      "closed": false,
+                      "columns": [
+                        {
+                          "dtype": "timestamp",
+                          "name": "ts",
+                          "nullable": false,
+                          "table": null
+                        },
+                        {
+                          "dtype": "float64",
+                          "name": "value",
+                          "nullable": false,
+                          "table": null
+                        }
+                      ],
+                      "time_index": 0,
+                      "unique_keys": []
+                    },
+                    "source": {
+                      "TimeSeries": {
+                        "metric": "http_requests_total"
+                      }
+                    }
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [],
+                  "hash": 16569634401303792668
+                },
+                {
+                  "id": 1,
+                  "kind": "TimeRange",
+                  "label": "TimeRange(300s)",
+                  "detail": {
+                    "range": {
+                      "nanos": 0,
+                      "secs": 300
+                    }
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [
+                    0
+                  ],
+                  "hash": 12007712336004404578
+                },
+                {
+                  "id": 2,
+                  "kind": "Aggregate",
+                  "label": "Aggregate(1 measures)",
+                  "detail": {
+                    "having": null,
+                    "measures": [
+                      {
+                        "kind": "rate"
+                      }
+                    ],
+                    "output_names": [
+                      ""
+                    ],
+                    "reduction": "PerEntity"
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [
+                    1
+                  ],
+                  "hash": 12607242477503010192
+                },
+                {
+                  "id": 3,
+                  "kind": "Sort",
+                  "label": "Sort(1 keys)",
+                  "detail": {
+                    "keys": [
+                      {
+                        "ascending": false,
+                        "expr": {
+                          "Column": 1
+                        },
+                        "nulls_first": false
+                      }
+                    ],
+                    "partition_by": []
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [
+                    2
+                  ],
+                  "hash": 3760917937445997010
+                },
+                {
+                  "id": 4,
+                  "kind": "Limit",
+                  "label": "Limit(10)",
+                  "detail": {
+                    "n": 10,
+                    "offset": 0
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [
+                    3
+                  ],
+                  "hash": 10822644126224715622
+                },
+                {
+                  "id": 5,
+                  "kind": "Limit",
+                  "label": "Limit(5)",
+                  "detail": {
+                    "n": 5,
+                    "offset": 0
+                  },
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "children": [
+                    4
+                  ],
+                  "hash": 5925942169603452483
+                }
+              ],
+              "root": 5
+            }
+          }
+        }
+      ],
+      "post_graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(http_requests_total)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": false,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": null
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "value",
+                    "nullable": false,
+                    "table": null
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "TimeSeries": {
+                  "metric": "http_requests_total"
+                }
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 9,
+            "hash": 16569634401303792668,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 1,
+            "kind": "TimeRange",
+            "label": "TimeRange(300s)",
+            "detail": {
+              "range": {
+                "nanos": 0,
+                "secs": 300
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 10,
+            "hash": 12007712336004404578,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 2,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(ExactAggregate(Rate))",
+            "detail": {
+              "col": "SampleValue",
+              "family": "ExactAggregate(Rate, Rate)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": "PerEntity"
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Timestamp)",
+                  "name": "ts",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Rate, Rate)",
+                  "name": "value",
+                  "nullable": false
+                }
+              ],
+              "time_index": 0
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 11,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 3,
+            "kind": "Sort",
+            "label": "Sort(1 keys)",
+            "detail": {
+              "keys": [
+                {
+                  "ascending": false,
+                  "expr": {
+                    "Column": 1
+                  },
+                  "nulls_first": false
+                }
+              ],
+              "partition_by": []
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 12,
+            "hash": 3760917937445997010,
+            "decision": {
+              "id": 2,
+              "strategy": "TopKLimitReuseStrategy",
+              "rationale": "Derives this smaller top-k from a compatible larger top-k result shared by the workload.",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 4,
+            "kind": "Limit",
+            "label": "Limit(10)",
+            "detail": {
+              "n": 10,
+              "offset": 0
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 13,
+            "hash": 10822644126224715622,
+            "decision": {
+              "id": 2,
+              "strategy": "TopKLimitReuseStrategy",
+              "rationale": "Derives this smaller top-k from a compatible larger top-k result shared by the workload.",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 5,
+            "kind": "Limit",
+            "label": "Limit(5)",
+            "detail": {
+              "n": 5,
+              "offset": 0
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              4
+            ],
+            "workload_node_id": 14,
+            "hash": 5925942169603452483,
+            "decision": {
+              "id": 2,
+              "strategy": "TopKLimitReuseStrategy",
+              "rationale": "Derives this smaller top-k from a compatible larger top-k result shared by the workload.",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_root"
+            }
+          }
+        ],
+        "root": 5
+      }
+    },
+    {
+      "name": "q4",
+      "source": "topk(10, rate(http_requests_total[5m]))",
+      "graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(http_requests_total)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": false,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": null
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "value",
+                    "nullable": false,
+                    "table": null
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "TimeSeries": {
+                  "metric": "http_requests_total"
+                }
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 5,
+            "hash": 16569634401303792668
+          },
+          {
+            "id": 1,
+            "kind": "TimeRange",
+            "label": "TimeRange(300s)",
+            "detail": {
+              "range": {
+                "nanos": 0,
+                "secs": 300
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 6,
+            "hash": 12007712336004404578
+          },
+          {
+            "id": 2,
+            "kind": "Aggregate",
+            "label": "Aggregate(1 measures)",
+            "detail": {
+              "having": null,
+              "measures": [
+                {
+                  "kind": "rate"
+                }
+              ],
+              "output_names": [
+                ""
+              ],
+              "reduction": "PerEntity"
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 7,
+            "hash": 12607242477503010192
+          },
+          {
+            "id": 3,
+            "kind": "Sort",
+            "label": "Sort(1 keys)",
+            "detail": {
+              "keys": [
+                {
+                  "ascending": false,
+                  "expr": {
+                    "Column": 1
+                  },
+                  "nulls_first": false
+                }
+              ],
+              "partition_by": []
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 8,
+            "hash": 3760917937445997010
+          },
+          {
+            "id": 4,
+            "kind": "Limit",
+            "label": "Limit(10)",
+            "detail": {
+              "n": 10,
+              "offset": 0
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 10,
+            "hash": 10822644126224715622
+          }
+        ],
+        "root": 4
+      },
+      "replacements": [
+        {
+          "decision_id": 3,
+          "target_pre_id": 2,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "Rate realizes as an exact Rate accumulator",
+          "rank": 0,
+          "cost": 4.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(http_requests_total)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": false,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": null
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "value",
+                        "nullable": false,
+                        "table": null
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "TimeSeries": {
+                      "metric": "http_requests_total"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 16569634401303792668
+              },
+              {
+                "id": 1,
+                "kind": "TimeRange",
+                "label": "TimeRange(300s)",
+                "detail": {
+                  "range": {
+                    "nanos": 0,
+                    "secs": 300
+                  }
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  0
+                ],
+                "hash": 12007712336004404578
+              },
+              {
+                "id": 2,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "kind": "rate"
+                    }
+                  ],
+                  "output_names": [
+                    ""
+                  ],
+                  "reduction": "PerEntity"
+                },
+                "schema": {
+                  "closed": false,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": null
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "value",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  1
+                ],
+                "hash": 12607242477503010192
+              }
+            ],
+            "root": 2
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "KeepPreAsap",
+                  "label": "KeepPreAsap(TimeRange)",
+                  "detail": {
+                    "pre_asap_subgraph": {
+                      "nodes": [
+                        {
+                          "children": [],
+                          "detail": {
+                            "predicates": [],
+                            "schema": {
+                              "closed": false,
+                              "columns": [
+                                {
+                                  "dtype": "timestamp",
+                                  "name": "ts",
+                                  "nullable": false,
+                                  "table": null
+                                },
+                                {
+                                  "dtype": "float64",
+                                  "name": "value",
+                                  "nullable": false,
+                                  "table": null
+                                }
+                              ],
+                              "time_index": 0,
+                              "unique_keys": []
+                            },
+                            "source": {
+                              "TimeSeries": {
+                                "metric": "http_requests_total"
+                              }
+                            }
+                          },
+                          "hash": 16569634401303792668,
+                          "id": 0,
+                          "kind": "Scan",
+                          "label": "Scan(http_requests_total)",
+                          "schema": {
+                            "closed": false,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": null
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "value",
+                                "nullable": false,
+                                "table": null
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        },
+                        {
+                          "children": [
+                            0
+                          ],
+                          "detail": {
+                            "range": {
+                              "nanos": 0,
+                              "secs": 300
+                            }
+                          },
+                          "hash": 12007712336004404578,
+                          "id": 1,
+                          "kind": "TimeRange",
+                          "label": "TimeRange(300s)",
+                          "schema": {
+                            "closed": false,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": null
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "value",
+                                "nullable": false,
+                                "table": null
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        }
+                      ],
+                      "root": 1
+                    }
+                  },
+                  "children": []
+                },
+                {
+                  "id": 1,
+                  "kind": "SummaryAgg",
+                  "label": "SummaryAgg(ExactAggregate(Rate))",
+                  "detail": {
+                    "col": "SampleValue",
+                    "family": "ExactAggregate(Rate, Rate)",
+                    "grouping": "PerSubpopulationInstance",
+                    "reduction": "PerEntity"
+                  },
+                  "children": [
+                    0
+                  ]
+                }
+              ],
+              "root": 1
+            }
+          }
+        }
+      ],
+      "post_graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(http_requests_total)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": false,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": null
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "value",
+                    "nullable": false,
+                    "table": null
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "TimeSeries": {
+                  "metric": "http_requests_total"
+                }
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 9,
+            "hash": 16569634401303792668,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 1,
+            "kind": "TimeRange",
+            "label": "TimeRange(300s)",
+            "detail": {
+              "range": {
+                "nanos": 0,
+                "secs": 300
+              }
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0
+            ],
+            "workload_node_id": 10,
+            "hash": 12007712336004404578,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 2,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(ExactAggregate(Rate))",
+            "detail": {
+              "col": "SampleValue",
+              "family": "ExactAggregate(Rate, Rate)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": "PerEntity"
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Timestamp)",
+                  "name": "ts",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Rate, Rate)",
+                  "name": "value",
+                  "nullable": false
+                }
+              ],
+              "time_index": 0
+            },
+            "children": [
+              1
+            ],
+            "workload_node_id": 11,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 3,
+            "kind": "Sort",
+            "label": "Sort(1 keys)",
+            "detail": {
+              "keys": [
+                {
+                  "ascending": false,
+                  "expr": {
+                    "Column": 1
+                  },
+                  "nulls_first": false
+                }
+              ],
+              "partition_by": []
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 12,
+            "hash": 3760917937445997010
+          },
+          {
+            "id": 4,
+            "kind": "Limit",
+            "label": "Limit(10)",
+            "detail": {
+              "n": 10,
+              "offset": 0
+            },
+            "schema": {
+              "closed": false,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "float64",
+                  "name": "value",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 13,
+            "hash": 10822644126224715622
+          }
+        ],
+        "root": 4
+      }
+    },
+    {
+      "name": "q6",
+      "source": "SELECT metrics.service, COUNT(*) FROM metrics JOIN hosts ON metrics.service = hosts.service GROUP BY metrics.service",
+      "graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(metrics)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": true,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "latency",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "int64",
+                    "name": "bytes",
+                    "nullable": false,
+                    "table": "metrics"
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "Table": {
+                  "table_ref": "metrics"
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 0,
+            "hash": 2606922452740434172
+          },
+          {
+            "id": 1,
+            "kind": "Scan",
+            "label": "Scan(hosts)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": true,
+                "columns": [
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "hosts"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "hosts"
+                  }
+                ],
+                "time_index": null,
+                "unique_keys": []
+              },
+              "source": {
+                "Table": {
+                  "table_ref": "hosts"
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "hosts"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "hosts"
+                }
+              ],
+              "time_index": null,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 11,
+            "hash": 7077183977966848076
+          },
+          {
+            "id": 2,
+            "kind": "Join",
+            "label": "Join(Inner)",
+            "detail": {
+              "kind": "Inner",
+              "pred": {
+                "Compare": {
+                  "left": {
+                    "Column": 1
+                  },
+                  "op": "Eq",
+                  "right": {
+                    "Column": 5
+                  }
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "hosts"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "hosts"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0,
+              1
+            ],
+            "workload_node_id": 12,
+            "hash": 1121596767830819524
+          },
+          {
+            "id": 3,
+            "kind": "Aggregate",
+            "label": "Aggregate(1 measures)",
+            "detail": {
+              "having": null,
+              "measures": [
+                {
+                  "accuracy": {
+                    "Epsilon": 0.01
+                  },
+                  "kind": "count"
+                }
+              ],
+              "output_names": [
+                "count(*)"
+              ],
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 13,
+            "hash": 4243737280010465780,
+            "notes": [
+              {
+                "kind": "SketchApproximation",
+                "reason": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with); count realizes as a CountSketch sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with); count realizes as a shared HydraCms structure over Cms serving every subpopulation of this grouped aggregate, instead of one Cms instance per distinct `by` key — legal because this aggregate has a non-empty subpopulation concept and Cms has a modeled Hydra variant (asap_types::post_asap::hydra_kind_for); whether it's *worth* the shared/independent trade-off for the actual subpopulation cardinality is a CostModel's call, not this strategy's; count realizes as a shared HydraCountSketch structure over CountSketch serving every subpopulation of this grouped aggregate, instead of one CountSketch instance per distinct `by` key — legal because this aggregate has a non-empty subpopulation concept and CountSketch has a modeled Hydra variant (asap_types::post_asap::hydra_kind_for); whether it's *worth* the shared/independent trade-off for the actual subpopulation cardinality is a CostModel's call, not this strategy's"
+              }
+            ]
+          },
+          {
+            "id": 4,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 1
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 14,
+            "hash": 16310199685311002920
+          }
+        ],
+        "root": 4
+      },
+      "replacements": [
+        {
+          "decision_id": 5,
+          "target_pre_id": 3,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "count realizes as a Cms sketch",
+          "rank": 0,
+          "cost": 5.0,
+          "before": {
+            "nodes": [
+              {
+                "id": 0,
+                "kind": "Scan",
+                "label": "Scan(metrics)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "timestamp",
+                        "name": "ts",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "float64",
+                        "name": "latency",
+                        "nullable": false,
+                        "table": "metrics"
+                      },
+                      {
+                        "dtype": "int64",
+                        "name": "bytes",
+                        "nullable": false,
+                        "table": "metrics"
+                      }
+                    ],
+                    "time_index": 0,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "Table": {
+                      "table_ref": "metrics"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "latency",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "bytes",
+                      "nullable": false,
+                      "table": "metrics"
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 2606922452740434172
+              },
+              {
+                "id": 1,
+                "kind": "Scan",
+                "label": "Scan(hosts)",
+                "detail": {
+                  "predicates": [],
+                  "schema": {
+                    "closed": true,
+                    "columns": [
+                      {
+                        "dtype": "utf8",
+                        "name": "service",
+                        "nullable": false,
+                        "table": "hosts"
+                      },
+                      {
+                        "dtype": "utf8",
+                        "name": "region",
+                        "nullable": false,
+                        "table": "hosts"
+                      }
+                    ],
+                    "time_index": null,
+                    "unique_keys": []
+                  },
+                  "source": {
+                    "Table": {
+                      "table_ref": "hosts"
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "hosts"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "hosts"
+                    }
+                  ],
+                  "time_index": null,
+                  "unique_keys": []
+                },
+                "children": [],
+                "hash": 7077183977966848076
+              },
+              {
+                "id": 2,
+                "kind": "Join",
+                "label": "Join(Inner)",
+                "detail": {
+                  "kind": "Inner",
+                  "pred": {
+                    "Compare": {
+                      "left": {
+                        "Column": 1
+                      },
+                      "op": "Eq",
+                      "right": {
+                        "Column": 5
+                      }
+                    }
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "timestamp",
+                      "name": "ts",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "float64",
+                      "name": "latency",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "bytes",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "hosts"
+                    },
+                    {
+                      "dtype": "utf8",
+                      "name": "region",
+                      "nullable": false,
+                      "table": "hosts"
+                    }
+                  ],
+                  "time_index": 0,
+                  "unique_keys": []
+                },
+                "children": [
+                  0,
+                  1
+                ],
+                "hash": 1121596767830819524
+              },
+              {
+                "id": 3,
+                "kind": "Aggregate",
+                "label": "Aggregate(1 measures)",
+                "detail": {
+                  "having": null,
+                  "measures": [
+                    {
+                      "accuracy": {
+                        "Epsilon": 0.01
+                      },
+                      "kind": "count"
+                    }
+                  ],
+                  "output_names": [
+                    "count(*)"
+                  ],
+                  "reduction": {
+                    "Reduce": [
+                      1
+                    ]
+                  }
+                },
+                "schema": {
+                  "closed": true,
+                  "columns": [
+                    {
+                      "dtype": "utf8",
+                      "name": "service",
+                      "nullable": false,
+                      "table": "metrics"
+                    },
+                    {
+                      "dtype": "int64",
+                      "name": "count(*)",
+                      "nullable": false,
+                      "table": null
+                    }
+                  ],
+                  "time_index": null,
+                  "unique_keys": [
+                    [
+                      0
+                    ]
+                  ]
+                },
+                "children": [
+                  2
+                ],
+                "hash": 4243737280010465780
+              }
+            ],
+            "root": 3
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                {
+                  "id": 0,
+                  "kind": "KeepPreAsap",
+                  "label": "KeepPreAsap(Join)",
+                  "detail": {
+                    "pre_asap_subgraph": {
+                      "nodes": [
+                        {
+                          "children": [],
+                          "detail": {
+                            "predicates": [],
+                            "schema": {
+                              "closed": true,
+                              "columns": [
+                                {
+                                  "dtype": "timestamp",
+                                  "name": "ts",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "utf8",
+                                  "name": "service",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "utf8",
+                                  "name": "region",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "float64",
+                                  "name": "latency",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                },
+                                {
+                                  "dtype": "int64",
+                                  "name": "bytes",
+                                  "nullable": false,
+                                  "table": "metrics"
+                                }
+                              ],
+                              "time_index": 0,
+                              "unique_keys": []
+                            },
+                            "source": {
+                              "Table": {
+                                "table_ref": "metrics"
+                              }
+                            }
+                          },
+                          "hash": 2606922452740434172,
+                          "id": 0,
+                          "kind": "Scan",
+                          "label": "Scan(metrics)",
+                          "schema": {
+                            "closed": true,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "service",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "region",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "latency",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "int64",
+                                "name": "bytes",
+                                "nullable": false,
+                                "table": "metrics"
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        },
+                        {
+                          "children": [],
+                          "detail": {
+                            "predicates": [],
+                            "schema": {
+                              "closed": true,
+                              "columns": [
+                                {
+                                  "dtype": "utf8",
+                                  "name": "service",
+                                  "nullable": false,
+                                  "table": "hosts"
+                                },
+                                {
+                                  "dtype": "utf8",
+                                  "name": "region",
+                                  "nullable": false,
+                                  "table": "hosts"
+                                }
+                              ],
+                              "time_index": null,
+                              "unique_keys": []
+                            },
+                            "source": {
+                              "Table": {
+                                "table_ref": "hosts"
+                              }
+                            }
+                          },
+                          "hash": 7077183977966848076,
+                          "id": 1,
+                          "kind": "Scan",
+                          "label": "Scan(hosts)",
+                          "schema": {
+                            "closed": true,
+                            "columns": [
+                              {
+                                "dtype": "utf8",
+                                "name": "service",
+                                "nullable": false,
+                                "table": "hosts"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "region",
+                                "nullable": false,
+                                "table": "hosts"
+                              }
+                            ],
+                            "time_index": null,
+                            "unique_keys": []
+                          }
+                        },
+                        {
+                          "children": [
+                            0,
+                            1
+                          ],
+                          "detail": {
+                            "kind": "Inner",
+                            "pred": {
+                              "Compare": {
+                                "left": {
+                                  "Column": 1
+                                },
+                                "op": "Eq",
+                                "right": {
+                                  "Column": 5
+                                }
+                              }
+                            }
+                          },
+                          "hash": 1121596767830819524,
+                          "id": 2,
+                          "kind": "Join",
+                          "label": "Join(Inner)",
+                          "schema": {
+                            "closed": true,
+                            "columns": [
+                              {
+                                "dtype": "timestamp",
+                                "name": "ts",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "service",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "region",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "float64",
+                                "name": "latency",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "int64",
+                                "name": "bytes",
+                                "nullable": false,
+                                "table": "metrics"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "service",
+                                "nullable": false,
+                                "table": "hosts"
+                              },
+                              {
+                                "dtype": "utf8",
+                                "name": "region",
+                                "nullable": false,
+                                "table": "hosts"
+                              }
+                            ],
+                            "time_index": 0,
+                            "unique_keys": []
+                          }
+                        }
+                      ],
+                      "root": 2
+                    }
+                  },
+                  "children": []
+                },
+                {
+                  "id": 1,
+                  "kind": "SummaryAgg",
+                  "label": "SummaryAgg(Sketch(Cms))",
+                  "detail": {
+                    "col": "SampleValue",
+                    "family": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+                    "grouping": "PerSubpopulationInstance",
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "children": [
+                    0
+                  ]
+                },
+                {
+                  "id": 2,
+                  "kind": "SummaryEstimate",
+                  "label": "SummaryEstimate(PointCount { key: SampleValue, value: None })",
+                  "detail": {
+                    "query": "PointCount { key: SampleValue, value: None }"
+                  },
+                  "children": [
+                    1
+                  ]
+                }
+              ],
+              "root": 2
+            }
+          }
+        }
+      ],
+      "post_graph": {
+        "nodes": [
+          {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(metrics)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": true,
+                "columns": [
+                  {
+                    "dtype": "timestamp",
+                    "name": "ts",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "float64",
+                    "name": "latency",
+                    "nullable": false,
+                    "table": "metrics"
+                  },
+                  {
+                    "dtype": "int64",
+                    "name": "bytes",
+                    "nullable": false,
+                    "table": "metrics"
+                  }
+                ],
+                "time_index": 0,
+                "unique_keys": []
+              },
+              "source": {
+                "Table": {
+                  "table_ref": "metrics"
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 0,
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 5,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 1,
+            "kind": "Scan",
+            "label": "Scan(hosts)",
+            "detail": {
+              "predicates": [],
+              "schema": {
+                "closed": true,
+                "columns": [
+                  {
+                    "dtype": "utf8",
+                    "name": "service",
+                    "nullable": false,
+                    "table": "hosts"
+                  },
+                  {
+                    "dtype": "utf8",
+                    "name": "region",
+                    "nullable": false,
+                    "table": "hosts"
+                  }
+                ],
+                "time_index": null,
+                "unique_keys": []
+              },
+              "source": {
+                "Table": {
+                  "table_ref": "hosts"
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "hosts"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "hosts"
+                }
+              ],
+              "time_index": null,
+              "unique_keys": []
+            },
+            "children": [],
+            "workload_node_id": 15,
+            "hash": 7077183977966848076,
+            "decision": {
+              "id": 5,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 2,
+            "kind": "Join",
+            "label": "Join(Inner)",
+            "detail": {
+              "kind": "Inner",
+              "pred": {
+                "Compare": {
+                  "left": {
+                    "Column": 1
+                  },
+                  "op": "Eq",
+                  "right": {
+                    "Column": 5
+                  }
+                }
+              }
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "timestamp",
+                  "name": "ts",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "float64",
+                  "name": "latency",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "int64",
+                  "name": "bytes",
+                  "nullable": false,
+                  "table": "metrics"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": "hosts"
+                },
+                {
+                  "dtype": "utf8",
+                  "name": "region",
+                  "nullable": false,
+                  "table": "hosts"
+                }
+              ],
+              "time_index": 0,
+              "unique_keys": []
+            },
+            "children": [
+              0,
+              1
+            ],
+            "workload_node_id": 16,
+            "hash": 1121596767830819524,
+            "decision": {
+              "id": 5,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 3,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(Sketch(Cms))",
+            "detail": {
+              "col": "SampleValue",
+              "family": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "Sketch(SketchKind { category: Frequency, algorithm: Cms, params: Cms { width: 272, depth: 5 } }, PerSubpopulationInstance)",
+                  "name": "count(*)",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
+            "children": [
+              2
+            ],
+            "workload_node_id": 17,
+            "decision": {
+              "id": 5,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 4,
+            "kind": "SummaryEstimate",
+            "label": "SummaryEstimate(PointCount { key: SampleValue, value: None })",
+            "detail": {
+              "query": "PointCount { key: SampleValue, value: None }"
+            },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "Plain(Int64)",
+                  "name": "count(*)",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
+            "children": [
+              3
+            ],
+            "workload_node_id": 18,
+            "decision": {
+              "id": 5,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch",
+              "rank": 0,
+              "cost": 5.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 5,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 1
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "schema": {
+              "closed": true,
+              "columns": [
+                {
+                  "dtype": "utf8",
+                  "name": "service",
+                  "nullable": false,
+                  "table": null
+                },
+                {
+                  "dtype": "int64",
+                  "name": "count(*)",
+                  "nullable": false,
+                  "table": null
+                }
+              ],
+              "time_index": null,
+              "unique_keys": [
+                [
+                  0
+                ]
+              ]
+            },
+            "children": [
+              4
+            ],
+            "workload_node_id": 19,
+            "hash": 16310199685311002920
+          }
+        ],
+        "root": 5
       }
     }
   ]
diff --git a/tools/dag-viewer/generate-sample.sh b/tools/dag-viewer/generate-sample.sh
index 7032fcc5..e916cba5 100755
--- a/tools/dag-viewer/generate-sample.sh
+++ b/tools/dag-viewer/generate-sample.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Regenerates tools/dag-viewer/dag.json from a fixed set of example queries.
+# Regenerates tools/dag-viewer/dag.example.json from real example queries.
 # Run from anywhere in the repo; edit the --sql/--promql lines below to try
 # your own queries instead.
 set -euo pipefail
@@ -10,10 +10,13 @@ cd "$(dirname "${BASH_SOURCE[0]}")/../.."
 # report — without it, no query below would ever pick up a `notes` badge
 # (see crates/devtools/src/bin/dag_export.rs's own `--epsilon` doc comment).
 cargo run -p asap-devtools --bin dag_export -- \
+  --post-asap --progress \
   --epsilon 0.01 \
   --sql "SELECT service, COUNT(*) FROM metrics GROUP BY service" --name q1 \
   --sql "SELECT service, AVG(latency) FROM metrics GROUP BY service" --name q2 \
   --promql "topk(5, rate(http_requests_total[5m]))" --name q3 \
-  > tools/dag-viewer/dag.json
+  --promql "topk(10, rate(http_requests_total[5m]))" --name q4 \
+  --sql "SELECT metrics.service, COUNT(*) FROM metrics JOIN hosts ON metrics.service = hosts.service GROUP BY metrics.service" --name q6 \
+  > tools/dag-viewer/dag.example.json
 
-echo "wrote tools/dag-viewer/dag.json"
+echo "wrote tools/dag-viewer/dag.example.json"
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 4678a7af..cb1a1d01 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -110,6 +110,71 @@
   .tab.checkTab { display: flex; align-items: center; gap: 0.35rem; cursor: default; }
   .tab.checkTab input { cursor: pointer; }
   .modeToggle { display: flex; gap: 0.3rem; }
+  #plannerPanel {
+    display: none;
+    padding: 0.65rem 0.75rem;
+    border-bottom: 1px solid var(--border);
+    background: var(--panel);
+  }
+  #plannerPanel.visible { display: block; }
+  #plannerRows { display: flex; flex-direction: column; gap: 0.45rem; }
+  .plannerRow { display: grid; grid-template-columns: auto 130px 80px 150px minmax(280px, 1fr) auto; gap: 0.45rem; align-items: center; }
+  .plannerRow input, .plannerRow select, .plannerRow textarea, #plannerEpsilon,
+  .schemaRow input, .schemaRow textarea {
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    background: var(--bg);
+    color: var(--fg);
+    padding: 0.35rem 0.45rem;
+    font: inherit;
+  }
+  .plannerRow textarea { resize: vertical; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 0.75rem; }
+  .plannerSchemas { display:flex; flex-wrap:wrap; gap:.2rem .45rem; font-size:.68rem; color:var(--muted); }
+  .plannerSchemas label { display:flex; align-items:center; gap:.15rem; }
+  .schemaEditor { margin-bottom: 0.75rem; padding-bottom: 0.7rem; border-bottom: 1px solid var(--border); }
+  .schemaEditorHead { display:flex; align-items:center; gap:.6rem; margin-bottom:.45rem; }
+  .schemaEditorHead h2 { margin:0; font-size:.8rem; }
+  #schemaRows { display:flex; flex-direction:column; gap:.4rem; }
+  .schemaRow { display:grid; grid-template-columns:auto 150px minmax(360px,1fr) 105px auto; gap:.45rem; align-items:center; }
+  .schemaRow textarea { resize:vertical; font: .72rem ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+  .schemaHint { color:var(--muted); font-size:.7rem; }
+  .plannerActions { display: flex; align-items: center; gap: 0.5rem; margin-top: 0.55rem; }
+  #plannerStatus { color: var(--muted); font-size: 0.75rem; }
+  #scopePicker {
+    display: none;
+    flex-wrap: wrap;
+    gap: 0.6rem 1.2rem;
+    padding: 0.55rem 0.75rem;
+    border-bottom: 1px solid var(--border);
+    background: var(--panel);
+  }
+  #scopePicker.visible { display: flex; }
+  .scopeGroup { display: flex; flex-direction: column; gap: 0.3rem; min-width: 220px; }
+  .scopeGroupLabel {
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: .03em;
+    color: var(--muted);
+  }
+  .scopeRow {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.35rem 0.6rem;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    background: var(--panel2);
+    color: var(--fg);
+    font: inherit;
+    font-size: 0.78rem;
+    text-align: left;
+  }
+  .scopeRow.active {
+    border-color: var(--accent);
+    background: var(--bg);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 15%, transparent);
+  }
+  .scopeRow .scopeMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
   .proxyNote {
     font-size: 0.72rem;
     color: var(--muted);
@@ -188,12 +253,26 @@
   }
   #sidepanel {
     width: 340px;
+    min-width: 260px;
+    max-width: 70vw;
     flex-shrink: 0;
     border-left: 1px solid var(--border);
     background: var(--panel);
     overflow-y: auto;
     font-size: 0.8rem;
   }
+  #sideResizeHandle {
+    width: 6px;
+    flex: 0 0 6px;
+    cursor: col-resize;
+    background: transparent;
+    border-left: 1px solid var(--border);
+    touch-action: none;
+  }
+  #sideResizeHandle:hover, #sideResizeHandle.dragging {
+    background: color-mix(in srgb, var(--accent) 22%, transparent);
+    border-left-color: var(--accent);
+  }
   #sidepanel .section {
     padding: 0.8rem;
     border-bottom: 1px solid var(--border);
@@ -235,6 +314,26 @@
   }
   .noteKind { font-size: 0.72rem; font-weight: 700; }
   .noteReason { font-size: 0.75rem; color: var(--fg); margin-top: 0.15rem; }
+  .translationBlock {
+    margin: 0.65rem 0;
+    padding: 0.55rem;
+    border: 1px solid color-mix(in srgb, var(--accent) 45%, var(--border));
+    border-radius: 8px;
+    background: var(--bg);
+  }
+  .translationBlock h3, .detailSubhead {
+    margin: 0 0 0.4rem;
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: .03em;
+    color: var(--muted);
+  }
+  .translationCard + .translationCard { border-top: 1px solid var(--border); margin-top: 0.5rem; padding-top: 0.5rem; }
+  .translationStrategy { color: var(--accent); font-weight: 750; }
+  .translationMeta, .translationTarget { color: var(--muted); font-size: 0.7rem; margin-top: 0.2rem; }
+  .translationReason { margin-top: 0.35rem; line-height: 1.35; }
+  .translationBlock.unchanged { border-style: dashed; color: var(--muted); }
+  .detailSubhead { margin-top: 0.65rem; }
   #detailSection pre {
     white-space: pre-wrap;
     word-break: break-word;
@@ -282,19 +381,37 @@ <h1>ASAP query DAG viewer</h1>
   <div id="dropzone">Drop WorkloadGraph JSON here, or click to choose file(s)</div>
   <input id="fileInput" type="file" accept="application/json" multiple />
   <div class="modeToggle" id="modeToggle">
-    <button class="btn active" id="modeSingleBtn" data-mode="single">Single</button>
-    <button class="btn" id="modeCompareBtn" data-mode="compare">Compare</button>
-    <button class="btn" id="modeUnionBtn" data-mode="union">Union</button>
+    <button class="btn active" type="button" disabled>Pre/Post-ASAP</button>
   </div>
-  <span class="proxyNote" id="proxyNote" style="display:none">"Shared" = same structural hash across independent exports, not live Rc identity — see README.</span>
+  <button class="btn" id="plannerToggle">Query editor</button>
   <button class="btn" id="clearBtn">Clear all</button>
   <label class="toggle">
     <input id="highlightToggle" type="checkbox" checked />
     Highlight shared subtrees
   </label>
+  <span class="proxyNote">Click an edge to inspect its schema</span>
 </header>
 
+<div id="plannerPanel">
+  <div class="schemaEditor">
+    <div class="schemaEditorHead">
+      <h2>Input table schemas</h2>
+      <button class="btn" id="schemaAdd" type="button">Add table schema</button>
+      <span class="schemaHint">One column per line: name TYPE [NOT NULL]. PromQL schemas are inferred from metric usage.</span>
+    </div>
+    <div id="schemaRows"></div>
+  </div>
+  <div id="plannerRows"></div>
+  <div class="plannerActions">
+    <button class="btn" id="plannerAdd" type="button">Add query</button>
+    <label class="toggle">epsilon <input id="plannerEpsilon" type="number" min="0.000001" max="0.999999" step="0.001" value="0.01" /></label>
+    <button class="btn" id="plannerRun" type="button">Plan selected workload</button>
+    <span id="plannerStatus">Requires the local interactive server.</span>
+  </div>
+</div>
+
 <div id="tabs"></div>
+<div id="scopePicker"></div>
 
 <div id="main">
   <div id="empty">
@@ -317,6 +434,7 @@ <h1>ASAP query DAG viewer</h1>
     <div id="cy"></div>
     <div id="modeHint" class="modeHint"></div>
   </div>
+  <div id="sideResizeHandle" style="display:none" title="Drag to resize details panel"></div>
   <div id="sidepanel" style="display:none">
     <div class="section" id="detailSection">
       <h2>Selected node</h2>
@@ -326,6 +444,10 @@ <h2>Selected node</h2>
       <h2>Query source</h2>
       <pre class="code" id="sourceBox"></pre>
     </div>
+    <div class="section">
+      <h2>Input table / metric schemas</h2>
+      <pre class="code" id="tableSchemaBox"></pre>
+    </div>
     <div class="section">
       <h2>Legend</h2>
       <div class="legend" id="legendList"></div>
@@ -334,5 +456,6 @@ <h2>Legend</h2>
 </div>
 
 <script src="viewer.js"></script>
+<script src="planner-ui.js"></script>
 </body>
 </html>
diff --git a/tools/dag-viewer/node-style.js b/tools/dag-viewer/node-style.js
index 3dfb7168..e688a80b 100644
--- a/tools/dag-viewer/node-style.js
+++ b/tools/dag-viewer/node-style.js
@@ -1,8 +1,12 @@
 // Category table for QueryExpr node kinds — the single source of truth for
-// how the viewer colors/labels/icons each `DagNode.kind`. Edit this file to
+// how the viewer colors and labels each `DagNode.kind`. Edit this file to
 // reclassify a kind or retune a palette; nothing else in index.html needs to
-// change. Icon SVGs are adapted from ProjectASAP/bgp-query-dag-explorer's
-// hand-drawn icon set (see tools/dag-viewer/README.md).
+// change.
+//
+// Also covers the 7 post-ASAP-only SummaryDagNode kinds (KeepPreAsap,
+// SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate,
+// SummaryMerge) that appear in the post-ASAP lane — see the `summary`
+// category below.
 
 // kind (DagNode.kind from crates/ir/src/dag_export.rs) -> category name.
 const KIND_CATEGORY = {
@@ -31,34 +35,16 @@ const KIND_CATEGORY = {
   Sort: 'sort',
   Limit: 'sort',
   LetBinding: 'bind',
+  // Post-ASAP SummaryDagNode kinds (post-ASAP lane only).
+  KeepPreAsap: 'summary',
+  SummaryAgg: 'summary',
+  SummaryJoin: 'summary',
+  SummarySubtract: 'summary',
+  SummaryDelete: 'summary',
+  SummaryEstimate: 'summary',
+  SummaryMerge: 'summary',
 };
 
-const ICON_STROKE = '2.2';
-const ICON_FILL = 'rgba(255,255,255,.06)';
-
-// Each icon fn takes a stroke/fill color and returns a standalone SVG string
-// (viewBox 0 0 48 48, consistent stroke weight) for use as a node background
-// image. Cylinder/funnel/transform/grid/venn/dashed-circle/sort-arrow are
-// adapted directly from the reference repo's `iconFor()`; `bind` and the
-// root-node badge are new, drawn in the same style.
-const ICONS = {
-  data: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><ellipse cx="24" cy="10" rx="15" ry="6" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><path d="M9 10v24c0 3.4 6.7 6 15 6s15-2.6 15-6V10" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}"/><path d="M9 22c0 3.4 6.7 6 15 6s15-2.6 15-6" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
-  filter: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><path d="M8 10h32L28 24v12l-8 4V24z" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linejoin="round"/></svg>`,
-  derive: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><circle cx="13" cy="14" r="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><circle cx="35" cy="14" r="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><circle cx="24" cy="34" r="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><path d="M17 16l14 0M15 18l7 13M33 18l-7 13" stroke="${c}" stroke-width="${ICON_STROKE}" fill="none" stroke-linecap="round"/></svg>`,
-  aggregate: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><text x="24" y="34" font-size="30" font-weight="900" text-anchor="middle" font-family="ui-sans-serif,system-ui,sans-serif" fill="${c}">Σ</text></svg>`,
-  window: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="9" y="10" width="30" height="28" rx="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><path d="M16 10v28M24 10v28M32 10v28M9 20h30M9 29h30" stroke="${c}" stroke-width="1.6" opacity=".8"/><path d="M16 7l16 34" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round"/></svg>`,
-  join: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><circle cx="19" cy="24" r="13" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><circle cx="29" cy="24" r="13" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
-  set: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><circle cx="24" cy="24" r="16" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-dasharray="3 3"/><circle cx="18" cy="22" r="2" fill="${c}"/><circle cx="26" cy="18" r="2" fill="${c}"/><circle cx="29" cy="29" r="2" fill="${c}"/><circle cx="20" cy="31" r="2" fill="${c}"/></svg>`,
-  sort: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><path d="M12 12h20M12 22h15M12 32h10" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round"/><path d="M35 12v24m0 0l-6-6m6 6l6-6" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round" stroke-linejoin="round"/></svg>`,
-  // New: a name tag, for LetBinding naming a sub-expression for reuse.
-  bind: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><path d="M8 22V12a4 4 0 0 1 4-4h10l18 18-14 14L8 22z" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linejoin="round"/><circle cx="17" cy="17" r="2.4" fill="${c}"/></svg>`,
-};
-
-// New: a small flag/marker badge layered onto whichever node is a query's
-// root, since QueryExpr has no dedicated terminal "output" node kind the way
-// the reference's BGP `out_*` steps do.
-const ROOT_BADGE_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><path d="M14 12h20v9c0 8-4 13-10 15-6-2-10-7-10-15z" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><path d="M18 38h12M21 42h6" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round"/></svg>`;
-
 // name -> { label, description, light: {bg, border}, dark: {bg, border} }
 const CATEGORIES = {
   data: {
@@ -115,6 +101,24 @@ const CATEGORIES = {
     light: { bg: '#fff5ea', border: '#b45309' },
     dark: { bg: '#3a2408', border: '#fb923c' },
   },
+  // Post-ASAP only (post-ASAP lane): every other category
+  // above is a saturated, hand-picked hue for a pre-ASAP QueryExpr operator.
+  // `summary` is deliberately plain neutral gray instead of another hue —
+  // partly because a 10th saturated color starts getting hard to
+  // distinguish at a glance from its 9 neighbors (data's blue and sort's
+  // blue are already close), and partly because "materialized post-ASAP
+  // structure" reads better as a visually distinct *family* (muted,
+  // grayscale) than as one more member of the pre-ASAP rainbow. KeepPreAsap
+  // (unchanged pre-ASAP content passed through) gets its own even-more-muted
+  // override in viewer.js's buildCyStyle rather than its own category, since
+  // it's a variant *within* "post-ASAP" (something bothered to carry it
+  // through) rather than a different concept.
+  summary: {
+    label: 'Summary',
+    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures',
+    light: { bg: '#f1f2f4', border: '#4b5563' },
+    dark: { bg: '#20242b', border: '#9ca3af' },
+  },
 };
 
 const ROOT_BADGE = {
@@ -124,35 +128,10 @@ const ROOT_BADGE = {
   dark: { border: '#f87171' },
 };
 
-// `DagNote.kind` -> badge color, for a node whose `notes` array (issue #257 —
-// asap-aware-mapping's ReplacementExplanation, matched onto this node by
-// dag_export's own hash) is non-empty. Only the two kinds
-// asap_aware_mapping::ExplanationKind currently ships get their own entry;
-// NOTE_KIND_FALLBACK covers anything else (a future kind, or a node whose
-// notes mix more than one kind) without needing a new color per addition.
-const NOTE_KIND_COLOR = {
-  SketchApproximation: { light: '#a16207', dark: '#facc15' }, // reuses the 'aggregate' category hue
-  CommonSubexpressionReuse: { light: '#4f46e5', dark: '#a5b4fc' }, // reuses the 'set' category hue
-};
-const NOTE_KIND_FALLBACK = { light: '#334155', dark: '#cbd5e1' };
-const NOTE_BADGE_LABEL = {
-  SketchApproximation: 'Sketch alternative available',
-  CommonSubexpressionReuse: 'Shareable across consumers',
-};
-
-// Small "why" marker (a filled circle + exclamation mark) for a node whose
-// `notes` is non-empty — layered in the bottom-right corner, so it never
-// collides with the root badge (top-right) or the category icon (top-center).
-const NOTE_BADGE_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><circle cx="24" cy="24" r="17" fill="${c}"/><path d="M24 14v16" stroke="white" stroke-width="4" stroke-linecap="round"/><circle cx="24" cy="35" r="2.6" fill="white"/></svg>`;
-
 function isDarkMode() {
   return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
 }
 
-function svgDataUri(svg) {
-  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
-}
-
 function categoryOf(kind) {
   return KIND_CATEGORY[kind] || 'derive';
 }
@@ -162,52 +141,12 @@ function categoryColors(name) {
   return isDarkMode() ? cat.dark : cat.light;
 }
 
-function categoryIconDataUri(name) {
-  const { border } = categoryColors(name);
-  const icon = ICONS[name] || ICONS.derive;
-  return svgDataUri(icon(border));
-}
-
-function rootBadgeIconDataUri() {
-  const { border } = isDarkMode() ? ROOT_BADGE.dark : ROOT_BADGE.light;
-  return svgDataUri(ROOT_BADGE_ICON(border));
-}
-
-// The color a `notes` badge/chip should use for `kind` — one of
-// ExplanationKind's two known variants, or NOTE_KIND_FALLBACK for anything
-// else (future kind, or `noteBadgeColor`'s own "mixed kinds" case below).
-function noteKindColor(kind) {
-  const c = NOTE_KIND_COLOR[kind] || NOTE_KIND_FALLBACK;
-  return isDarkMode() ? c.dark : c.light;
-}
-
-// The color for a node's *badge* (as opposed to one note's own chip): the
-// shared color if every note on the node is the same kind, otherwise the
-// fallback — a node need not itself distinguish "two sketch findings" from
-// "a sketch finding and a reuse finding" the way the side-panel detail
-// (which lists each note individually) does.
-function noteBadgeColor(notes) {
-  const kinds = new Set((notes || []).map((n) => n.kind));
-  if (kinds.size === 1) return noteKindColor(notes[0].kind);
-  const c = NOTE_KIND_FALLBACK;
-  return isDarkMode() ? c.dark : c.light;
-}
-
-function noteBadgeIconDataUri(notes) {
-  return svgDataUri(NOTE_BADGE_ICON(noteBadgeColor(notes)));
-}
-
-// Mirror the palette into CSS custom properties so plain-DOM chrome (legend,
-// side panel chips) can use var(--cat-<name>-bg/border) instead of
-// duplicating these hex values in index.html's <style>. Cytoscape's own
-// stylesheet reads the JS tables directly (categoryColors/categoryIconDataUri)
-// since var() support in a vendored cytoscape build isn't something to rely on.
 function applyPaletteToCssVars() {
   const root = document.documentElement.style;
-  for (const [name, cat] of Object.entries(CATEGORIES)) {
-    const c = isDarkMode() ? cat.dark : cat.light;
-    root.setProperty(`--cat-${name}-bg`, c.bg);
-    root.setProperty(`--cat-${name}-border`, c.border);
+  for (const [name, category] of Object.entries(CATEGORIES)) {
+    const colors = isDarkMode() ? category.dark : category.light;
+    root.setProperty(`--cat-${name}-bg`, colors.bg);
+    root.setProperty(`--cat-${name}-border`, colors.border);
   }
   root.setProperty('--cat-output-border', (isDarkMode() ? ROOT_BADGE.dark : ROOT_BADGE.light).border);
 }
diff --git a/tools/dag-viewer/planner-ui.js b/tools/dag-viewer/planner-ui.js
new file mode 100644
index 00000000..21651f61
--- /dev/null
+++ b/tools/dag-viewer/planner-ui.js
@@ -0,0 +1,148 @@
+const plannerPanel = document.getElementById('plannerPanel');
+const plannerRows = document.getElementById('plannerRows');
+const plannerStatus = document.getElementById('plannerStatus');
+const schemaRows = document.getElementById('schemaRows');
+
+function addSchemaRow(schema = {}) {
+  const row = document.createElement('div');
+  row.className = 'schemaRow';
+  row.innerHTML = `
+    <input class="schemaInclude" type="checkbox" checked title="Include this table in the SQL catalog" />
+    <input class="schemaName" value="${escapeHtml(schema.name || `table_${schemaRows.children.length + 1}`)}" aria-label="Table name" />
+    <textarea class="schemaColumns" rows="5" aria-label="Columns">${escapeHtml(schema.columns || 'id       INT64       NOT NULL\nvalue    FLOAT64')}</textarea>
+    <input class="schemaTimeIndex" value="${escapeHtml(schema.timeIndex ?? '')}" placeholder="time column" aria-label="Time-index column" />
+    <button class="btn schemaRemove" type="button">Remove</button>`;
+  row.querySelector('.schemaRemove').addEventListener('click', () => {
+    row.remove();
+    refreshSchemaSelectors();
+  });
+  row.querySelectorAll('input, textarea').forEach((input) => input.addEventListener('input', refreshSchemaSelectors));
+  schemaRows.appendChild(row);
+  refreshSchemaSelectors();
+}
+
+function enabledSchemaNames() {
+  return Array.from(schemaRows.querySelectorAll('.schemaRow'))
+    .filter((row) => row.querySelector('.schemaInclude').checked)
+    .map((row) => row.querySelector('.schemaName').value.trim())
+    .filter(Boolean);
+}
+
+function refreshSchemaSelectors() {
+  const names = enabledSchemaNames();
+  plannerRows.querySelectorAll('.plannerRow').forEach((row) => {
+    const container = row.querySelector('.plannerSchemas');
+    const previous = new Set(Array.from(container.querySelectorAll('input:checked')).map((input) => input.value));
+    const promql = row.querySelector('.plannerLanguage').value === 'promql';
+    container.innerHTML = promql
+      ? '<span>Metric schema (inferred)</span>'
+      : names.map((name) => `<label><input type="checkbox" value="${escapeHtml(name)}" ${previous.has(name) ? 'checked' : ''}/>${escapeHtml(name)}</label>`).join('');
+  });
+}
+
+function parseSchemaRow(row) {
+  const columns = row.querySelector('.schemaColumns').value.split(/[\n,]+/).map((raw) => raw.trim()).filter(Boolean).map((raw) => {
+    const compact = raw.match(/^([^:\s]+):([a-zA-Z0-9]+)(!)?$/);
+    if (compact) return { name: compact[1], type: compact[2], nullable: !compact[3] };
+    const readable = raw.match(/^(\S+)\s+(\S+?)(?:\s+(NOT\s+NULL|NULL))?$/i);
+    if (!readable) throw new Error(`Invalid column ${raw}; use "name TYPE [NOT NULL]"`);
+    return {
+      name: readable[1],
+      type: readable[2],
+      nullable: !readable[3] || readable[3].toUpperCase() === 'NULL',
+    };
+  });
+  const timeName = row.querySelector('.schemaTimeIndex').value.trim();
+  const timeIndex = timeName ? columns.findIndex((column) => column.name === timeName) : -1;
+  if (timeName && timeIndex < 0) throw new Error(`Time column ${timeName} is not in the column list`);
+  return {
+    name: row.querySelector('.schemaName').value.trim(),
+    columns,
+    ...(timeIndex >= 0 ? { time_index: timeIndex } : {}),
+  };
+}
+
+function addPlannerRow(query = {}) {
+  const row = document.createElement('div');
+  row.className = 'plannerRow';
+  row.innerHTML = `
+    <input class="plannerInclude" type="checkbox" checked title="Include in workload" />
+    <input class="plannerName" value="${escapeHtml(query.name || `q${plannerRows.children.length + 1}`)}" aria-label="Query name" />
+    <select class="plannerLanguage" aria-label="Language"><option value="sql">SQL</option><option value="promql">PromQL</option></select>
+    <div class="plannerSchemas" aria-label="Input schemas"></div>
+    <textarea class="plannerText" aria-label="Query text" rows="2">${escapeHtml(query.text || 'SELECT service, COUNT(*) FROM metrics GROUP BY service')}</textarea>
+    <button class="btn plannerRemove" type="button">Remove</button>`;
+  row.querySelector('.plannerLanguage').value = query.language || 'sql';
+  row.querySelector('.plannerLanguage').addEventListener('change', refreshSchemaSelectors);
+  row.querySelector('.plannerRemove').addEventListener('click', () => row.remove());
+  plannerRows.appendChild(row);
+  refreshSchemaSelectors();
+  (query.schemas || (query.schema ? [query.schema] : [])).forEach((name) => {
+    const checkbox = Array.from(row.querySelectorAll('.plannerSchemas input')).find((input) => input.value === name);
+    if (checkbox) checkbox.checked = true;
+  });
+}
+
+document.getElementById('plannerToggle').addEventListener('click', () => plannerPanel.classList.toggle('visible'));
+document.getElementById('plannerAdd').addEventListener('click', () => addPlannerRow({ text: '' }));
+document.getElementById('schemaAdd').addEventListener('click', () => addSchemaRow());
+document.getElementById('plannerRun').addEventListener('click', async () => {
+  const rows = Array.from(plannerRows.querySelectorAll('.plannerRow')).filter((row) => row.querySelector('.plannerInclude').checked);
+  const queries = rows.map((row) => ({
+    name: row.querySelector('.plannerName').value,
+    language: row.querySelector('.plannerLanguage').value,
+    schemas: Array.from(row.querySelectorAll('.plannerSchemas input:checked')).map((input) => input.value),
+    text: row.querySelector('.plannerText').value,
+  }));
+  plannerStatus.textContent = 'Running pre-ASAP lowering and ASAP-aware mapping…';
+  document.getElementById('plannerRun').disabled = true;
+  try {
+    const response = await fetch('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/api/plan', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        queries,
+        schemas: Array.from(schemaRows.querySelectorAll('.schemaRow'))
+          .filter((row) => row.querySelector('.schemaInclude').checked)
+          .map(parseSchemaRow),
+        epsilon: Number(document.getElementById('plannerEpsilon').value),
+      }),
+    });
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.error || `HTTP ${response.status}`);
+    window.renderPlannerWorkload(result);
+    plannerStatus.textContent = `Planned ${result.queries.length} queries. Select one or several tabs above.`;
+  } catch (error) {
+    plannerStatus.textContent = `Planning failed: ${error.message}. Start this page with server.py.`;
+  } finally {
+    document.getElementById('plannerRun').disabled = false;
+  }
+});
+
+addSchemaRow({
+  name: 'metrics',
+  columns: 'ts         TIMESTAMP   NOT NULL\nservice    UTF8        NOT NULL\nregion     UTF8        NOT NULL\nlatency    FLOAT64     NOT NULL\nbytes      INT64       NOT NULL',
+  timeIndex: 'ts',
+});
+addSchemaRow({
+  name: 'hosts',
+  columns: 'service    UTF8        NOT NULL\nregion     UTF8        NOT NULL',
+});
+addPlannerRow({ name: 'count_by_service', schemas: ['metrics'] });
+addPlannerRow({ name: 'avg_latency', schemas: ['metrics'], text: 'SELECT service, AVG(latency) FROM metrics GROUP BY service' });
+addPlannerRow({
+  name: 'q3',
+  language: 'promql',
+  text: 'topk(5, rate(http_requests_total[5m]))',
+});
+addPlannerRow({
+  name: 'q6',
+  language: 'sql',
+  schemas: ['metrics', 'hosts'],
+  text: 'SELECT metrics.service, COUNT(*) FROM metrics JOIN hosts ON metrics.service = hosts.service GROUP BY metrics.service',
+});
+addPlannerRow({
+  name: 'q4',
+  language: 'promql',
+  text: 'topk(10, rate(http_requests_total[5m]))',
+});
diff --git a/tools/dag-viewer/post_asap_fixture.json b/tools/dag-viewer/post_asap_fixture.json
new file mode 100644
index 00000000..a680d28f
--- /dev/null
+++ b/tools/dag-viewer/post_asap_fixture.json
@@ -0,0 +1,149 @@
+{
+  "queries": [
+    {
+      "name": "p95_pktlen",
+      "source": "SELECT srcip, approx_percentile_cont(pkt_len, 0.95) AS p95_pkt_len FROM netflow_table GROUP BY srcip",
+      "graph": {
+        "nodes": [
+          { "id": 0, "kind": "Scan", "label": "Scan(netflow_table)", "detail": {"source": {"Table": {"table_ref": "netflow_table"}}}, "children": [], "hash": 111 },
+          { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "quantile", "q": 0.95, "col": 6, "accuracy": {"Epsilon": 0.01}}], "output_names": ["approx_percentile_cont(netflow_table.pkt_len,Float64(0.95))"], "reduction": {"Reduce": [1]}}, "children": [0], "hash": 222,
+            "notes": [{"kind": "SketchApproximation", "reason": "quantile(q=0.95) realizes as a Kll sketch — one of summary_candidates' alternatives for this intent"}] },
+          { "id": 2, "kind": "Project", "label": "Project(2 cols)", "detail": {"cols": [{"expr": {"Column": 0}}, {"alias": "p95_pkt_len", "expr": {"Column": 1}}]}, "children": [1], "hash": 333 }
+        ],
+        "root": 2
+      },
+      "post_graph": {
+        "nodes": [
+          { "id": 0, "kind": "KeepPreAsap", "label": "KeepPreAsap(Scan)", "detail": {"pre_asap_subgraph": {"nodes": [{"id": 0, "kind": "Scan", "label": "Scan(netflow_table)", "detail": {}, "children": []}], "root": 0}}, "children": [] },
+          { "id": 1, "kind": "SummaryAgg", "label": "SummaryAgg(Kll)", "detail": {"family": {"Sketch": ["Kll", {"k": 200}]}, "col": {"Column": 6}, "reduction": {"Reduce": [1]}, "grouping": "PerSubpopulationInstance"}, "children": [0], "origin_pre_id": 1 },
+          { "id": 2, "kind": "KeepPreAsap", "label": "KeepPreAsap(Project)", "detail": {"pre_asap_subgraph": {"nodes": [{"id": 0, "kind": "Project", "label": "Project(2 cols)", "detail": {}, "children": []}], "root": 0}}, "children": [1] }
+        ],
+        "root": 2
+      },
+      "replacements": [
+        {
+          "target_pre_id": 1,
+          "strategy": "Sketch",
+          "provenance": "SummaryImplementation",
+          "rationale": "quantile(q=0.95) realizes as a Kll sketch (rank 1 of 2 candidates, est. cost 1024 bytes/group) — DDSketch was the runner-up.",
+          "rank": 0,
+          "cost": 1024.0,
+          "before": {
+            "nodes": [
+              { "id": 0, "kind": "Scan", "label": "Scan(netflow_table)", "detail": {"source": {"Table": {"table_ref": "netflow_table"}}}, "children": [], "hash": 111 },
+              { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "quantile", "q": 0.95, "col": 6}]}, "children": [0], "hash": 222 }
+            ],
+            "root": 1
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                { "id": 0, "kind": "KeepPreAsap", "label": "KeepPreAsap(Scan)", "detail": {"pre_asap_subgraph": {"nodes": [{"id": 0, "kind": "Scan", "label": "Scan(netflow_table)", "detail": {}, "children": [], "hash": 111}], "root": 0}}, "children": [] },
+                { "id": 1, "kind": "SummaryAgg", "label": "SummaryAgg(Kll)", "detail": {"family": {"Sketch": ["Kll", {"k": 200}]}, "col": {"Column": 6}, "reduction": {"Reduce": [1]}, "grouping": "PerSubpopulationInstance"}, "children": [0], "origin_pre_id": 1 }
+              ],
+              "root": 1
+            }
+          }
+        },
+        {
+          "target_pre_id": 1,
+          "strategy": "HydraGrouping",
+          "provenance": "SummaryImplementation",
+          "rationale": "This grouped aggregate's Kll sketch can instead be realized as one shared Hydra-Kll structure over every srcip subpopulation, instead of one instance per distinct srcip — legal here, but ranked below the per-subpopulation instance because the estimated per-key cardinality is too low for the shared layout to pay off.",
+          "rank": 1,
+          "cost": 4096.0,
+          "before": {
+            "nodes": [
+              { "id": 0, "kind": "Scan", "label": "Scan(netflow_table)", "detail": {}, "children": [], "hash": 111 },
+              { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "quantile", "q": 0.95, "col": 6}]}, "children": [0], "hash": 222 }
+            ],
+            "root": 1
+          },
+          "after": {
+            "kind": "Summary",
+            "graph": {
+              "nodes": [
+                { "id": 0, "kind": "KeepPreAsap", "label": "KeepPreAsap(Scan)", "detail": {}, "children": [] },
+                { "id": 1, "kind": "SummaryAgg", "label": "SummaryAgg(HydraKll)", "detail": {"family": {"Sketch": ["Kll", {"k": 200}]}, "grouping": {"SharedMultiSubpopulation": {"params": {}}}}, "children": [0], "origin_pre_id": 1 }
+              ],
+              "root": 1
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "avg_latency",
+      "source": "SELECT service, AVG(latency) FROM metrics GROUP BY service",
+      "graph": {
+        "nodes": [
+          { "id": 0, "kind": "Scan", "label": "Scan(metrics)", "detail": {"source": {"Table": {"table_ref": "metrics"}}}, "children": [], "hash": 444 },
+          { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "avg", "col": 3}], "output_names": ["avg(metrics.latency)"]}, "children": [0], "hash": 555 },
+          { "id": 2, "kind": "Project", "label": "Project(2 cols)", "detail": {"cols": [{"expr": {"Column": 0}}, {"expr": {"Column": 1}}]}, "children": [1], "hash": 666 }
+        ],
+        "root": 2
+      },
+      "replacements": [
+        {
+          "target_pre_id": 1,
+          "strategy": "AvgToSumRewrite",
+          "provenance": "LogicalRewrite",
+          "rationale": "avg(latency) has no summary realization of its own (PassThrough) — rewritten into sum(latency)/count(*) so the sketch/CSE strategies below now have a mergeable accumulator to work with.",
+          "rank": 0,
+          "cost": 0.0,
+          "before": {
+            "nodes": [
+              { "id": 0, "kind": "Scan", "label": "Scan(metrics)", "detail": {}, "children": [], "hash": 444 },
+              { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "avg", "col": 3}]}, "children": [0], "hash": 555 }
+            ],
+            "root": 1
+          },
+          "after": {
+            "kind": "Rewrite",
+            "graph": {
+              "nodes": [
+                { "id": 0, "kind": "Scan", "label": "Scan(metrics)", "detail": {}, "children": [], "hash": 444 },
+                { "id": 1, "kind": "Aggregate", "label": "Aggregate(2 measures)", "detail": {"measures": [{"kind": "sum", "col": 3}, {"kind": "count"}], "output_names": ["sum(metrics.latency)", "count(*)"]}, "children": [0], "hash": 777 },
+                { "id": 2, "kind": "Project", "label": "Project(1 cols)", "detail": {"cols": [{"alias": "avg(metrics.latency)", "expr": {"BinaryOp": {"op": "Div", "left": {"Column": 0}, "right": {"Column": 1}}}}]}, "children": [1], "hash": 888 }
+              ],
+              "root": 2
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "cse_share_demo",
+      "source": "-- q_a -- SELECT service, COUNT(*) FROM metrics GROUP BY service ;\n-- q_b -- SELECT service, COUNT(*) FROM metrics WHERE region='us' GROUP BY service",
+      "graph": {
+        "nodes": [
+          { "id": 0, "kind": "Scan", "label": "Scan(metrics)", "detail": {}, "children": [], "hash": 111 },
+          { "id": 1, "kind": "Aggregate", "label": "Aggregate(1 measures)", "detail": {"measures": [{"kind": "count"}]}, "children": [0], "hash": 999 }
+        ],
+        "root": 1
+      },
+      "replacements": [
+        {
+          "target_pre_id": 0,
+          "strategy": "SharedSubtree",
+          "provenance": "CseShare",
+          "rationale": "Scan(metrics) has 2 consumers across this workload — building it once and sharing the Rc beats recomputing it independently per consumer at this estimated row count.",
+          "rank": 0,
+          "cost": 12.0,
+          "before": {
+            "nodes": [ { "id": 0, "kind": "Scan", "label": "Scan(metrics)", "detail": {}, "children": [], "hash": 111 } ],
+            "root": 0
+          },
+          "after": {
+            "kind": "Rewrite",
+            "graph": {
+              "nodes": [ { "id": 0, "kind": "Scan", "label": "Scan(metrics)  [shared, 2 consumers]", "detail": {}, "children": [], "hash": 111 } ],
+              "root": 0
+            }
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index a8566286..2059597f 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-"""Bake one or more dag_export WorkloadGraph JSON files into a single,
-portable HTML page — the same tools/dag-viewer UI (Single/Compare/Union,
-click-to-inspect, shared-subtree/CSE highlighting) as index.html, but with
+"""Bake WorkloadGraph JSON into a single, portable Pre/Post-ASAP HTML page,
+with the same query selection, workload-union, and node details as index.html,
+but with
 the vendored JS libraries and the query data all inlined into one file.
 
 Why this exists alongside index.html:
@@ -30,7 +30,7 @@
   cargo run -p asap-devtools --bin dag_export -- --sql "..." --name q1 \\
     | python3 tools/dag-viewer/render.py -o rendered.html
 
-  python3 tools/dag-viewer/render.py dag1.json dag2.json -o rendered.html --mode union
+  python3 tools/dag-viewer/render.py dag1.json dag2.json -o rendered.html
 
 Multiple input files are merged exactly like index.html's multi-file drop: a
 query name colliding with an earlier one is disambiguated by suffixing the
@@ -42,6 +42,7 @@
 import argparse
 import copy
 import json
+import re
 import sys
 from pathlib import Path
 
@@ -52,7 +53,7 @@
 # embedded data and mode override must land immediately before it in
 # document order (its startup code reads both synchronously as soon as it
 # runs) — see viewer.js's header comment.
-_INLINE_LIBS = ("dagre.min.js", "cytoscape.min.js", "cytoscape-dagre.js", "node-style.js")
+_INLINE_LIBS = ("dagre.min.js", "cytoscape.min.js", "cytoscape-dagre.js", "node-style.js", "planner-ui.js")
 
 
 def _compact(value: object) -> str:
@@ -69,6 +70,8 @@ def _compact(value: object) -> str:
         return ", ".join(_compact(item) for item in value) or "none"
     if not isinstance(value, dict):
         return str(value)
+
+    # Common serde enum/newtype shapes in QueryExpr detail.
     if set(value) == {"Column"}:
         return f"col[{_compact(value['Column'])}]"
     if set(value) == {"Table"} and isinstance(value["Table"], dict):
@@ -83,39 +86,49 @@ def _compact(value: object) -> str:
     return ", ".join(f"{key}={_compact(item)}" for key, item in value.items())
 
 
-def _column(value: object) -> str:
+def _column(value: object, input_schema: object = None) -> str:
     if isinstance(value, int):
+        if isinstance(input_schema, dict):
+            columns = input_schema.get("columns")
+            if isinstance(columns, list) and value < len(columns):
+                column = columns[value]
+                if isinstance(column, dict) and column.get("name"):
+                    return str(column["name"])
         return f"col[{value}]"
     return _compact(value)
 
 
-def _measure(value: object) -> str:
+def _measure(value: object, input_schema: object = None) -> str:
     if not isinstance(value, dict):
         return _compact(value)
     kind = str(value.get("kind", "aggregate"))
     args = []
     if value.get("col") is not None:
-        args.append(_column(value["col"]))
+        args.append(_column(value["col"], input_schema))
     for key in ("q", "k", "population", "label", "lower", "upper"):
         if key in value:
             args.append(f"{key}={_compact(value[key])}")
-    accuracy = value.get("accuracy")
-    if isinstance(accuracy, dict) and len(accuracy) == 1:
-        name, amount = next(iter(accuracy.items()))
-        args.append(f"{name.lower()}={_compact(amount)}")
     return f"{kind}({', '.join(args)})" if args else f"{kind}()"
 
 
-def _grouping(reduction: object) -> str | None:
+def _bounded_lines(lines: list[str], maximum: int = 4, width: int = 64) -> str:
+    """Keep graph boxes scannable; the sidebar owns the lossless detail."""
+    shortened = [line if len(line) <= width else line[: width - 1] + "…" for line in lines]
+    if len(shortened) > maximum:
+        shortened = shortened[: maximum - 1] + [f"… +{len(shortened) - maximum + 1} more"]
+    return "\n".join(shortened)
+
+
+def _grouping(reduction: object, input_schema: object = None) -> str | None:
     if reduction == "PerEntity":
         return "per entity"
     if not isinstance(reduction, dict) or "Reduce" not in reduction:
         return None
     keys = reduction["Reduce"]
     if isinstance(keys, dict) and "without" in keys:
-        return "group without " + ", ".join(_column(key) for key in keys["without"])
+        return "group without " + ", ".join(_column(key, input_schema) for key in keys["without"])
     if isinstance(keys, list):
-        return "group by " + (", ".join(_column(key) for key in keys) or "all rows")
+        return "group by " + (", ".join(_column(key, input_schema) for key in keys) or "all rows")
     return "group by " + _compact(keys)
 
 
@@ -128,20 +141,28 @@ def _sort_key(value: object) -> str:
     return f"{expr} {direction}, {nulls}"
 
 
-def _semantic_label(node: dict) -> str:
+def _semantic_label(node: dict, input_schema: object = None) -> str:
     """Build a box label from a node's concrete IR fields, not its summary."""
     kind = str(node.get("kind", "Node"))
     detail = node.get("detail") or {}
     if not isinstance(detail, dict):
         return f"{kind}\n{_compact(detail)}"
+
     lines = [kind]
     if kind == "Scan":
-        lines.append(f"source: {_compact(detail.get('source', 'unknown'))}")
+        source = detail.get("source")
+        if source is None:
+            # Older/demo fixtures sometimes kept the source only in the
+            # exporter label ("Scan(metrics)") and left detail empty.
+            match = re.fullmatch(r"Scan\(([^)]+)\)(?:\s+.*)?", str(node.get("label", "")))
+            source = match.group(1) if match else "unknown"
+        lines.append(f"source: {_compact(source)}")
         if detail.get("predicates"):
             lines.append(f"where: {_compact(detail['predicates'])}")
     elif kind == "Aggregate":
-        lines.extend(f"compute: {_measure(measure)}" for measure in detail.get("measures") or [])
-        grouping = _grouping(detail.get("reduction"))
+        measures = detail.get("measures") or []
+        lines.extend(f"measure: {_measure(measure, input_schema)}" for measure in measures)
+        grouping = _grouping(detail.get("reduction"), input_schema)
         if grouping:
             lines.append(grouping)
         if detail.get("having"):
@@ -151,13 +172,13 @@ def _semantic_label(node: dict) -> str:
         if detail.get("partition_by"):
             lines.append(f"within: {_compact(detail['partition_by'])}")
     elif kind == "Project":
-        for item in detail.get("cols") or []:
-            if isinstance(item, dict):
-                expr = _compact(item.get("expr"))
-                alias = item.get("alias")
-                lines.append(f"output: {expr}" + (f" as {alias}" if alias else ""))
-            else:
-                lines.append(f"output: {_compact(item)}")
+        output_schema = node.get("schema")
+        output_columns = output_schema.get("columns") if isinstance(output_schema, dict) else None
+        if isinstance(output_columns, list) and output_columns:
+            names = [str(column.get("name", "?")) for column in output_columns if isinstance(column, dict)]
+            lines.append("columns: " + ", ".join(names))
+        else:
+            lines.append(f"columns: {len(detail.get('cols') or [])}")
     elif kind == "Filter":
         lines.append(f"where: {_compact(detail.get('pred'))}")
     elif kind == "Join":
@@ -172,9 +193,18 @@ def _semantic_label(node: dict) -> str:
         lines.append(f"operation: {_compact(detail.get('op'))}")
         if detail.get("vector_match"):
             lines.append(f"match: {_compact(detail['vector_match'])}")
-    elif kind in {"SummaryAgg", "SummaryJoin"}:
+    elif kind == "SummaryAgg":
         lines.append(f"family: {_compact(detail.get('family'))}")
-        for key in ("col", "key", "reduction", "grouping"):
+        if "col" in detail:
+            lines.append(f"input: {_column(detail['col'])}")
+        reduction = _grouping(detail.get("reduction"), input_schema)
+        if reduction:
+            lines.append(reduction)
+        if "grouping" in detail:
+            lines.append(f"summary layout: {_compact(detail['grouping'])}")
+    elif kind == "SummaryJoin":
+        lines.append(f"family: {_compact(detail.get('family'))}")
+        for key in ("key", "grouping"):
             if key in detail:
                 lines.append(f"{key}: {_compact(detail[key])}")
     elif kind == "SummaryEstimate":
@@ -188,10 +218,13 @@ def _semantic_label(node: dict) -> str:
         root = next((item for item in nested_nodes if item.get("id") == nested_root), None)
         lines.append(f"unchanged: {root.get('kind', 'pre-ASAP subtree') if root else 'pre-ASAP subtree'}")
     else:
+        # Less common variants still show their own scalar IR fields. Avoid
+        # schema/subgraph blobs, which belong in the click-to-inspect panel.
         for key, value in detail.items():
             if key not in {"schema", "pre_asap_subgraph"} and value not in (None, [], {}):
                 lines.append(f"{key}: {_compact(value)}")
-    return "\n".join(lines)
+
+    return _bounded_lines(lines)
 
 
 def prepare_workload(workload: dict) -> dict:
@@ -201,18 +234,21 @@ def prepare_workload(workload: dict) -> dict:
     def prepare_graph(graph: object) -> None:
         if not isinstance(graph, dict):
             return
+        by_id = {node.get("id"): node for node in graph.get("nodes", [])}
         for node in graph.get("nodes", []):
-            node["label"] = _semantic_label(node)
+            child = by_id.get((node.get("children") or [None])[0])
+            input_schema = (
+                child.get("schema") or (child.get("detail") or {}).get("schema")
+                if isinstance(child, dict)
+                else None
+            )
+            node["label"] = _semantic_label(node, input_schema)
             nested = (node.get("detail") or {}).get("pre_asap_subgraph")
             prepare_graph(nested)
 
     for query in prepared.get("queries", []):
         prepare_graph(query.get("graph"))
         prepare_graph(query.get("post_graph"))
-        for replacement in query.get("replacements", []):
-            prepare_graph(replacement.get("before"))
-            after = replacement.get("after") or {}
-            prepare_graph(after.get("graph"))
     return prepared
 
 
@@ -242,7 +278,7 @@ def _json_script(obj: object) -> str:
     return json.dumps(obj).replace("<", "\\u003c")
 
 
-def render(workload: dict, mode: str) -> str:
+def render(workload: dict) -> str:
     workload = prepare_workload(workload)
     html = (HERE / "index.html").read_text()
 
@@ -253,13 +289,12 @@ def render(workload: dict, mode: str) -> str:
         html = html.replace(tag, f"<script>\n{(HERE / name).read_text()}\n</script>", 1)
 
     embedded = f'<script type="application/json" id="embedded-workload">{_json_script(workload)}</script>'
-    config = f"<script>window.__DAG_RENDER__ = {_json_script({'mode': mode})};</script>\n" if mode != "single" else ""
     viewer_tag = '<script src="viewer.js"></script>'
     if viewer_tag not in html:
         raise RuntimeError(f"render.py: expected to find {viewer_tag!r} in index.html — did it move or get renamed?")
     html = html.replace(
         viewer_tag,
-        f"{embedded}\n{config}<script>\n{(HERE / 'viewer.js').read_text()}\n</script>",
+        f"{embedded}\n<script>\n{(HERE / 'viewer.js').read_text()}\n</script>",
         1,
     )
     return html
@@ -277,12 +312,6 @@ def main() -> None:
         help="dag_export WorkloadGraph JSON file(s); reads stdin if none are given",
     )
     parser.add_argument("-o", "--output", type=Path, required=True, help="output HTML file path")
-    parser.add_argument(
-        "--mode",
-        choices=["single", "compare", "union"],
-        default="single",
-        help="view mode the page opens into; compare/union pre-select every loaded query (default: single)",
-    )
     args = parser.parse_args()
 
     try:
@@ -297,14 +326,7 @@ def main() -> None:
     if not workload.get("queries"):
         print("render.py: no queries in input — nothing to render", file=sys.stderr)
         sys.exit(1)
-    if args.mode != "single" and len(workload["queries"]) < 2:
-        print(
-            f"render.py: --mode {args.mode} needs 2+ queries to do anything "
-            f"(got {len(workload['queries'])}) — the page will just show its 'select more' hint",
-            file=sys.stderr,
-        )
-
-    args.output.write_text(render(workload, args.mode))
+    args.output.write_text(render(workload))
     n = len(workload["queries"])
     print(f"wrote {args.output} ({n} quer{'y' if n == 1 else 'ies'})")
 
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
new file mode 100644
index 00000000..552abb81
--- /dev/null
+++ b/tools/dag-viewer/server.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""Local interactive server for planning query workloads and viewing IR DAGs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import tempfile
+import threading
+from http import HTTPStatus
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from render import prepare_workload
+
+HERE = Path(__file__).resolve().parent
+REPO = HERE.parents[1]
+BINARY = REPO / "target" / "debug" / "dag_export"
+
+
+def build_exporter() -> None:
+    subprocess.run(
+        ["cargo", "build", "-q", "-p", "asap-devtools", "--bin", "dag_export"],
+        cwd=REPO,
+        check=True,
+    )
+
+
+def plan_workload(payload: dict) -> dict:
+    queries = payload.get("queries")
+    if not isinstance(queries, list) or not queries or len(queries) > 50:
+        raise ValueError("queries must contain 1–50 entries")
+    epsilon = float(payload.get("epsilon", 0.01))
+    if not 0 < epsilon < 1:
+        raise ValueError("epsilon must be between 0 and 1")
+
+    schemas = payload.get("schemas", [])
+    if not isinstance(schemas, list) or len(schemas) > 50:
+        raise ValueError("schemas must be an array with at most 50 tables")
+
+    args = [str(BINARY), "--post-asap", "--progress", "--epsilon", str(epsilon)]
+    schema_names: set[str] = set()
+    for index, schema in enumerate(schemas, 1):
+        if not isinstance(schema, dict):
+            raise ValueError(f"schema #{index} must be an object")
+        name = schema.get("name")
+        columns = schema.get("columns")
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError(f"schema #{index}: name is required")
+        if name in schema_names:
+            raise ValueError(f"schema #{index}: duplicate table name {name}")
+        schema_names.add(name)
+        if not isinstance(columns, list) or not columns or len(columns) > 500:
+            raise ValueError(f"schema #{index}: columns must contain 1–500 entries")
+        args.extend(["--table-schema", json.dumps(schema, separators=(",", ":"))])
+    for index, query in enumerate(queries, 1):
+        if not isinstance(query, dict):
+            raise ValueError(f"query #{index} must be an object")
+        language = query.get("language", "sql")
+        text = query.get("text")
+        name = query.get("name") or f"q{index}"
+        if language not in {"sql", "promql"}:
+            raise ValueError(f"query #{index}: language must be sql or promql")
+        if not isinstance(text, str) or not text.strip() or len(text) > 100_000:
+            raise ValueError(f"query #{index}: text must contain 1–100000 characters")
+        selected_schemas = query.get("schemas", [])
+        if language == "sql" and (
+            not isinstance(selected_schemas, list)
+            or any(schema not in schema_names for schema in selected_schemas)
+        ):
+            raise ValueError(f"query #{index}: selected schemas must all be enabled")
+        args.extend([f"--{language}", text, "--name", str(name)])
+
+    print(f"\n[planner] Received workload with {len(queries)} quer{'y' if len(queries) == 1 else 'ies'}", flush=True)
+    stderr_lines: list[str] = []
+    with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as stdout_file:
+        process = subprocess.Popen(
+            args,
+            cwd=REPO,
+            text=True,
+            stdout=stdout_file,
+            stderr=subprocess.PIPE,
+        )
+
+        def relay_stderr() -> None:
+            assert process.stderr is not None
+            for line in process.stderr:
+                line = line.rstrip()
+                stderr_lines.append(line)
+                print(f"[planner] {line}", flush=True)
+
+        relay = threading.Thread(target=relay_stderr, daemon=True)
+        relay.start()
+        try:
+            returncode = process.wait(timeout=120)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+            relay.join()
+            raise
+        relay.join()
+        stdout_file.seek(0)
+        stdout = stdout_file.read()
+
+    stderr = "\n".join(stderr_lines)
+    if returncode != 0:
+        raise RuntimeError(stderr.strip() or "dag_export failed")
+    workload = prepare_workload(json.loads(stdout))
+    workload["planner_stderr"] = stderr
+    print(f"[planner] Complete: generated {len(workload.get('queries', []))} pre/post DAG pairs", flush=True)
+    return workload
+
+
+class Handler(SimpleHTTPRequestHandler):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=str(HERE), **kwargs)
+
+    def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
+        if self.path != "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/api/plan":
+            self.send_error(HTTPStatus.NOT_FOUND)
+            return
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+            if length <= 0 or length > 5_000_000:
+                raise ValueError("request body must contain at most 5 MB")
+            payload = json.loads(self.rfile.read(length))
+            response = plan_workload(payload)
+            self._send_json(HTTPStatus.OK, response)
+        except (ValueError, json.JSONDecodeError) as error:
+            self._send_json(HTTPStatus.BAD_REQUEST, {"error": str(error)})
+        except subprocess.TimeoutExpired:
+            self._send_json(HTTPStatus.GATEWAY_TIMEOUT, {"error": "planning exceeded 120 seconds"})
+        except Exception as error:  # surface planner failures to this local UI
+            self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
+
+    def do_GET(self) -> None:  # noqa: N802 - stdlib handler API
+        if self.path == "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/api/example":
+            try:
+                example = json.loads((HERE / "dag.example.json").read_text(encoding="utf-8"))
+                self._send_json(HTTPStatus.OK, prepare_workload(example))
+            except Exception as error:
+                self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
+            return
+        super().do_GET()
+
+    def end_headers(self) -> None:
+        # This is a local development viewer: stale HTML/JS/example JSON is
+        # more harmful than the tiny files are expensive to reload.
+        self.send_header("Cache-Control", "no-store, max-age=0")
+        super().end_headers()
+
+    def _send_json(self, status: HTTPStatus, value: object) -> None:
+        body = json.dumps(value).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--skip-build", action="store_true", help="use an already-built target/debug/dag_export")
+    args = parser.parse_args()
+    if not args.skip_build:
+        build_exporter()
+    if not BINARY.exists():
+        parser.error(f"{BINARY} does not exist; start without --skip-build")
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    print(f"ASAP DAG viewer: http://{args.host}:{args.port}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nStopped.")
+    finally:
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index 21815de5..6966287e 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -98,12 +98,12 @@ def test_no_script_src_tags_remain(self):
         # usage in prose) once that file is inlined verbatim -- so match the
         # real tag shape instead of a bare substring.
         workload = {"queries": [named_graph("q1"), named_graph("q2")]}
-        html = render(workload, mode="single")
+        html = render(workload)
         self.assertNotRegex(html, r'<script src="[^"]+"></script>')
 
     def test_embedded_workload_round_trips(self):
         workload = {"queries": [named_graph("q1"), named_graph("q2")]}
-        html = render(workload, mode="single")
+        html = render(workload)
 
         m = re.search(
             r'<script type="application/json" id="embedded-workload">(.*?)</script>',
@@ -116,44 +116,35 @@ def test_embedded_workload_round_trips(self):
     def test_render_does_not_mutate_callers_workload(self):
         workload = {"queries": [named_graph("q1")]}
         original = json.loads(json.dumps(workload))
-        render(workload, mode="single")
+        render(workload)
         self.assertEqual(workload, original)
 
-    def test_single_mode_adds_no_render_config(self):
+    def test_render_adds_no_legacy_mode_config(self):
         # Bare "__DAG_RENDER__" also matches viewer.js's own header comment
         # (which documents the window.__DAG_RENDER__ config object in prose)
         # once that file is inlined verbatim -- match the actual assignment
         # statement instead.
         workload = {"queries": [named_graph("q1"), named_graph("q2")]}
-        html = render(workload, mode="single")
+        html = render(workload)
         self.assertNotRegex(html, r"window\.__DAG_RENDER__ =")
 
-    def test_non_single_mode_sets_render_config(self):
-        workload = {"queries": [named_graph("q1"), named_graph("q2")]}
-        html = render(workload, mode="union")
-        m = re.search(r"window\.__DAG_RENDER__ = (\{.*?\});", html)
-        self.assertIsNotNone(m, "__DAG_RENDER__ assignment not found")
-        self.assertEqual(json.loads(m.group(1)), {"mode": "union"})
-
     def test_embedded_data_placed_before_viewer_js_body(self):
         # viewer.js's top-level startup code reads #embedded-workload and
-        # window.__DAG_RENDER__ synchronously as soon as it runs, so both
-        # must appear earlier in the document than viewer.js's own inlined
+        # synchronously as soon as it runs, so it must appear earlier in the
+        # document than viewer.js's own inlined
         # <script> block.
         workload = {"queries": [named_graph("q1"), named_graph("q2")]}
-        html = render(workload, mode="union")
+        html = render(workload)
         embedded_pos = html.index('id="embedded-workload"')
-        config_pos = html.index("__DAG_RENDER__ =")
         viewer_pos = html.index("cytoscape.use(window.cytoscapeDagre)")  # viewer.js's first line
         self.assertLess(embedded_pos, viewer_pos)
-        self.assertLess(config_pos, viewer_pos)
 
     def test_angle_bracket_in_query_source_does_not_break_out_of_script_tag(self):
         # A pathological (but legal JSON) query source containing a literal
         # "</script>" substring must not prematurely close the embedded
         # <script type="application/json"> tag when the browser parses it.
         workload = {"queries": [named_graph("q1", source="SELECT '</script><script>evil()</script>'")]}
-        html = render(workload, mode="single")
+        html = render(workload)
 
         m = re.search(
             r'<script type="application/json" id="embedded-workload">(.*?)</script>',
@@ -173,14 +164,86 @@ def test_escapes_angle_bracket_but_stays_valid_json(self):
 
 
 class SemanticLabelTests(unittest.TestCase):
+    def test_scan_recovers_source_from_legacy_label(self):
+        node = {"kind": "Scan", "label": "Scan(metrics)", "detail": {}}
+        self.assertEqual(_semantic_label(node), "Scan\nsource: metrics")
+
     def test_aggregate_names_measure_input_and_grouping(self):
-        node = {"kind": "Aggregate", "detail": {"measures": [{"kind": "quantile", "col": 6, "q": 0.95}], "reduction": {"Reduce": [1]}}}
-        self.assertEqual(_semantic_label(node), "Aggregate\ncompute: quantile(col[6], q=0.95)\ngroup by col[1]")
+        node = {
+            "kind": "Aggregate",
+            "detail": {
+                "measures": [{"kind": "quantile", "col": 6, "q": 0.95}],
+                "reduction": {"Reduce": [1]},
+            },
+        }
+        self.assertEqual(
+            _semantic_label(node),
+            "Aggregate\nmeasure: quantile(col[6], q=0.95)\ngroup by col[1]",
+        )
+
+    def test_summary_aggregate_names_reduction_as_group_by(self):
+        node = {
+            "kind": "SummaryAgg",
+            "detail": {
+                "family": "Sketch(Cms)",
+                "col": "SampleValue",
+                "reduction": {"Reduce": [1]},
+                "grouping": "PerSubpopulationInstance",
+            },
+        }
+        self.assertEqual(
+            _semantic_label(node),
+            "SummaryAgg\nfamily: Sketch(Cms)\ninput: SampleValue\n… +2 more",
+        )
 
     def test_sort_names_expression_direction_and_null_order(self):
-        node = {"kind": "Sort", "detail": {"keys": [{"expr": {"Column": 2}, "ascending": False, "nulls_first": True}]}}
+        node = {
+            "kind": "Sort",
+            "detail": {
+                "keys": [{"expr": {"Column": 2}, "ascending": False, "nulls_first": True}]
+            },
+        }
         self.assertEqual(_semantic_label(node), "Sort\nsort: col[2] descending, nulls first")
 
+    def test_prepares_before_after_and_whole_post_asap_graphs(self):
+        node = {
+            "id": 0,
+            "kind": "Aggregate",
+            "label": "Aggregate(1 measures)",
+            "detail": {"measures": [{"kind": "avg", "col": 3}]},
+            "children": [],
+        }
+        def graph():
+            return {"nodes": [dict(node)], "root": 0}
+        workload = {
+            "queries": [
+                {
+                    "graph": graph(),
+                    "post_graph": graph(),
+                    "replacements": [{"before": graph(), "after": {"graph": graph()}}],
+                }
+            ]
+        }
+        prepared = prepare_workload(workload)
+        query = prepared["queries"][0]
+        labels = [
+            query["graph"]["nodes"][0]["label"],
+            query["post_graph"]["nodes"][0]["label"],
+        ]
+        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 2)
+        self.assertEqual(
+            query["replacements"][0]["before"]["nodes"][0]["label"],
+            "Aggregate(1 measures)",
+        )
+
+    def test_replacement_subgraphs_are_not_prepared_for_the_current_viewer(self):
+        def graph():
+            return {"nodes": [{"id": 0, "kind": "Scan", "label": "legacy", "detail": {}, "children": []}], "root": 0}
+        workload = {"queries": [{"graph": graph(), "replacements": [{"before": graph(), "after": {"graph": graph()}}]}]}
+        replacement = prepare_workload(workload)["queries"][0]["replacements"][0]
+        self.assertEqual(replacement["before"]["nodes"][0]["label"], "legacy")
+        self.assertEqual(replacement["after"]["graph"]["nodes"][0]["label"], "legacy")
+
 
 class MainCliTests(unittest.TestCase):
     """Exercises main()'s own error handling via subprocess, rather than
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 9b9e0221..feca4f8c 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -8,22 +8,26 @@
 cytoscape.use(window.cytoscapeDagre);
 
 // ── State ────────────────────────────────────────────────────────────────
-// queries: [{ name, graph: { nodes, root } }], flattened across every loaded
-// file (a later file whose query name collides with an earlier one is kept
-// distinct by suffixing the file index).
+// queries: [{ name, graph: { nodes, root }, replacements?, post_graph? }],
+// flattened across every loaded file (a later file whose query name
+// collides with an earlier one is kept distinct by suffixing the file
+// index). `replacements` is the optional --post-asap array of
+// ReplacementSite entries for that query (each with its own `before`/`after`
+// subtree) — defaulted to `[]` when the loaded JSON omits the field, so
+// callers never need an extra existence check. `post_graph` is the optional
+// --post-asap whole-query merged post-ASAP graph (same flattened
+// `{nodes, root}` shape as `graph`, but nodes may be post-ASAP-only kinds
+// like "SummaryAgg" mixed in, and any such node has no `hash` — there's no
+// corresponding QueryExpr to hash) — left `undefined` when absent (omitted
+// whenever --post-asap wasn't set, or this query had zero replacements),
+// unlike `replacements` which always defaults to an array.
 let queries = [];
 let activeIndex = -1;
 let cy = null;
 let highlightOn = true;
 let zoom = 1;
-// mode: 'single' (default) shows one query's DAG via the tabs above, exactly
-// as before. 'compare' lays every selected query out in its own lane, side
-// by side, with dashed links between nodes that share a structural hash.
-// 'union' merges selected queries into one graph, collapsing every node
-// whose hash is shared by >= 2 of them into a single node with converging
-// edges. See the "Compare and Union mode" section of README.md.
-let mode = 'single';
-// Indices into `queries` currently selected to participate in compare/union.
+// The viewer has one Pre/Post-ASAP mode. One selected query renders its own
+// two DAGs; multiple selected queries union each stage into one workload DAG.
 let participants = new Set();
 
 const dropzone = document.getElementById('dropzone');
@@ -31,16 +35,17 @@ const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
 const tabsEl = document.getElementById('tabs');
+const scopePickerEl = document.getElementById('scopePicker');
 const cyOuterEl = document.getElementById('cyOuter');
 const cyEl = document.getElementById('cy');
 const modeHintEl = document.getElementById('modeHint');
 const emptyEl = document.getElementById('empty');
 const sidepanel = document.getElementById('sidepanel');
+const sideResizeHandle = document.getElementById('sideResizeHandle');
 const detailSection = document.getElementById('detailSection');
 const viewTitleEl = document.getElementById('viewTitle');
 const zoomSlider = document.getElementById('zoomSlider');
 const zoomLabel = document.getElementById('zoomLabel');
-const proxyNote = document.getElementById('proxyNote');
 
 dropzone.addEventListener('click', () => fileInput.click());
 dropzone.addEventListener('dragover', (e) => { e.preventDefault(); dropzone.classList.add('dragover'); });
@@ -54,33 +59,30 @@ fileInput.addEventListener('change', (e) => loadFiles(e.target.files));
 clearBtn.addEventListener('click', () => {
   queries = [];
   activeIndex = -1;
-  mode = 'single';
   participants = new Set();
-  setModeButtons();
   render();
 });
 highlightToggle.addEventListener('change', () => {
   highlightOn = highlightToggle.checked;
   applyHighlighting();
 });
-
-document.querySelectorAll('#modeToggle .btn').forEach((btn) => {
-  btn.addEventListener('click', () => {
-    mode = btn.dataset.mode;
-    setModeButtons();
-    // First switch into compare/union with nothing chosen yet: default to
-    // every currently-loaded query rather than an empty set of lanes.
-    if (mode !== 'single' && participants.size === 0) {
-      queries.forEach((_, i) => participants.add(i));
-    }
-    render();
-  });
+let resizingSidepanel = false;
+sideResizeHandle.addEventListener('pointerdown', (event) => {
+  resizingSidepanel = true;
+  sideResizeHandle.classList.add('dragging');
+  sideResizeHandle.setPointerCapture(event.pointerId);
+});
+sideResizeHandle.addEventListener('pointermove', (event) => {
+  if (!resizingSidepanel) return;
+  const width = Math.max(260, Math.min(window.innerWidth * 0.7, window.innerWidth - event.clientX));
+  sidepanel.style.width = `${width}px`;
+  if (cy) cy.resize();
+});
+sideResizeHandle.addEventListener('pointerup', (event) => {
+  resizingSidepanel = false;
+  sideResizeHandle.classList.remove('dragging');
+  sideResizeHandle.releasePointerCapture(event.pointerId);
 });
-
-function setModeButtons() {
-  document.querySelectorAll('#modeToggle .btn').forEach((b) => b.classList.toggle('active', b.dataset.mode === mode));
-  proxyNote.style.display = mode === 'single' ? 'none' : 'inline';
-}
 
 function loadFiles(fileList) {
   const files = Array.from(fileList || []);
@@ -97,7 +99,7 @@ function loadFiles(fileList) {
           let name = q.name;
           if (existingNames.has(name)) name = `${q.name} (${file.name})`;
           existingNames.add(name);
-          queries.push({ name, graph: q.graph, source: q.source });
+          queries.push({ name, graph: q.graph, source: q.source, replacements: q.replacements || [], post_graph: q.post_graph });
         });
       } catch (err) {
         alert(`Failed to parse ${file.name}: ${err.message}`);
@@ -105,6 +107,7 @@ function loadFiles(fileList) {
       pending -= 1;
       if (pending === 0) {
         if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
+        if (participants.size === 0 && activeIndex >= 0) participants.add(activeIndex);
         render();
       }
     };
@@ -113,29 +116,6 @@ function loadFiles(fileList) {
   fileInput.value = '';
 }
 
-// ── Shared-subtree hashes across a set of queries ───────────────────────
-// Map<hash, Set<queryName>> — a node's hash is "shared" once it shows up
-// under >= 2 distinct query names (this is a client-side structural-equality
-// proxy for real CSE output; see crates/types/src/dag_export.rs and the
-// "Shared-subtree highlighting is a proxy" section of README.md). Defaults
-// to every loaded query (single-view highlighting); Compare/Union instead
-// pass just their selected participants, so a node never shows as "shared"
-// against a query that isn't even part of that view.
-function computeHashOwners(subsetQueries) {
-  const list = subsetQueries || queries;
-  const owners = new Map();
-  for (const q of list) {
-    const seenInThisQuery = new Set();
-    for (const node of q.graph.nodes) {
-      if (seenInThisQuery.has(node.hash)) continue;
-      seenInThisQuery.add(node.hash);
-      if (!owners.has(node.hash)) owners.set(node.hash, new Set());
-      owners.get(node.hash).add(q.name);
-    }
-  }
-  return owners;
-}
-
 function getParticipants() {
   return Array.from(participants)
     .filter((i) => i >= 0 && i < queries.length)
@@ -145,42 +125,28 @@ function getParticipants() {
 function render() {
   if (queries.length === 0) {
     tabsEl.innerHTML = '';
+    scopePickerEl.classList.remove('visible');
     emptyEl.style.display = 'flex';
     cyOuterEl.style.display = 'none';
     sidepanel.style.display = 'none';
+    sideResizeHandle.style.display = 'none';
     if (cy) { cy.destroy(); cy = null; }
     return;
   }
   emptyEl.style.display = 'none';
   cyOuterEl.style.display = 'block';
   sidepanel.style.display = 'block';
+  sideResizeHandle.style.display = 'block';
 
   renderTabs();
 
-  if (mode === 'single') {
-    if (activeIndex === -1) activeIndex = 0;
-    renderGraph(queries[activeIndex]);
-  } else if (mode === 'compare') {
-    renderCompare(getParticipants());
-  } else {
-    renderUnion(getParticipants());
-  }
+  renderPrePostAsap();
   renderLegend();
 }
 
 function renderTabs() {
   tabsEl.innerHTML = '';
-  if (mode === 'single') {
-    queries.forEach((q, i) => {
-      const tab = document.createElement('div');
-      tab.className = 'tab' + (i === activeIndex ? ' active' : '');
-      tab.textContent = q.name;
-      tab.addEventListener('click', () => { activeIndex = i; render(); });
-      tabsEl.appendChild(tab);
-    });
-    return;
-  }
-  // Compare/Union: checkboxes choose which loaded queries participate.
+  // Checkboxes choose the single query or workload to union.
   queries.forEach((q, i) => {
     const chip = document.createElement('label');
     chip.className = 'tab checkTab' + (participants.has(i) ? ' active' : '');
@@ -211,7 +177,6 @@ function buildCyStyle() {
     style: {
       'border-color': categoryColors(name).border,
       'background-color': categoryColors(name).bg,
-      'background-image': categoryIconDataUri(name),
     },
   }));
 
@@ -245,17 +210,26 @@ function buildCyStyle() {
       selector: 'node[category = "data"]',
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
-    ...categoryStyles.map((entry) => ({
-      ...entry,
-      style: { ...entry.style, 'background-image': 'none' },
-    })),
+    ...categoryStyles,
     {
-      selector: 'node.root',
-      style: { 'border-width': 2.5 },
+      // KeepPreAsap (post-ASAP lane only) is post-ASAP-only
+      // as a *kind*, but represents literally unchanged pre-ASAP content —
+      // override the 'summary' category's color/icon with the same neutral
+      // panel/muted/dashed treatment the rest of the chrome uses for "nothing
+      // to see here", so a glance at the After lane separates "the planner
+      // did something" (solid, colored) from "left alone" (dashed, muted).
+      // See node-style.js's CATEGORIES.summary comment for the category-level
+      // color choice this overrides.
+      selector: 'node[kind = "KeepPreAsap"]',
+      style: {
+        'background-color': panelColor,
+        'border-color': borderColor,
+        'border-style': 'dashed',
+      },
     },
     {
-      selector: 'node.hasNotes',
-      style: { 'border-style': 'double', 'border-width': 3 },
+      selector: 'node.root',
+      style: { 'border-width': 2.5 },
     },
     {
       selector: 'node.shared',
@@ -267,7 +241,7 @@ function buildCyStyle() {
       },
     },
     {
-      // Union mode's collapsed nodes: a persistent double border marks the
+      // Workload-union collapsed nodes: a persistent double border marks the
       // merge itself (unlike '.shared', this isn't gated by the highlight
       // toggle — collapsing *is* how union mode represents sharing).
       selector: 'node.unionShared',
@@ -284,7 +258,7 @@ function buildCyStyle() {
       },
     },
     {
-      // Compare mode's per-query lane container (a compound parent node).
+      // Pre/Post-ASAP lane container (a compound parent node).
       selector: 'node.laneParent',
       style: {
         'shape': 'round-rectangle',
@@ -312,28 +286,20 @@ function buildCyStyle() {
         'target-arrow-color': edgeColor,
         'target-arrow-shape': 'triangle',
         'curve-style': 'bezier',
+        'label': '',
+        'font-size': 9,
+        'color': textColor,
+        'text-background-color': panelColor,
+        'text-background-opacity': 0.92,
+        'text-background-padding': 3,
+        'text-rotation': 'autorotate',
+        'text-wrap': 'wrap',
+        'text-max-width': 260,
         'transition-property': 'opacity',
         'transition-duration': '260ms',
         'transition-timing-function': 'ease-in-out',
       },
     },
-    {
-      // Compare mode's cross-lane "same hash" connector: dashed, no
-      // arrowhead (it isn't a data-flow edge), added after layout so it
-      // never influences dagre's ranking.
-      selector: 'edge.sharedLink',
-      style: {
-        'line-style': 'dashed',
-        'line-color': ringColor,
-        'target-arrow-shape': 'none',
-        'source-arrow-shape': 'none',
-        'curve-style': 'unbundled-bezier',
-        'control-point-distances': [24],
-        'control-point-weights': [0.5],
-        'opacity': 0.55,
-        'width': 1.5,
-      },
-    },
   ];
 
   return style;
@@ -366,31 +332,17 @@ function buildCy(elements, layout) {
   return cy;
 }
 
-// Root badges + notes badges + click/tap wiring — identical across
-// single/compare/union.
+// Root borders and click/tap wiring for the Pre/Post-ASAP lanes.
 function finalizeGraphInteractions() {
   // Use borders rather than pictograms so IR text owns the whole node box.
   cy.nodes('[?root]').addClass('root');
 
-  // A double border marks nodes carrying planner notes without taking space
-  // away from the IR text.
-  cy.nodes().forEach((n) => {
-    if (n.data('isLane')) return;
-    const node = n.data('node');
-    if (!node || !node.notes || !node.notes.length) return;
-    n.addClass('hasNotes');
-  });
-
   cy.on('tap', 'node', (evt) => {
     const n = evt.target;
     if (n.data('isLane')) return;
-    if (n.data('isUnion')) {
-      showUnionDetail(n.data());
-      return;
-    }
-    const query = queries.find((q) => q.name === n.data('queryName'));
-    showDetail(n.data('node'), query, mode === 'compare' ? getParticipants().map((i) => queries[i]) : undefined);
+    showPrePostDetail(n.data());
   });
+  cy.on('tap', 'edge', (evt) => showEdgeDetail(evt.target));
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
 }
 
@@ -414,239 +366,323 @@ function hideModeHint() {
   cyEl.style.display = 'block';
 }
 
-// ── Single-query view (default, unchanged behavior) ──────────────────────
+// ── Pre/Post-ASAP: one query or two workload-union DAGs ──────────────────
+function renderPrePostAsap() {
+  const chosen = getParticipants();
+  const selected = chosen.map((i) => queries[i]);
+  renderScopeSummary(selected);
+  renderSourcePanel(selected);
 
-function renderGraph(query) {
+  if (selected.length === 0) {
+    viewTitleEl.textContent = 'Pre/Post-ASAP';
+    showModeHint('Select one query for a complete pre/post DAG, or several queries for a batch workload view.');
+    return;
+  }
+  const missing = selected.filter((q) => !q.post_graph);
+  if (missing.length > 0) {
+    viewTitleEl.textContent = selected.length === 1 ? `Pre/Post-ASAP: ${selected[0].name}` : `Pre/Post-ASAP workload: ${selected.length} queries`;
+    const action = document.getElementById('plannerRun')
+      ? 'Open Query planner and click “Plan selected workload”, or re-export with dag_export --post-asap.'
+      : 'Re-export with dag_export --post-asap.';
+    showModeHint(`No post-ASAP graph for: ${missing.map((q) => q.name).join(', ')}. ${action}`);
+    return;
+  }
   hideModeHint();
-  viewTitleEl.textContent = query.name;
-  renderSourcePanel([query]);
+  viewTitleEl.textContent = selected.length === 1
+    ? `Pre/Post-ASAP: ${selected[0].name}`
+    : `Pre/Post-ASAP workload union: ${selected.length} queries`;
+
+  const elements = selected.length === 1
+    ? [
+        ...laneElements('pre-asap', `${selected[0].name} · pre-ASAP`, selected[0].graph, selected[0], 'pre'),
+        ...laneElements('post-asap', `${selected[0].name} · post-ASAP`, selected[0].post_graph, selected[0], 'post'),
+      ]
+    : [
+        ...unionStageLaneElements('pre', chosen),
+        ...unionStageLaneElements('post', chosen),
+      ];
+
+  buildCy(elements);
+  finalizeGraphInteractions();
+  applyHighlighting();
+  const initial = cy.nodes().filter((node) =>
+    !node.data('isLane') && node.data('stage') === 'pre' && node.data('root')
+  ).first();
+  if (initial && initial.length) {
+    initial.select();
+    showPrePostDetail(initial.data());
+  } else {
+    clearDetail();
+  }
+  fitAndSyncZoom();
+}
+
+function unionStageLaneElements(stage, chosen) {
+  // Workload merging is an exporter decision. `workload_node_id` is the
+  // explicit JSON mapping; do not reconstruct identity from node content.
+  const laneId = `${stage}-asap-union`;
+  const graphFor = (query) => (stage === 'pre' ? query.graph : query.post_graph);
+  const owners = new Map();
+
+  chosen.forEach((qIdx) => {
+    const query = queries[qIdx];
+    const graph = graphFor(query);
+    graph.nodes.forEach((node) => {
+      if (node.workload_node_id === undefined) return;
+      if (!owners.has(node.workload_node_id)) owners.set(node.workload_node_id, new Set());
+      owners.get(node.workload_node_id).add(query.name);
+    });
+  });
+
+  const sharedIds = new Map();
+  let nextSharedId = 0;
+  owners.forEach((queryNames, workloadNodeId) => {
+    if (queryNames.size > 1) sharedIds.set(workloadNodeId, `${laneId}-shared-${nextSharedId++}`);
+  });
+  const keyFor = (qIdx, node) => sharedIds.get(node.workload_node_id) || `${laneId}-q${qIdx}-${node.id}`;
+  const entries = new Map();
+  const edges = new Map();
+  const elements = [
+    { data: { id: laneId, label: `${stage === 'pre' ? 'pre-ASAP' : 'post-ASAP'} · workload union`, isLane: true }, classes: 'laneParent', selectable: false, grabbable: false },
+  ];
+
+  chosen.forEach((qIdx) => {
+    const query = queries[qIdx];
+    const graph = graphFor(query);
+    const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+    graph.nodes.forEach((node) => {
+      const key = keyFor(qIdx, node);
+      let entry = entries.get(key);
+      if (!entry) {
+        entry = { node, sourceQueries: new Set(), rootFor: new Set(), decisions: new Map() };
+        entries.set(key, entry);
+      }
+      entry.sourceQueries.add(query.name);
+      for (const decision of translationsForNode(query, node, stage)) {
+        entry.decisions.set(decision.id, decision);
+      }
+      if (node.id === graph.root) entry.rootFor.add(query.name);
+      node.children.forEach((childId) => {
+        const childKey = keyFor(qIdx, byId.get(childId));
+        const child = byId.get(childId);
+        edges.set(`${childKey}\u0000${key}`, formatSchema(child.schema));
+      });
+    });
+  });
 
-  const elements = [];
-  for (const node of query.graph.nodes) {
+  entries.forEach((entry, key) => elements.push({
+    data: {
+      id: key,
+      parent: laneId,
+      label: entry.node.label,
+      node: entry.node,
+      kind: entry.node.kind,
+      category: categoryOf(entry.node.kind),
+      root: entry.rootFor.size > 0,
+      rootFor: Array.from(entry.rootFor),
+      sourceQueries: Array.from(entry.sourceQueries),
+      isPrePost: true,
+      stage,
+      queryName: Array.from(entry.sourceQueries)[0],
+      translations: Array.from(entry.decisions.values()),
+    },
+    classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
+  }));
+  let edgeIndex = 0;
+  edges.forEach((schemaLabel, edge) => {
+    const [source, target] = edge.split('\u0000');
+    elements.push({ data: { id: `${laneId}-edge-${edgeIndex++}`, source, target, schemaLabel } });
+  });
+  return elements;
+}
+
+// Builds one Pre/Post-ASAP lane (a dashed compound parent plus its
+// nodes/edges). `nodes` is either a plain pre-ASAP
+// DagNode list (the `before` subtree, or an `after.kind === "Rewrite"`
+// graph) or a SummaryDagNode list (an `after.kind === "Summary"` graph) —
+// both shapes carry id/kind/label/detail/children, which is all a lane
+// needs; SummaryDagNode's missing `hash`/`notes` fields are simply never
+// read by this function or by showPrePostDetail below.
+function laneElements(laneId, laneLabel, graph, query, stage) {
+  const nodes = graph.nodes;
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const elements = [
+    { data: { id: laneId, label: laneLabel, isLane: true }, classes: 'laneParent', selectable: false, grabbable: false },
+  ];
+  for (const node of nodes) {
     elements.push({
       data: {
-        id: String(node.id),
+        id: `${laneId}-${node.id}`,
+        parent: laneId,
         label: node.label,
         node,
+        // Flat (not nested under `node`) so buildCyStyle's
+        // `node[kind = "KeepPreAsap"]` selector can actually match it —
+        // cytoscape selectors can't reach into a data field that's itself an
+        // object.
+        kind: node.kind,
         category: categoryOf(node.kind),
-        root: node.id === query.graph.root,
+        root: node.id === graph.root,
+        isPrePost: true,
+        laneId,
+        stage,
         queryName: query.name,
+        translations: translationsForNode(query, node, stage),
       },
     });
   }
-  for (const node of query.graph.nodes) {
+  for (const node of nodes) {
     for (const childId of node.children) {
       elements.push({
         data: {
           // Arrow points from input to consumer (data-flow direction), the
           // reverse of the tree's parent->child structure.
-          id: `e-${node.id}-${childId}`,
-          source: String(childId),
-          target: String(node.id),
+          id: `e-${laneId}-${node.id}-${childId}`,
+          source: `${laneId}-${childId}`,
+          target: `${laneId}-${node.id}`,
+          schemaLabel: formatSchema(byId.get(childId).schema),
         },
       });
     }
   }
-
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  zoom = 1;
-  applyZoom();
+  return elements;
 }
 
-// ── Compare mode: selected queries side by side in lanes ─────────────────
-// Each selected query gets its own compound "lane" node (a dashed box
-// titled with the query name). Lanes share no structural edges with each
-// other, so dagre lays them out left to right on their own. Nodes whose
-// hash is shared by >= 2 selected queries get a dashed link edge added
-// *after* the layout call returns (dagre layout is synchronous here), so
-// those cross-lane links are purely visual and never pull dagre's ranking
-// out of per-query lanes.
-function renderCompare(chosen) {
-  viewTitleEl.textContent = chosen.length ? `Compare: ${chosen.map((i) => queries[i].name).join(', ')}` : 'Compare';
-  renderSourcePanel(chosen.map((i) => queries[i]));
-
-  if (chosen.length < 2) {
-    showModeHint('Select two or more loaded queries above to compare them side by side.');
-    return;
-  }
-  hideModeHint();
-
-  const elements = [];
-  chosen.forEach((qIdx) => {
-    const q = queries[qIdx];
-    const laneId = `lane-${qIdx}`;
-    elements.push({
-      data: { id: laneId, label: q.name, isLane: true },
-      classes: 'laneParent',
-      selectable: false,
-      grabbable: false,
-    });
-    for (const node of q.graph.nodes) {
-      elements.push({
-        data: {
-          id: `q${qIdx}-${node.id}`,
-          parent: laneId,
-          label: node.label,
-          node,
-          category: categoryOf(node.kind),
-          root: node.id === q.graph.root,
-          queryName: q.name,
-        },
-      });
-    }
-    for (const node of q.graph.nodes) {
-      for (const childId of node.children) {
-        elements.push({
-          data: {
-            // Arrow points from input to consumer (data-flow direction), the
-            // reverse of the tree's parent->child structure.
-            id: `e-q${qIdx}-${node.id}-${childId}`,
-            source: `q${qIdx}-${childId}`,
-            target: `q${qIdx}-${node.id}`,
-          },
-        });
-      }
-    }
+function formatSchema(schema) {
+  if (!schema || typeof schema !== 'object') return 'schema unavailable';
+  const fields = Array.isArray(schema.columns) ? schema.columns : schema.fields;
+  if (!Array.isArray(fields) || fields.length === 0) return 'empty schema';
+  const rows = fields.map((field, index) => {
+    const name = field && field.name !== undefined ? field.name : '?';
+    const dtype = field && field.dtype !== undefined
+      ? (typeof field.dtype === 'string' ? field.dtype : JSON.stringify(field.dtype))
+      : '?';
+    return {
+      name: String(name),
+      dtype: String(dtype).toUpperCase(),
+      nullable: field && field.nullable ? 'NULL' : 'NOT NULL',
+      timeIndex: schema.time_index === index,
+    };
   });
-
-  buildCy(elements);
-  cy.add(buildSharedLinkEdges(chosen));
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
+  const nameWidth = Math.max(...rows.map((row) => row.name.length));
+  const typeWidth = Math.max(...rows.map((row) => row.dtype.length));
+  return rows.map((row) =>
+    `${row.name.padEnd(nameWidth)}  ${row.dtype.padEnd(typeWidth)}  ${row.nullable}${row.timeIndex ? '  · TIME INDEX' : ''}`
+  ).join('\n');
 }
 
-// Dashed, non-directional link edges connecting one representative node per
-// lane for every hash shared by >= 2 of the chosen queries. Chains each
-// occurrence to the nearest earlier lane that also has it (not a full
-// mesh), which is enough to make "this shape recurs" visually obvious
-// without drawing an edge for every pair.
-function buildSharedLinkEdges(chosen) {
-  const owners = computeHashOwners(chosen.map((i) => queries[i]));
-  const links = [];
-  for (const [hash, ownerNames] of owners) {
-    if (ownerNames.size < 2) continue;
-    let prevKey = null;
-    chosen.forEach((qIdx) => {
-      const q = queries[qIdx];
-      if (!ownerNames.has(q.name)) return;
-      const representative = q.graph.nodes.find((n) => n.hash === hash);
-      if (!representative) return;
-      const key = `q${qIdx}-${representative.id}`;
-      if (prevKey) {
-        links.push({
-          data: { id: `link-${hash}-${prevKey}-${key}`, source: prevKey, target: key },
-          classes: 'sharedLink',
-          selectable: false,
-        });
-      }
-      prevKey = key;
-    });
+function schemaDerivation(target) {
+  const node = target.data('node');
+  if (!node) return 'The target operation metadata is unavailable.';
+  const detail = node.detail || {};
+  switch (node.kind) {
+    case 'Filter': return 'Filter evaluates its predicate and preserves the input columns and types.';
+    case 'Sort': return 'Sort changes row order using its sort keys and preserves the input schema.';
+    case 'Limit': return `Limit keeps ${detail.n ?? 'the requested number of'} ordered rows and preserves the input schema.`;
+    case 'Project': return 'Project evaluates its selected expressions; aliases and expression result types form the output schema.';
+    case 'Aggregate': return 'Aggregate emits its reduction/group-by keys followed by the result column for each aggregate measure.';
+    case 'SummaryAgg': return 'SummaryAgg replaces the aggregate state with the selected exact or approximate summary representation.';
+    case 'SummaryEstimate': return 'SummaryEstimate reads the selected summary state and emits the requested estimate schema.';
+    case 'TimeRange': return 'TimeRange restricts the temporal input window and preserves the row schema.';
+    case 'Scan': return 'Scan obtains this schema from the bound table or metric source.';
+    default: return `${node.kind} applies the IR operation shown below; its declared output schema is exported by the planner.`;
   }
-  return links;
 }
 
-// ── Union mode: merge selected queries into one graph ─────────────────────
-// A node whose hash is shared by >= 2 selected queries collapses into a
-// single graph node (id `h-<hash>`); every other node keeps a per-query id
-// (`q<i>-<nodeId>`). Edges are deduped after the merge, so multiple parents
-// — from different queries, or repeats within one query — that point at the
-// same shared node converge onto it instead of each drawing a separate
-// copy. That's the "real branching DAG" case this mode has to handle:
-// a merged node can end up with several parents at once, and plain dagre
-// already lays out multi-parent DAGs natively, so no special-cased layout
-// is needed beyond building this merged element set.
-function renderUnion(chosen) {
-  viewTitleEl.textContent = chosen.length ? `Union: ${chosen.map((i) => queries[i].name).join(', ')}` : 'Union';
-  renderSourcePanel(chosen.map((i) => queries[i]));
-
-  if (chosen.length < 2) {
-    showModeHint('Select two or more loaded queries above to merge them into one union graph.');
-    return;
-  }
-  hideModeHint();
+function showEdgeDetail(edge) {
+  const source = edge.source();
+  const target = edge.target();
+  const sourceNode = source.data('node') || {};
+  const targetNode = target.data('node') || {};
+  const edgeSchema = edge.data('schemaLabel') || formatSchema(sourceNode.schema);
+  detailSection.innerHTML = `
+    <h2>Selected edge</h2>
+    <div class="translationBlock">
+      <h3>Connection</h3>
+      <div><strong>From:</strong> ${escapeHtml(sourceNode.label || source.id())}</div>
+      <div><strong>To:</strong> ${escapeHtml(targetNode.label || target.id())}</div>
+    </div>
+    <h3 class="detailSubhead">Schema carried by this edge</h3>
+    <pre>${escapeHtml(edgeSchema || '(schema unavailable)')}</pre>
+    <h3 class="detailSubhead">How the schema is produced</h3>
+    <div class="translationBlock">${escapeHtml(schemaDerivation(target))}</div>
+    <h3 class="detailSubhead">Target operation</h3>
+    <pre>${escapeHtml(JSON.stringify(targetNode.detail || {}, null, 2))}</pre>
+    <h3 class="detailSubhead">Target output schema</h3>
+    <pre>${escapeHtml(formatSchema(targetNode.schema) || '(schema unavailable)')}</pre>
+  `;
+}
 
-  const owners = computeHashOwners(chosen.map((i) => queries[i]));
-  const isSharedHash = (hash) => {
-    const ownerNames = owners.get(hash);
-    return !!ownerNames && ownerNames.size > 1;
-  };
-  const keyFor = (qIdx, node) => (isSharedHash(node.hash) ? `h-${node.hash}` : `q${qIdx}-${node.id}`);
+function renderScopeSummary(selected) {
+  scopePickerEl.classList.add('visible');
+  const strategies = new Set();
+  selected.forEach((query) => (query.post_graph?.nodes || []).forEach((node) => {
+    if (node.decision && node.decision.rank === 0) strategies.add(node.decision.strategy);
+  }));
+  const scope = selected.length === 1 ? 'Single query' : `Batch workload · ${selected.length} queries`;
+  const strategyText = strategies.size ? `Winning strategies: ${Array.from(strategies).join(', ')}` : 'No selected replacements';
+  scopePickerEl.innerHTML = `<div class="scopeGroup"><div class="scopeGroupLabel">View scope</div><div class="scopeRow active"><span>${escapeHtml(scope)}</span><span class="scopeMeta">${escapeHtml(strategyText)}</span></div></div>`;
+}
 
-  const nodeEntries = new Map(); // key -> accumulator
-  const edgeKeys = new Set();
-  const elements = [];
+function translationsForNode(query, node, stage) {
+  // The pre lane is deliberately the original pre-ASAP IR only. Strategy
+  // metadata belongs to nodes in the post lane.
+  if (stage === 'pre') return [];
+  const replacements = (query.replacements || []).filter((replacement) => replacement.rank === 0);
+  if (!node.decision) return [];
+  const replacement = replacements.find((entry) => entry.decision_id === node.decision.id);
+  return [{
+    ...node.decision,
+    target_pre_id: replacement ? replacement.target_pre_id : undefined,
+    output_kind: replacement ? replacement.after?.kind : undefined,
+  }];
+}
 
-  chosen.forEach((qIdx) => {
-    const q = queries[qIdx];
-    for (const node of q.graph.nodes) {
-      const key = keyFor(qIdx, node);
-      let entry = nodeEntries.get(key);
-      if (!entry) {
-        entry = {
-          node,
-          category: categoryOf(node.kind),
-          isMerged: isSharedHash(node.hash),
-          sourceQueries: new Set(),
-          rootFor: new Set(),
-        };
-        nodeEntries.set(key, entry);
-      }
-      entry.sourceQueries.add(q.name);
-      if (node.id === q.graph.root) entry.rootFor.add(q.name);
-    }
-  });
+function showPrePostDetail(data) {
+  const node = data.node;
+  const category = categoryOf(node.kind);
+  const catColors = categoryColors(category);
+  const catLabel = (CATEGORIES[category] || {}).label || category;
+  const stageName = data.stage === 'pre' ? 'pre-ASAP' : 'post-ASAP';
+  const chipLabel = catLabel === node.kind ? node.kind : `${catLabel} · ${node.kind}`;
 
-  chosen.forEach((qIdx) => {
-    const q = queries[qIdx];
-    const byId = new Map(q.graph.nodes.map((n) => [n.id, n]));
-    for (const node of q.graph.nodes) {
-      const parentKey = keyFor(qIdx, node);
-      for (const childId of node.children) {
-        const childNode = byId.get(childId);
-        const childKey = keyFor(qIdx, childNode);
-        const edgeKey = `${parentKey}__${childKey}`;
-        if (edgeKeys.has(edgeKey)) continue;
-        edgeKeys.add(edgeKey);
-        // Arrow points from input to consumer (data-flow direction), the
-        // reverse of the tree's parent->child structure.
-        elements.push({ data: { id: `e-${edgeKey}`, source: childKey, target: parentKey } });
-      }
-    }
-  });
+  const rootNames = data.rootFor && data.rootFor.length ? data.rootFor : [data.queryName];
+  const rootHtml = data.root
+    ? `<div class="rootNote">Root of the complete ${stageName} DAG for: ${rootNames.map(escapeHtml).join(', ')}.</div>`
+    : '';
 
-  for (const [key, entry] of nodeEntries) {
-    elements.push({
-      data: {
-        id: key,
-        label: entry.node.label,
-        node: entry.node,
-        category: entry.category,
-        isUnion: true,
-        isMerged: entry.isMerged,
-        sourceQueries: Array.from(entry.sourceQueries),
-        rootFor: Array.from(entry.rootFor),
-        root: entry.rootFor.size > 0,
-      },
-      classes: entry.isMerged ? 'unionShared' : '',
-    });
+  const decisions = data.translations || [];
+  let translationHtml = '';
+  if (decisions.length > 0) {
+    const cards = decisions.map((entry) => `
+      <div class="translationCard">
+        <div class="translationStrategy">${escapeHtml(entry.strategy)}</div>
+        <div class="translationMeta">rank ${entry.rank} · estimated cost ${escapeHtml(entry.cost)}</div>
+        <div class="translationMeta">${entry.role === 'replacement_root' ? 'This node replaces the pre-ASAP target.' : 'This node is generated or carried inside the replacement region.'}</div>
+        <div class="translationReason">${escapeHtml(entry.rationale || 'No rationale recorded.')}</div>
+        <div class="translationTarget">${entry.target_pre_id === undefined ? `decision #${entry.id}` : `pre-ASAP target node #${entry.target_pre_id}`} · output ${escapeHtml(entry.output_kind || node.kind)}</div>
+      </div>`).join('');
+    translationHtml = `<div class="translationBlock"><h3>Why this post-ASAP translation</h3>${cards}</div>`;
+  } else if (data.stage === 'post') {
+    translationHtml = `<div class="translationBlock unchanged"><h3>Translation</h3><div>No replacement targets this node; it is unchanged support structure in the post-ASAP DAG.</div></div>`;
   }
 
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
+  detailSection.innerHTML = `
+    <h2>Selected node</h2>
+    <span class="chip" style="color:${catColors.border}; background:${catColors.bg}">${escapeHtml(chipLabel)}</span>
+    <div style="font-weight:650; margin:0.3rem 0 0.4rem">${escapeHtml(node.label)}</div>
+    ${rootHtml}
+    ${translationHtml}
+    <h3 class="detailSubhead">IR node content</h3>
+    <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
+  `;
 }
 
 // ── Shared rendering bits ─────────────────────────────────────────────────
 
 function renderSourcePanel(qs) {
   const sourceBox = document.getElementById('sourceBox');
+  renderTableSchemas(qs);
   if (qs.length === 0) {
     sourceBox.textContent = 'Select queries above.';
     sourceBox.classList.add('placeholder');
@@ -668,16 +704,48 @@ function renderSourcePanel(qs) {
   sourceBox.classList.remove('placeholder');
 }
 
+function renderTableSchemas(qs) {
+  const box = document.getElementById('tableSchemaBox');
+  const schemas = new Map();
+  qs.forEach((query) => {
+    (query.graph?.nodes || []).filter((node) => node.kind === 'Scan').forEach((node) => {
+      const key = JSON.stringify([node.detail, node.schema]);
+      if (!schemas.has(key)) schemas.set(key, { node, owners: [] });
+      schemas.get(key).owners.push(query.name);
+    });
+  });
+  const blocks = Array.from(schemas.values()).map(({ node, owners }) =>
+    `${node.label}\nUsed by: ${owners.join(', ')}\n${formatSchema(node.schema) || '(schema unavailable)'}`);
+  box.textContent = blocks.join('\n\n') || 'No bound Scan schema in the selected queries.';
+  box.classList.toggle('placeholder', blocks.length === 0);
+}
+
 function applyHighlighting() {
   if (!cy) return;
-  const owners = mode === 'single' ? computeHashOwners() : computeHashOwners(getParticipants().map((i) => queries[i]));
-  cy.nodes().forEach((n) => {
-    if (n.data('isLane') || n.data('isUnion')) return;
-    const node = n.data('node');
-    if (!node) return;
-    const sharedWith = owners.get(node.hash);
-    const isShared = highlightOn && sharedWith && sharedWith.size > 1;
-    n.toggleClass('shared', isShared);
+  const selected = getParticipants().map((i) => queries[i]);
+  const ownersFor = (graphOf) => {
+    const owners = new Map();
+    selected.forEach((query) => {
+      const seen = new Set();
+      const graph = graphOf(query);
+      (graph ? graph.nodes : []).forEach((node) => {
+        const id = node.workload_node_id;
+        if (id === undefined || seen.has(id)) return;
+        seen.add(id);
+        if (!owners.has(id)) owners.set(id, new Set());
+        owners.get(id).add(query.name);
+      });
+    });
+    return owners;
+  };
+  const preOwners = ownersFor((query) => query.graph);
+  const postOwners = ownersFor((query) => query.post_graph);
+  cy.nodes().forEach((element) => {
+    if (element.data('isLane')) return;
+    const node = element.data('node');
+    const owners = element.data('stage') === 'post' ? postOwners : preOwners;
+    const sharedWith = node && owners.get(node.workload_node_id);
+    element.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
   });
 }
 
@@ -685,81 +753,6 @@ function clearDetail() {
   detailSection.innerHTML = '<h2>Selected node</h2><div class="placeholder">Click a node to inspect it.</div>';
 }
 
-function showDetail(node, query, scopeQueries) {
-  const owners = computeHashOwners(scopeQueries);
-  const sharedWith = Array.from(owners.get(node.hash) || []).filter((n) => n !== query.name);
-  const category = categoryOf(node.kind);
-  const catColors = categoryColors(category);
-  const catLabel = (CATEGORIES[category] || {}).label || category;
-
-  const rootHtml = node.id === query.graph.root
-    ? `<div class="rootNote">This is the query's root (final output).</div>`
-    : '';
-  const sharedHtml = sharedWith.length
-    ? `<div class="shared-note">Structurally identical to a node also present in: ${sharedWith
-        .map(escapeHtml)
-        .join(', ')}</div>`
-    : '';
-
-  detailSection.innerHTML = `
-    <h2>Selected node</h2>
-    <span class="chip" style="color:${catColors.border}; background:${catColors.bg}">${escapeHtml(catLabel)} · ${escapeHtml(node.kind)}</span>
-    <div style="font-weight:650; margin:0.3rem 0 0.4rem">${escapeHtml(node.label)}</div>
-    ${rootHtml}
-    ${sharedHtml}
-    ${notesHtml(node)}
-    <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
-  `;
-}
-
-// Renders a DagNode's `notes` (issue #257: asap-aware-mapping's explanation
-// of why a replacement exists here, matched onto this node by structural
-// hash — see README.md), one block per note, color-coded to match its badge.
-// Empty string if there are none, so callers can always splice this in.
-function notesHtml(node) {
-  if (!node.notes || !node.notes.length) return '';
-  const items = node.notes
-    .map((note) => {
-      const c = noteKindColor(note.kind);
-      return `<div class="noteItem" style="border-left-color:${c}">
-        <span class="noteKind" style="color:${c}">${escapeHtml(note.kind)}</span>
-        <div class="noteReason">${escapeHtml(note.reason)}</div>
-      </div>`;
-    })
-    .join('');
-  return `<div class="notesBlock"><h3>Why a replacement exists here</h3>${items}</div>`;
-}
-
-// Union mode's variant of showDetail: `data` is a merged cytoscape node's
-// data object (see renderUnion), not a raw DagNode + query pair, since a
-// merged node can be "present in" several queries and "root of" several
-// (or zero) of them at once.
-function showUnionDetail(data) {
-  const node = data.node;
-  const category = categoryOf(node.kind);
-  const catColors = categoryColors(category);
-  const catLabel = (CATEGORIES[category] || {}).label || category;
-
-  const rootHtml = data.rootFor && data.rootFor.length
-    ? `<div class="rootNote">Root (final output) of: ${data.rootFor.map(escapeHtml).join(', ')}</div>`
-    : '';
-  const sharedHtml = data.isMerged
-    ? `<div class="shared-note">Merged: same structural hash in ${data.sourceQueries.length} selected queries — ${data.sourceQueries
-        .map(escapeHtml)
-        .join(', ')}</div>`
-    : `<div class="shared-note" style="color:var(--muted)">Query-specific to ${escapeHtml(data.sourceQueries[0])}</div>`;
-
-  detailSection.innerHTML = `
-    <h2>Selected node</h2>
-    <span class="chip" style="color:${catColors.border}; background:${catColors.bg}">${escapeHtml(catLabel)} · ${escapeHtml(node.kind)}</span>
-    <div style="font-weight:650; margin:0.3rem 0 0.4rem">${escapeHtml(node.label)}</div>
-    ${rootHtml}
-    ${sharedHtml}
-    ${notesHtml(node)}
-    <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
-  `;
-}
-
 function renderLegend() {
   const legendList = document.getElementById('legendList');
   const rows = Object.entries(CATEGORIES).map(([name, cat]) => {
@@ -770,22 +763,13 @@ function renderLegend() {
   const ringColor = getComputedStyle(document.documentElement).getPropertyValue('--accent').trim() || '#2563eb';
   const rootColor = getComputedStyle(document.documentElement).getPropertyValue('--cat-output-border').trim() || '#b42318';
   rows.push(`<div class="leg"><span class="swatch ring" style="border-color:${ringColor}"></span>
-    <span><span class="swatchLabel">Shared subtree</span><span class="swatchDesc">Structurally identical to a node in another loaded query (hash-based proxy, not real CSE)</span></span></div>`);
+    <span><span class="swatchLabel">Shared workload node</span><span class="swatchDesc">Explicitly identified by the exporter as shared across selected queries</span></span></div>`);
   rows.push(`<div class="leg"><span class="swatch ring" style="border-color:${rootColor}"></span>
     <span><span class="swatchLabel">Query root</span><span class="swatchDesc">${escapeHtml(ROOT_BADGE.description)}</span></span></div>`);
-  for (const [kind, label] of Object.entries(NOTE_BADGE_LABEL)) {
-    const c = noteKindColor(kind);
-    rows.push(`<div class="leg"><span class="swatch" style="background:${c}; border-color:${c}"></span>
-      <span><span class="swatchLabel">${escapeHtml(label)}</span><span class="swatchDesc">Bottom-right badge — click the node for why (issue #257)</span></span></div>`);
-  }
-  if (mode === 'compare') {
-    rows.push(`<div class="leg"><span class="swatch ring" style="border-color:${ringColor}; border-style:dashed"></span>
-      <span><span class="swatchLabel">Shared-subtree link</span><span class="swatchDesc">Dashed line connects matching-hash nodes across lanes</span></span></div>`);
-  }
-  if (mode === 'union') {
-    rows.push(`<div class="leg"><span class="swatch" style="background:transparent; border:3px double ${ringColor}"></span>
-      <span><span class="swatchLabel">Merged node</span><span class="swatchDesc">Collapsed: this hash appears in 2+ selected queries</span></span></div>`);
-  }
+  const panelBg = getComputedStyle(document.documentElement).getPropertyValue('--panel2').trim() || '#f0f2f5';
+  const mutedColor = getComputedStyle(document.documentElement).getPropertyValue('--muted').trim() || '#6b7280';
+  rows.push(`<div class="leg"><span class="swatch" style="background:${panelBg}; border-color:${mutedColor}; border-style:dashed"></span>
+    <span><span class="swatchLabel">Pass-through (KeepPreAsap)</span><span class="swatchDesc">Unchanged pre-ASAP subtree carried into the Summary graph as-is</span></span></div>`);
   legendList.innerHTML = rows.join('');
 }
 
@@ -812,18 +796,30 @@ document.getElementById('resetBtn').addEventListener('click', () => { zoom = 1;
 
 function loadWorkload(parsed) {
   const incoming = (parsed && parsed.queries) || [];
-  incoming.forEach((q) => queries.push({ name: q.name, graph: q.graph, source: q.source }));
+  incoming.forEach((q) => queries.push({ name: q.name, graph: q.graph, source: q.source, replacements: q.replacements || [], post_graph: q.post_graph }));
   if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
+  if (participants.size === 0 && activeIndex >= 0) participants.add(activeIndex);
 }
 
+// Entry point used by planner-ui.js after the local HTTP backend returns a
+// freshly generated WorkloadGraph. Replace (rather than append to) the
+// current data and open the complete workload pre/post view.
+window.renderPlannerWorkload = function renderPlannerWorkload(parsed) {
+  queries = [];
+  participants = new Set();
+  activeIndex = -1;
+  loadWorkload(parsed);
+  queries.forEach((_, index) => participants.add(index));
+  render();
+};
+
 // render.py's standalone output bakes the WorkloadGraph JSON directly into
 // the page as a <script type="application/json"> tag instead of relying on
 // fetch('dag.json') — a `file://` page can't fetch a sibling file in most
 // browsers (blocked as cross-origin), which is exactly the "no browser
 // dev-server available" case that tool exists for. `window.__DAG_RENDER__`
 // is an optional config object the same generated page may also set, e.g.
-// `{ mode: 'union' }`, to open straight into Compare/Union instead of
-// Single — see render.py's --mode flag.
+// The generated page always opens in Pre/Post-ASAP mode.
 const embeddedEl = document.getElementById('embedded-workload');
 if (embeddedEl) {
   try {
@@ -831,25 +827,15 @@ if (embeddedEl) {
   } catch (err) {
     console.error('tools/dag-viewer: failed to parse embedded workload data', err);
   }
-  const requestedMode = window.__DAG_RENDER__ && window.__DAG_RENDER__.mode;
-  if (requestedMode && requestedMode !== 'single') {
-    mode = requestedMode;
-    queries.forEach((_, i) => participants.add(i));
-    setModeButtons();
-  }
+  if (queries.length > 0 && participants.size === 0) participants.add(0);
   render();
 } else {
-  // Plain index.html: no embedded data. If a dag.json sits next to this page
-  // (e.g. so a remote/tunnelled session has something to look at without a
-  // local file to drag in), load it automatically. Silently does nothing if
-  // there's no such file — drag/drop and the file picker still work either
-  // way. Prefer a real, freshly-generated dag.json (gitignored scratch
-  // output of generate-sample.sh or a manual dag_export run), falling back
-  // to the committed dag.example.json so the page still shows something
-  // with zero setup.
-  fetch('dag.json')
-    .then((r) => (r.ok ? r : fetch('dag.example.json')))
-    .then((r) => (r.ok ? r.json() : null))
+  // Plain index.html starts with the committed, post-ASAP-generated example.
+  // Do not silently prefer a leftover scratch dag.json: it may predate
+  // post_graph and make Pre/Post-ASAP appear broken. Users can load scratch
+  // exports explicitly with the picker or run them through Query planner.
+  fetch('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/api/example', { cache: 'no-store' })
+    .then((r) => (r.ok ? r.json() : fetch('dag.example.json', { cache: 'no-store' }).then((fallback) => fallback.json())))
     .then(loadWorkload)
     .catch(() => {})
     .finally(render);