From 3e40ee0a590ed61c292a5e7050300b60ca9d4fe7 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 19:59:36 -0600
Subject: [PATCH 01/27] feat(devtools): materialize post-ASAP replacements for
 dag_export --post-asap

Add a --post-asap flag to the dag_export devtools binary that runs
asap-aware-mapping's replacement search (default_strategies() plus the
unwired AvgToSumOverCountStrategy) over the lowered workload and surfaces
what it found, two ways:

- NamedGraph.replacements: Vec<TargetReplacement> - one small,
  self-contained before/after pair per independently-discovered
  replacement site (sketch mapping, CSE share/recompute, workload-aware
  rollup, Hydra grouping, avg -> sum/count rewrite), each with a strategy
  label, rationale, rank/cost, and an after tagged
  {"kind": "Summary"|"Rewrite", "graph": {...}}.
- NamedGraph.post_graph: Option<DagGraph> - one merged, whole-query graph
  per query with every winning candidate spliced directly into the query's
  own pre-ASAP shape in place, built via a new
  asap_types::dag_export::export_post_asap.

asap_types::dag_export gains the generic, crate-agnostic shapes for this
(SummaryDagNode/SummaryDagGraph/export_summary, TargetReplacement/
TargetReplacementAfter, PostAsapSubstitution/export_post_asap) following
the same layering discipline DagNode::notes already established: this
crate never runs the search or picks a winner, only defines shapes a
higher layer (the dag_export binary) populates after the fact. DagNode's
source_expr becomes Option<QueryExpr> (None for a post-ASAP-originated
node with no corresponding QueryExpr).

Without --post-asap, output is byte-identical to before (both new fields
are empty/None and skipped from JSON).

Sample outputs covering all four --post-asap replacement kinds saved to
/tmp/post_asap_samples/*.json for the frontend dag-viewer track.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 crates/devtools/src/bin/dag_export.rs | 413 ++++++++++++++++++-
 crates/types/src/dag_export.rs        | 555 ++++++++++++++++++++++++--
 2 files changed, 928 insertions(+), 40 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 591773c5..99a83237 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -17,8 +17,54 @@
 // note. Pass it to actually exercise that path, e.g.:
 //   cargo run -p asap-lower --bin dag_export -- \
 //       --epsilon 0.01 --sql "SELECT quantile(0.99, latency) FROM metrics" --name p99
+//
+// `--post-asap` is optional and off by default. When passed, this binary
+// additionally runs `asap_aware_mapping::replacement::search_workload_with`
+// (with `default_strategies()` plus `AvgToSumOverCountStrategy`, which isn't
+// one of that crate's own defaults) 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 asap_types::dag_export::{self, DagGraph, DagNote, NamedGraph, WorkloadGraph};
+use asap_aware_mapping::cost_model::DefaultCostModel;
+use asap_aware_mapping::replacement::{
+    default_strategies, search_workload_with, Replacement, ReplacementProvenance,
+    ReplacementStrategy, ReplacementSubDAG,
+};
+use asap_aware_mapping::rewrite::AvgToSumOverCountStrategy;
+use asap_types::dag_export::{
+    self, DagGraph, DagNote, NamedGraph, PostAsapSubstitution, TargetReplacement,
+    TargetReplacementAfter, WorkloadGraph,
+};
+use asap_types::post_asap::{GroupingStrategy, SummaryExpr};
+use asap_types::pre_asap::agg_intent::AggIntent;
+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;
 
@@ -56,12 +102,13 @@ fn catalog() -> SqlCatalog {
 
 /// 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) {
+/// `--epsilon <f64>` and one optional global `--post-asap` flag. `--name` is
+/// optional and applies to the immediately preceding `--sql`/`--promql`.
+fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool) {
     let mut entries: Vec<(String, Lang, String)> = Vec::new();
     let mut pending: Option<(Lang, String)> = None;
     let mut accuracy = AccuracyTarget::Exact;
+    let mut post_asap = false;
     let mut args = std::env::args().skip(1);
 
     fn flush(entries: &mut Vec<(String, Lang, String)>, pending: &mut Option<(Lang, String)>) {
@@ -96,16 +143,22 @@ fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget) {
                     .unwrap_or_else(|_| panic!("--epsilon must be a float, got {raw:?}"));
                 accuracy = AccuracyTarget::Epsilon(epsilon);
             }
+            "--post-asap" => {
+                post_asap = true;
+            }
             other => panic!("unrecognized argument: {other}"),
         }
     }
     flush(&mut entries, &mut pending);
-    (entries, accuracy)
+    (entries, accuracy, post_asap)
 }
 
 /// 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],
@@ -113,7 +166,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 == 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(),
@@ -124,11 +179,244 @@ fn annotate_with_explanations(
     }
 }
 
+/// Which display `strategy` label a winning candidate earns, derived from
+/// its `ReplacementProvenance` plus (for `SummaryImplementation`/
+/// `LogicalRewrite`, which each cover more than one concrete strategy) a
+/// look at the winning candidate's own shape:
+///
+/// - `SummaryImplementation` covers both `SketchAlgorithmStrategy` and
+///   `HydraGroupingStrategy` — both produce `Replacement::Summary`
+///   candidates with this same provenance, distinguished only by whether
+///   the bound `SummaryAgg`'s own `grouping` chose
+///   `GroupingStrategy::SharedMultiSubpopulation` (Hydra) or not (an
+///   ordinary per-subpopulation sketch instance).
+/// - `CseShare`/`CseRecompute` both come from `SharedSubtreeStrategy`'s own
+///   two-way share-vs-recompute pair — one label either way, since the
+///   *choice* of which of the two won is exactly what `rank`/`cost`/`after`
+///   already show, not something the strategy label itself needs to encode.
+/// - `LogicalRewrite` covers both `AvgToSumOverCountStrategy` and
+///   `RollupStrategy` — both emit a `Replacement::Rewrite` with this same
+///   provenance, and (per `rollup.rs`) `RollupStrategy` never sets
+///   `provenance` to anything else either, so provenance alone can't tell
+///   them apart. Disambiguated instead by `target`'s own shape:
+///   `AvgToSumOverCountStrategy::matches` requires exactly one
+///   `AggIntent::Avg` measure (`rewrite.rs`'s own `avg_rewrite_target`
+///   precondition) — and `Avg` has no summary/accumulator realization at
+///   all (`implementations_for_with` dispatches it straight to
+///   `PassThrough`), so it can never be a `RollupStrategy` source either
+///   (that strategy only rolls up ordinary mergeable accumulators). A
+///   target whose sole measure is `Avg` is therefore unambiguously an
+///   `AvgToSumOverCountStrategy` candidate, and everything else this
+///   provenance produces is `RollupStrategy`'s.
+fn classify_strategy(target: &QueryExpr, winner: &ReplacementSubDAG) -> String {
+    match winner.provenance {
+        ReplacementProvenance::SummaryImplementation => match &winner.replacement {
+            Replacement::Summary(node) => match &node.expr {
+                SummaryExpr::SummaryAgg {
+                    grouping: GroupingStrategy::SharedMultiSubpopulation { .. },
+                    ..
+                } => "HydraGrouping".to_string(),
+                _ => "Sketch".to_string(),
+            },
+            // Never actually produced by SketchAlgorithmStrategy/
+            // HydraGroupingStrategy (both only ever emit
+            // Replacement::Summary) — a defensive fallback, not a case this
+            // binary expects to hit.
+            Replacement::Rewrite(_) => "Sketch".to_string(),
+        },
+        ReplacementProvenance::CseShare | ReplacementProvenance::CseRecompute => {
+            "SharedSubtree".to_string()
+        }
+        ReplacementProvenance::LogicalRewrite => {
+            if let QueryExpr::Aggregate { measures, .. } = target {
+                if let [AggIntent::Avg { .. }] = measures.as_slice() {
+                    return "AvgToSumRewrite".to_string();
+                }
+            }
+            "Rollup".to_string()
+        }
+    }
+}
+
+/// 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,
+}
+
+/// 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(target_pre_id: u32, winner: &Winner<'_>) -> TargetReplacement {
+    let strategy = classify_strategy(winner.target, winner.candidate);
+    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 {
+        target_pre_id,
+        strategy,
+        rationale: winner.candidate.rationale.clone(),
+        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)>,
+}
+
+/// Run `asap_aware_mapping::replacement::search_workload_with` (this
+/// binary's own strategy set — `default_strategies()` plus
+/// `AvgToSumOverCountStrategy`, since that strategy isn't one of that
+/// crate's own defaults) 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(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapResults {
+    let mut strategies: Vec<Box<dyn ReplacementStrategy>> = default_strategies();
+    strategies.push(Box::new(AvgToSumOverCountStrategy));
+
+    let roots: Vec<(String, Rc<QueryExpr>)> = lowered_queries
+        .iter()
+        .map(|(name, _, qe)| (name.clone(), Rc::new(qe.clone())))
+        .collect();
+    let space = search_workload_with(roots, &strategies);
+    let ranked_groups = space.cost_sorted(&DefaultCostModel);
+
+    let winners: Vec<Winner<'_>> = ranked_groups
+        .iter()
+        .filter_map(|group| {
+            let candidate = group.candidates.first()?;
+            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);
+    }
+
+    // ---- 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).
+    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(node.id, &winners[i])));
+                matched[i] = true;
+            }
+        }
+    }
+    for (winner, matched) in winners.iter().zip(&matched) {
+        if !matched {
+            let strategy = classify_strategy(winner.target, winner.candidate);
+            eprintln!(
+                "dag_export: post-asap replacement ({strategy}) matched no DagNode in any query graph"
+            );
+        }
+    }
+
+    // ---- Merged, whole-query `post_graph`, one per query ---------------
+    //
+    // A fresh `HashCache` here (rather than reusing `lookup_cache` above):
+    // `export_post_asap` calls `find_winner` at every node of every query's
+    // own tree, not just at nodes a plain `export` already flattened, so
+    // this is a genuinely separate hashing pass, not a re-walk of the same
+    // nodes the loop above already visited.
+    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)?;
+        Some(match &winners[i].candidate.replacement {
+            Replacement::Rewrite(rc) => PostAsapSubstitution::Rewrite(Rc::clone(rc)),
+            Replacement::Summary(rc) => PostAsapSubstitution::Summary(Rc::clone(rc)),
+        })
+    };
+    let post_graphs: Vec<(String, DagGraph)> = lowered_queries
+        .iter()
+        .map(|(name, _, qe)| {
+            (
+                name.clone(),
+                dag_export::export_post_asap(qe, &mut find_winner),
+            )
+        })
+        .collect();
+
+    PostAsapResults {
+        replacements,
+        post_graphs,
+    }
+}
+
 #[tokio::main]
 async fn main() {
-    let (entries, accuracy) = parse_args();
+    let (entries, accuracy, post_asap) = parse_args();
     if entries.is_empty() {
-        eprintln!("usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] ...");
+        eprintln!(
+            "usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] [--post-asap] ..."
+        );
         std::process::exit(1);
     }
 
@@ -156,13 +444,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) {
@@ -174,6 +464,20 @@ async fn main() {
         }
     }
 
+    if post_asap {
+        let results = run_post_asap(&lowered_queries);
+        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 workload = WorkloadGraph { queries };
     println!("{}", serde_json::to_string_pretty(&workload).unwrap());
 }
@@ -225,4 +529,85 @@ mod tests {
         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 = 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 == "AvgToSumRewrite"));
+
+        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"
+            );
+        }
+    }
 }
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 33e9f131..41f18a68 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -41,8 +41,11 @@
 //! `asap_types` itself never constructs a `DagNote` — see [`DagNode::notes`]
 //! for the layering rule this keeps.
 
+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};
 
@@ -71,8 +74,14 @@ pub struct DagNode {
     /// 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: QueryExpr,
+    pub source_expr: Option<QueryExpr>,
     /// 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
@@ -120,6 +129,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 +167,298 @@ 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 {
+    /// 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"` /
+    /// `"AvgToSumRewrite"` / `"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 +467,83 @@ 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(Rc<QueryExpr>),
+    /// This exact node has a winning `Replacement::Summary` — switch to
+    /// rendering `.0`'s bound `SummaryNode` shape from here down, via
+    /// [`build_summary_hybrid`].
+    Summary(Rc<SummaryNode>),
+}
+
+/// 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);
+    DagGraph {
+        nodes,
+        root: root_id,
+    }
+}
+
 /// 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
@@ -167,12 +568,71 @@ fn push_node(
         detail,
         children,
         hash,
-        source_expr: expr.clone(),
+        source_expr: Some(expr.clone()),
+        notes: Vec::new(),
+    });
+    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,
+        children,
+        hash: 0,
+        source_expr: None,
         notes: Vec::new(),
     });
     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);
+    push_summary_originated_node(nodes, kind, label, detail, children)
+}
+
 fn source_label(source: &Source) -> String {
     match source {
         Source::Table { table_ref } => table_ref.clone(),
@@ -190,7 +650,47 @@ 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)) => {
+            return build_no_recheck(&replacement, nodes, cache, find_winner);
+        }
+        Some(PostAsapSubstitution::Summary(node)) => {
+            return build_summary_hybrid(&node, nodes, cache, find_winner);
+        }
+        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 +741,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 +753,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 +765,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 +778,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 +791,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 +804,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 +821,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 +840,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 +858,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 +871,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 +892,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 +911,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 +929,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 +942,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 +959,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 +972,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 +985,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 +1006,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 +1031,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,

From 6981f5fabf559efa29762594c5a9d8dd0d556528 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 19:49:52 -0600
Subject: [PATCH 02/27] feat(dag-viewer): add Before/After mode for post-ASAP
 replacement sites

Adds a fourth view mode alongside Single/Compare/Union that lets a user
pick one of a query's --post-asap `replacements[]` entries and see its
`before`/`after` subtrees side by side, plus a whole-query option
(query.graph vs the whole-query `post_graph`), so a claimed replacement
can be visually confirmed instead of just trusted.

- index.html: new "Before/After" mode button and a secondary #baPicker
  list (grouped by target node, sorted by rank, winner marked) shown
  below the tabs while the mode is active.
- viewer.js: renderBeforeAfter/laneElements reuse Compare mode's
  compound-lane pattern for exactly two fixed lanes; renderBaPicker
  builds the per-target and whole-query picker rows; showBeforeAfterDetail
  renders a selected lane node's detail (degrades cleanly on
  SummaryDagNode's missing hash/notes fields); computeHashOwners now
  skips hash-less nodes instead of bucketing them under `undefined`.
- node-style.js: new 'summary' category (neutral gray, distinct from the
  existing 9 hues) covering the 7 post-ASAP-only SummaryDagNode kinds;
  KeepPreAsap gets an extra muted/dashed override plus its own
  pass-through icon so 'unchanged' visually reads differently from
  'the planner did something here'.
- README.md: new "Before/After mode" section.
- post_asap_fixture.json: fixture used to build/test against (3 queries
  covering Sketch/HydraGrouping rank comparison, AvgToSumRewrite, and a
  SharedSubtree CSE share; p95_pktlen hand-extended with a post_graph
  since the Rust track's --post-asap output doesn't exist yet).

Verified via Playwright screenshots (light + dark) that Single/Compare/
Union are unregressed and all three fixture queries render correctly in
Before/After mode, including the whole-query toggle and its
disabled-when-absent state.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 tools/dag-viewer/README.md              |  54 ++++
 tools/dag-viewer/index.html             |  50 ++++
 tools/dag-viewer/node-style.js          |  46 ++++
 tools/dag-viewer/post_asap_fixture.json | 149 +++++++++++
 tools/dag-viewer/viewer.js              | 328 +++++++++++++++++++++++-
 5 files changed, 616 insertions(+), 11 deletions(-)
 create mode 100644 tools/dag-viewer/post_asap_fixture.json

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index bda65d31..f4789b83 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -42,6 +42,9 @@ picker.
 - 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.
+- If a query's export carries `replacements` (`dag_export --post-asap`),
+  switch to **Before/After** mode to see one claimed replacement's before
+  and after subtrees side by side — see "Before/After mode" below.
 
 ## Render a standalone page from Python
 
@@ -245,6 +248,57 @@ its bottom-right corner (color keyed to `kind` — see `node-style.js`'s
 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.
 
+## Before/After mode
+
+`dag_export --post-asap` additionally attaches a `replacements` array to each
+query — one entry per place in the query where `asap-aware-mapping` actually
+*chose* a real optimization (cost-ranked, not just "could apply"): a sketch
+mapping, a CSE share/recompute, a workload-aware rollup, Hydra
+frequency-sketch grouping, or an `avg`→`sum`/`count` rewrite. Each entry
+carries its own small `before` subtree (the pre-ASAP nodes it replaced) and
+`after` subtree — either a rewritten pre-ASAP graph (`after.kind ===
+"Rewrite"`, e.g. the `avg` rewrite) or a post-ASAP "Summary" graph
+(`after.kind === "Summary"`, e.g. a sketch realization), plus `strategy`,
+`provenance`, a human `rationale`, and this candidate's `rank`/`cost` among
+whatever else was considered for the same target (`rank: 0` is the winner).
+
+**Before/After** mode (only shown once a query with `replacements` is
+loaded) reuses the Single-mode tab bar to pick a query, then shows a
+secondary picker below the tabs listing every entry, grouped by which
+pre-ASAP node it targets (so a node with several ranked candidates — e.g.
+one query's Kll sketch vs. a Hydra-grouped alternative for the same
+aggregate — reads as one section instead of unrelated rows) and sorted by
+rank within a group so the winner is always first and marked. Pick a row and
+the main view draws that entry's `before` and `after` as two fixed lanes —
+**Before** / **After** — using the same compound-lane layout Compare mode
+uses for its per-query lanes, just with exactly two lanes fed from one
+entry's two subtrees instead of N lanes fed from N queries.
+
+The picker also always offers a **Whole query** option: `query.graph`
+(Before) against the query's whole-query merged post-ASAP graph,
+`query.post_graph` (After) — the `NamedGraph`-level counterpart to picking
+one target's tiny subtrees. It's disabled rather than hidden when a query's
+export has no `post_graph` (no `--post-asap`, or the query had zero
+replacements) — the option always exists, it just isn't always populated.
+
+A Summary graph's nodes (`SummaryDagNode`, from `after.kind === "Summary"` or
+from `post_graph`) are a different shape than the pre-ASAP `DagNode`s
+everywhere else in this viewer: `kind` is one of `KeepPreAsap`, `SummaryAgg`,
+`SummaryJoin`, `SummarySubtract`, `SummaryDelete`, `SummaryEstimate`,
+`SummaryMerge`, and there's no `hash` (no corresponding `QueryExpr` to hash)
+and no `notes`. `node-style.js` maps all seven to a new `summary` category —
+neutral gray rather than another saturated hue, both because a 10th vivid
+color starts crowding the other 9 and because "materialized post-ASAP
+structure" reads better as its own muted family than as one more member of
+the pre-ASAP rainbow. `KeepPreAsap` — literally an unchanged pre-ASAP subtree
+carried through as-is — gets an even more washed-out, dashed treatment on
+top of that (see `buildCyStyle`'s `node[kind = "KeepPreAsap"]` override in
+`viewer.js`), so a glance at an After lane separates "the planner did
+something here" from "left alone." Side-panel node inspection is otherwise
+identical to every other mode: click a node, get its `detail` dumped
+verbatim; a `SummaryDagNode`'s missing `hash`/`notes` just means the
+cross-query "shared with" note and notes block don't render, not a crash.
+
 ## Vendored dependencies
 
 `cytoscape.min.js`, `dagre.min.js`, and `cytoscape-dagre.js` are vendored here
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 4678a7af..72ee9ce9 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -110,6 +110,54 @@
   .tab.checkTab { display: flex; align-items: center; gap: 0.35rem; cursor: default; }
   .tab.checkTab input { cursor: pointer; }
   .modeToggle { display: flex; gap: 0.3rem; }
+  #baPicker {
+    display: none;
+    flex-wrap: wrap;
+    gap: 0.6rem 1.2rem;
+    padding: 0.55rem 0.75rem;
+    border-bottom: 1px solid var(--border);
+    background: var(--panel);
+  }
+  #baPicker.visible { display: flex; }
+  .baGroup { display: flex; flex-direction: column; gap: 0.3rem; min-width: 220px; }
+  .baGroupLabel {
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: .03em;
+    color: var(--muted);
+  }
+  .baRow {
+    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);
+    cursor: pointer;
+    font: inherit;
+    font-size: 0.78rem;
+    text-align: left;
+  }
+  .baRow:hover { border-color: var(--accent); }
+  .baRow:disabled { opacity: 0.55; cursor: not-allowed; }
+  .baRow:disabled:hover { border-color: var(--border); }
+  .baRow.active {
+    border-color: var(--accent);
+    background: var(--bg);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 15%, transparent);
+  }
+  .baRow .baWinner {
+    font-size: 0.66rem;
+    font-weight: 700;
+    color: var(--accent);
+    border: 1px solid var(--accent);
+    border-radius: 999px;
+    padding: 0.05rem 0.4rem;
+    flex-shrink: 0;
+  }
+  .baRow .baMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
   .proxyNote {
     font-size: 0.72rem;
     color: var(--muted);
@@ -285,6 +333,7 @@ <h1>ASAP query DAG viewer</h1>
     <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" id="modeBeforeAfterBtn" data-mode="beforeafter">Before/After</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="clearBtn">Clear all</button>
@@ -295,6 +344,7 @@ <h1>ASAP query DAG viewer</h1>
 </header>
 
 <div id="tabs"></div>
+<div id="baPicker"></div>
 
 <div id="main">
   <div id="empty">
diff --git a/tools/dag-viewer/node-style.js b/tools/dag-viewer/node-style.js
index 3dfb7168..ca6c31d1 100644
--- a/tools/dag-viewer/node-style.js
+++ b/tools/dag-viewer/node-style.js
@@ -3,6 +3,11 @@
 // 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).
+//
+// Also covers the 7 post-ASAP-only SummaryDagNode kinds (KeepPreAsap,
+// SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate,
+// SummaryMerge) that only ever appear in Before/After mode's After lane when
+// an entry's `after.kind === "Summary"` — see the `summary` category below.
 
 // kind (DagNode.kind from crates/ir/src/dag_export.rs) -> category name.
 const KIND_CATEGORY = {
@@ -31,6 +36,14 @@ const KIND_CATEGORY = {
   Sort: 'sort',
   Limit: 'sort',
   LetBinding: 'bind',
+  // Post-ASAP SummaryDagNode kinds (Before/After mode's After lane only).
+  KeepPreAsap: 'summary',
+  SummaryAgg: 'summary',
+  SummaryJoin: 'summary',
+  SummarySubtract: 'summary',
+  SummaryDelete: 'summary',
+  SummaryEstimate: 'summary',
+  SummaryMerge: 'summary',
 };
 
 const ICON_STROKE = '2.2';
@@ -52,8 +65,23 @@ const ICONS = {
   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: stacked layers, for the post-ASAP `summary` category — a materialized
+  // structure (a sketch, a rollup, a merged/estimated join) rather than a
+  // pre-ASAP relational operator.
+  summary: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="9" y="7" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="19" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="31" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
 };
 
+// KeepPreAsap-only: a dashed box with a through-arrow, standing in for
+// "unchanged pre-ASAP content carried through as-is" — see the `summary`
+// CATEGORIES entry and buildCyStyle's `node[kind = "KeepPreAsap"]` override
+// in viewer.js for why this doesn't just reuse ICONS.summary's stroke color.
+const KEEP_PRE_ASAP_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="7" y="14" width="34" height="20" rx="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-dasharray="4 3"/><path d="M13 24h22m0 0l-6-6m6 6l-6 6" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+
+function keepPreAsapIconDataUri() {
+  const muted = getComputedStyle(document.documentElement).getPropertyValue('--muted').trim() || '#6b7280';
+  return svgDataUri(KEEP_PRE_ASAP_ICON(muted));
+}
+
 // 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.
@@ -115,6 +143,24 @@ const CATEGORIES = {
     light: { bg: '#fff5ea', border: '#b45309' },
     dark: { bg: '#3a2408', border: '#fb923c' },
   },
+  // Post-ASAP only (Before/After mode's After 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 (Before/After mode only)',
+    light: { bg: '#f1f2f4', border: '#4b5563' },
+    dark: { bg: '#20242b', border: '#9ca3af' },
+  },
 };
 
 const ROOT_BADGE = {
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/viewer.js b/tools/dag-viewer/viewer.js
index 76bba97b..de31d310 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -8,9 +8,19 @@
 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;
@@ -21,16 +31,30 @@ let zoom = 1;
 // 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.
+// edges. See the "Compare and Union mode" section of README.md. 'beforeafter'
+// picks one query (via the same tab bar as 'single') and one entry from its
+// `replacements[]` (via the secondary picker in #baPicker), then draws that
+// entry's `before` and `after.graph` as two fixed Compare-mode-style lanes.
 let mode = 'single';
 // Indices into `queries` currently selected to participate in compare/union.
 let participants = new Set();
+// Before/After mode only: index into `queries[activeIndex].replacements`
+// currently shown in the two lanes. -1 means "nothing picked yet" (defaults
+// to the first entry on render). Reset whenever the active query changes,
+// since an index is only meaningful within that query's own array.
+let baSelectedIndex = -1;
+// Before/After mode only: true when the picker's "Whole query" option is
+// selected instead of a per-target replacement entry — draws the query's
+// whole `graph` (Before) against its whole `post_graph` (After) rather than
+// one entry's tiny before/after subgraphs. Reset alongside baSelectedIndex.
+let baWholeQuery = false;
 
 const dropzone = document.getElementById('dropzone');
 const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
 const tabsEl = document.getElementById('tabs');
+const baPickerEl = document.getElementById('baPicker');
 const cyOuterEl = document.getElementById('cyOuter');
 const cyEl = document.getElementById('cy');
 const modeHintEl = document.getElementById('modeHint');
@@ -56,6 +80,8 @@ clearBtn.addEventListener('click', () => {
   activeIndex = -1;
   mode = 'single';
   participants = new Set();
+  baSelectedIndex = -1;
+  baWholeQuery = false;
   setModeButtons();
   render();
 });
@@ -70,16 +96,24 @@ document.querySelectorAll('#modeToggle .btn').forEach((btn) => {
     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) {
+    if ((mode === 'compare' || mode === 'union') && participants.size === 0) {
       queries.forEach((_, i) => participants.add(i));
     }
+    // First switch into Before/After: reuse the single-view tab selection
+    // (defaulting to the first query) and let renderBeforeAfter default
+    // baSelectedIndex to that query's first replacement.
+    if (mode === 'beforeafter') {
+      if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
+      baSelectedIndex = -1;
+      baWholeQuery = false;
+    }
     render();
   });
 });
 
 function setModeButtons() {
   document.querySelectorAll('#modeToggle .btn').forEach((b) => b.classList.toggle('active', b.dataset.mode === mode));
-  proxyNote.style.display = mode === 'single' ? 'none' : 'inline';
+  proxyNote.style.display = mode === 'compare' || mode === 'union' ? 'inline' : 'none';
 }
 
 function loadFiles(fileList) {
@@ -97,7 +131,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}`);
@@ -127,6 +161,12 @@ function computeHashOwners(subsetQueries) {
   for (const q of list) {
     const seenInThisQuery = new Set();
     for (const node of q.graph.nodes) {
+      // A post-ASAP-only node (e.g. mixed into a whole-query post_graph) has
+      // no corresponding QueryExpr to hash — skip rather than bucketing
+      // every such node together under the key `undefined`. `graph.nodes`
+      // (as opposed to `post_graph.nodes`) never actually contains one of
+      // these today, but this stays correct if that ever changes.
+      if (node.hash === undefined) continue;
       if (seenInThisQuery.has(node.hash)) continue;
       seenInThisQuery.add(node.hash);
       if (!owners.has(node.hash)) owners.set(node.hash, new Set());
@@ -145,6 +185,7 @@ function getParticipants() {
 function render() {
   if (queries.length === 0) {
     tabsEl.innerHTML = '';
+    baPickerEl.classList.remove('visible');
     emptyEl.style.display = 'flex';
     cyOuterEl.style.display = 'none';
     sidepanel.style.display = 'none';
@@ -158,24 +199,36 @@ function render() {
   renderTabs();
 
   if (mode === 'single') {
+    baPickerEl.classList.remove('visible');
     if (activeIndex === -1) activeIndex = 0;
     renderGraph(queries[activeIndex]);
   } else if (mode === 'compare') {
+    baPickerEl.classList.remove('visible');
     renderCompare(getParticipants());
-  } else {
+  } else if (mode === 'union') {
+    baPickerEl.classList.remove('visible');
     renderUnion(getParticipants());
+  } else {
+    renderBeforeAfter();
   }
   renderLegend();
 }
 
 function renderTabs() {
   tabsEl.innerHTML = '';
-  if (mode === 'single') {
+  if (mode === 'single' || mode === 'beforeafter') {
     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(); });
+      tab.addEventListener('click', () => {
+        activeIndex = i;
+        if (mode === 'beforeafter') {
+          baSelectedIndex = -1;
+          baWholeQuery = false;
+        }
+        render();
+      });
       tabsEl.appendChild(tab);
     });
     return;
@@ -253,6 +306,23 @@ function buildCyStyle() {
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
     ...categoryStyles,
+    {
+      // KeepPreAsap (Before/After mode's After 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',
+        'background-image': keepPreAsapIconDataUri(),
+      },
+    },
     {
       selector: 'node.shared',
       style: {
@@ -409,6 +479,10 @@ function finalizeGraphInteractions() {
       showUnionDetail(n.data());
       return;
     }
+    if (n.data('isBeforeAfter')) {
+      showBeforeAfterDetail(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);
   });
@@ -664,6 +738,224 @@ function renderUnion(chosen) {
   fitAndSyncZoom();
 }
 
+// ── Before/After mode: one replacement site's before/after subtree ───────
+// Reuses the Single-mode tab bar to pick a query, then a secondary picker
+// (#baPicker, built by renderBaPicker) to pick one entry from that query's
+// `replacements[]`. The chosen entry's `before` and `after.graph` are drawn
+// as exactly two Compare-mode-style lanes ("Before" / "After") via the same
+// compound-lane pattern renderCompare uses for N query lanes — here it's
+// always exactly 2, and both lanes come from one entry instead of from two
+// different queries.
+function renderBeforeAfter() {
+  const query = activeIndex >= 0 ? queries[activeIndex] : undefined;
+  const replacements = (query && query.replacements) || [];
+  const hasPostGraph = !!(query && query.post_graph);
+  renderBaPicker(query, replacements, hasPostGraph);
+
+  if (!query) {
+    viewTitleEl.textContent = 'Before/After';
+    renderSourcePanel([]);
+    showModeHint('Select a query above to inspect its replacements.');
+    return;
+  }
+  renderSourcePanel([query]);
+  if (replacements.length === 0 && !hasPostGraph) {
+    viewTitleEl.textContent = `Before/After: ${query.name}`;
+    showModeHint(`${query.name} has no recorded replacements in this export.`);
+    return;
+  }
+  // A query with no per-target replacements but a post_graph (or the user's
+  // explicit pick) falls back to the whole-query view rather than a hint —
+  // it's the one option that's actually available.
+  if (!baWholeQuery && replacements.length === 0) baWholeQuery = true;
+  hideModeHint();
+
+  let beforeNodes, beforeRoot, afterNodes, afterRoot, titleSuffix, afterLabel;
+  if (baWholeQuery) {
+    beforeNodes = query.graph.nodes;
+    beforeRoot = query.graph.root;
+    afterNodes = query.post_graph.nodes;
+    afterRoot = query.post_graph.root;
+    titleSuffix = 'whole query';
+    afterLabel = 'After (post-ASAP graph)';
+  } else {
+    if (baSelectedIndex === -1 || baSelectedIndex >= replacements.length) baSelectedIndex = 0;
+    const entry = replacements[baSelectedIndex];
+    beforeNodes = entry.before.nodes;
+    beforeRoot = entry.before.root;
+    afterNodes = entry.after.graph.nodes;
+    afterRoot = entry.after.graph.root;
+    titleSuffix = `${entry.strategy} (rank ${entry.rank})`;
+    afterLabel = entry.after.kind === 'Summary' ? 'After (Summary)' : 'After (Rewrite)';
+  }
+
+  viewTitleEl.textContent = `Before/After: ${query.name} — ${titleSuffix}`;
+
+  const elements = [
+    ...laneElements('ba-before', 'Before', beforeNodes, beforeRoot),
+    ...laneElements('ba-after', afterLabel, afterNodes, afterRoot),
+  ];
+
+  buildCy(elements);
+  finalizeGraphInteractions();
+  applyHighlighting();
+  clearDetail();
+  fitAndSyncZoom();
+}
+
+// Builds one Compare-mode-style lane (a dashed compound parent plus its
+// nodes/edges) for Before/After mode. `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 showBeforeAfterDetail below.
+function laneElements(laneId, laneLabel, nodes, rootId) {
+  const elements = [
+    { data: { id: laneId, label: laneLabel, isLane: true }, classes: 'laneParent', selectable: false, grabbable: false },
+  ];
+  for (const node of nodes) {
+    elements.push({
+      data: {
+        id: `${laneId}-${node.id}`,
+        parent: laneId,
+        label: `${node.kind}\n${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 === rootId,
+        isBeforeAfter: true,
+        laneId,
+      },
+    });
+  }
+  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-${laneId}-${node.id}-${childId}`,
+          source: `${laneId}-${childId}`,
+          target: `${laneId}-${node.id}`,
+        },
+      });
+    }
+  }
+  return elements;
+}
+
+// Secondary picker shown below #tabs while Before/After mode is active:
+// a "Whole query" option (query.graph vs query.post_graph in full, disabled
+// rather than omitted when this query's export has no post_graph — the
+// option always exists, it just isn't always populated) followed by one row
+// per `replacements[]` entry, grouped by `target_pre_id` (so a node with
+// multiple ranked candidates — e.g. p95_pktlen's Sketch vs HydraGrouping
+// fixture — reads as one section instead of two unrelated rows) and sorted
+// by rank within a group so the winner (rank 0) is always listed first and
+// visually marked.
+function renderBaPicker(query, replacements, hasPostGraph) {
+  baPickerEl.innerHTML = '';
+  if (!query || (replacements.length === 0 && !hasPostGraph)) {
+    baPickerEl.classList.remove('visible');
+    return;
+  }
+  baPickerEl.classList.add('visible');
+
+  const wholeGroup = document.createElement('div');
+  wholeGroup.className = 'baGroup';
+  const wholeLabel = document.createElement('div');
+  wholeLabel.className = 'baGroupLabel';
+  wholeLabel.textContent = 'Whole query';
+  wholeGroup.appendChild(wholeLabel);
+  const wholeRow = document.createElement('button');
+  wholeRow.type = 'button';
+  wholeRow.className = 'baRow' + (baWholeQuery ? ' active' : '');
+  wholeRow.disabled = !hasPostGraph;
+  wholeRow.innerHTML = hasPostGraph
+    ? `<span>Whole query — ${query.graph.nodes.length} nodes vs. post-ASAP graph</span>`
+    : `<span>Whole query</span><span class="baMeta">no post-ASAP graph in this export</span>`;
+  if (hasPostGraph) {
+    wholeRow.addEventListener('click', () => {
+      baWholeQuery = true;
+      render();
+    });
+  }
+  wholeGroup.appendChild(wholeRow);
+  baPickerEl.appendChild(wholeGroup);
+
+  if (replacements.length === 0) return;
+
+  const groups = new Map(); // target_pre_id -> [index into replacements]
+  replacements.forEach((r, idx) => {
+    if (!groups.has(r.target_pre_id)) groups.set(r.target_pre_id, []);
+    groups.get(r.target_pre_id).push(idx);
+  });
+  const byId = new Map(query.graph.nodes.map((n) => [n.id, n]));
+
+  for (const [targetId, idxs] of groups) {
+    idxs.sort((a, b) => replacements[a].rank - replacements[b].rank);
+    const targetNode = byId.get(targetId);
+    const nodeDesc = targetNode ? `${targetNode.kind} — ${targetNode.label}` : `node #${targetId}`;
+
+    const group = document.createElement('div');
+    group.className = 'baGroup';
+    const groupLabel = document.createElement('div');
+    groupLabel.className = 'baGroupLabel';
+    groupLabel.textContent = idxs.length > 1 ? `${nodeDesc} — ${idxs.length} candidates` : nodeDesc;
+    group.appendChild(groupLabel);
+
+    idxs.forEach((idx) => {
+      const r = replacements[idx];
+      const row = document.createElement('button');
+      row.type = 'button';
+      row.className = 'baRow' + (!baWholeQuery && idx === baSelectedIndex ? ' active' : '');
+      const rationale = r.rationale || '';
+      const rationalePrefix = rationale.length > 90 ? `${rationale.slice(0, 90)}…` : rationale;
+      row.innerHTML = `${r.rank === 0 ? '<span class="baWinner">winner</span>' : ''}<span>${escapeHtml(r.strategy)} — ${escapeHtml(rationalePrefix)}</span><span class="baMeta">rank ${r.rank}, cost ${r.cost}</span>`;
+      row.addEventListener('click', () => {
+        baWholeQuery = false;
+        baSelectedIndex = idx;
+        render();
+      });
+      group.appendChild(row);
+    });
+    baPickerEl.appendChild(group);
+  }
+}
+
+// Before/After mode's variant of showDetail/showUnionDetail: `data` is one
+// lane node's cytoscape data (see laneElements above). Deliberately skips
+// the cross-query "shared with" note those two render (meaningless for two
+// lanes drawn from one entry's own before/after subtrees) — notesHtml and
+// JSON.stringify(node.detail) below already degrade cleanly when `notes`/
+// other pre-ASAP-only fields are simply absent, which is the SummaryDagNode
+// case (no `hash`, no `notes`).
+function showBeforeAfterDetail(data) {
+  const node = data.node;
+  const category = categoryOf(node.kind);
+  const catColors = categoryColors(category);
+  const catLabel = (CATEGORIES[category] || {}).label || category;
+  const laneName = data.laneId === 'ba-before' ? 'Before' : 'After';
+
+  const rootHtml = data.root
+    ? `<div class="rootNote">This is the root of the ${laneName} subtree.</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}
+    ${notesHtml(node)}
+    <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
+  `;
+}
+
 // ── Shared rendering bits ─────────────────────────────────────────────────
 
 function renderSourcePanel(qs) {
@@ -691,6 +983,14 @@ function renderSourcePanel(qs) {
 
 function applyHighlighting() {
   if (!cy) return;
+  if (mode === 'beforeafter') {
+    // Shared-subtree highlighting is a cross-query proxy (computeHashOwners
+    // matches a hash across distinct query names) — meaningless for two
+    // lanes drawn from one query's own before/after subtrees, so Before/
+    // After mode never marks '.shared'.
+    cy.nodes().forEach((n) => n.removeClass('shared'));
+    return;
+  }
   const owners = mode === 'single' ? computeHashOwners() : computeHashOwners(getParticipants().map((i) => queries[i]));
   cy.nodes().forEach((n) => {
     if (n.data('isLane') || n.data('isUnion')) return;
@@ -807,6 +1107,12 @@ function renderLegend() {
     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>`);
   }
+  if (mode === 'beforeafter') {
+    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('');
 }
 
@@ -833,7 +1139,7 @@ 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;
 }
 

From 3174518b2151f54b015512f9821ab8b6be80e875 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 20:10:24 -0600
Subject: [PATCH 03/27] fix(devtools): make DagNode::hash Option<u64> to fix
 false shared-subtree matches
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Integration fix after merging the post-ASAP export (--post-asap) and
dag-viewer Before/After tracks: export_post_asap's post-ASAP-originated
nodes (SummaryAgg, SummaryEstimate, etc. — anything with no
corresponding QueryExpr) were emitting hash: 0 as a placeholder. The
viewer's shared-subtree highlighting only treats hash === undefined as
'no hash' (by design, per the frontend track's own report), so every
post-ASAP-originated node across every query/graph would collide on
hash 0 and get spuriously rung as 'shared' with each other.

Fixed at the source: DagNode::hash is now Option<u64>, None (and
omitted from JSON) for nodes with no QueryExpr to hash — mirroring how
source_expr already handles the same situation. Verified real
--post-asap output flows through the merged dag-viewer correctly with
no false-shared highlighting and no regressions: full workspace test
suite (asap-types, asap-aware-mapping, asap-devtools, and everything
else) passes unchanged, fmt/clippy clean, and manually confirmed via
Playwright against real generated JSON (sketch mapping and
avg-to-sum-rewrite queries) in both Before/After per-target and
whole-query views.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 crates/asap-aware-mapping/src/explanation.rs |  3 ++-
 crates/devtools/src/bin/dag_export.rs        |  4 ++--
 crates/types/src/dag_export.rs               | 21 ++++++++++++++------
 3 files changed, 19 insertions(+), 9 deletions(-)

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/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 99a83237..71843747 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -166,7 +166,7 @@ fn annotate_with_explanations(
 ) {
     for (i, explanation) in explanations.iter().enumerate() {
         for node in graph.nodes.iter_mut() {
-            if node.hash == explanation.node_hash
+            if node.hash == Some(explanation.node_hash)
                 && node.source_expr.as_ref() == Some(explanation.target.as_ref())
             {
                 node.notes.push(DagNote {
@@ -523,7 +523,7 @@ 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);
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 41f18a68..9534eed6 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -69,7 +69,16 @@ pub struct DagNode {
     /// 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
@@ -560,7 +569,7 @@ 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,
@@ -598,7 +607,7 @@ fn push_summary_originated_node(
         label,
         detail,
         children,
-        hash: 0,
+        hash: None,
         source_expr: None,
         notes: Vec::new(),
     });
@@ -1229,7 +1238,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"
         );
     }
@@ -1257,7 +1266,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())"
         );
 
@@ -1265,7 +1274,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"
         );

From c1c6b84108c5d107ec88d6794f9beb1574aa1f2e Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 20:18:20 -0600
Subject: [PATCH 04/27] fix(devtools): drop the now-redundant
 AvgToSumOverCountStrategy wiring
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

default_strategies() already includes it as of #282 — this binary no
longer needs its own custom strategy list, just plain
search_workload(). Also reworded the 'unmatched winner' diagnostic:
with AvgToSumOverCountStrategy now running by default, its rewrite
output routinely exposes new sum/count descendants that the same
search pass independently sketch-ranks — real winners, but ones with
no node in any query's original pre-rewrite graph to attach a flat
replacements[] entry to (expected, not a bug: still fully represented
in that query's post_graph). The old wording read like an error for
what is normally an expected case.

Verified: cargo test --workspace, fmt, and clippy all clean; manually
re-ran --post-asap on an AVG query and confirmed the JSON output is
identical (only the diagnostic wording changed).
---
 crates/devtools/src/bin/dag_export.rs | 124 ++++++++++++++++----------
 1 file changed, 78 insertions(+), 46 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 71843747..d07e6644 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -19,10 +19,11 @@
 //       --epsilon 0.01 --sql "SELECT quantile(0.99, latency) FROM metrics" --name p99
 //
 // `--post-asap` is optional and off by default. When passed, this binary
-// additionally runs `asap_aware_mapping::replacement::search_workload_with`
-// (with `default_strategies()` plus `AvgToSumOverCountStrategy`, which isn't
-// one of that crate's own defaults) over every lowered query and ranks each
-// discovered `MemoGroup` via `PlanSpace::cost_sorted`. The best-ranked
+// 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
@@ -53,10 +54,8 @@ use std::rc::Rc;
 
 use asap_aware_mapping::cost_model::DefaultCostModel;
 use asap_aware_mapping::replacement::{
-    default_strategies, search_workload_with, Replacement, ReplacementProvenance,
-    ReplacementStrategy, ReplacementSubDAG,
+    search_workload, Replacement, ReplacementProvenance, ReplacementSubDAG,
 };
-use asap_aware_mapping::rewrite::AvgToSumOverCountStrategy;
 use asap_types::dag_export::{
     self, DagGraph, DagNote, NamedGraph, PostAsapSubstitution, TargetReplacement,
     TargetReplacementAfter, WorkloadGraph,
@@ -309,23 +308,20 @@ struct PostAsapResults {
     post_graphs: Vec<(String, DagGraph)>,
 }
 
-/// Run `asap_aware_mapping::replacement::search_workload_with` (this
-/// binary's own strategy set — `default_strategies()` plus
-/// `AvgToSumOverCountStrategy`, since that strategy isn't one of that
-/// crate's own defaults) 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.
+/// 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(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapResults {
-    let mut strategies: Vec<Box<dyn ReplacementStrategy>> = default_strategies();
-    strategies.push(Box::new(AvgToSumOverCountStrategy));
-
     let roots: Vec<(String, Rc<QueryExpr>)> = lowered_queries
         .iter()
         .map(|(name, _, qe)| (name.clone(), Rc::new(qe.clone())))
         .collect();
-    let space = search_workload_with(roots, &strategies);
+    let space = search_workload(roots);
     let ranked_groups = space.cost_sorted(&DefaultCostModel);
 
     let winners: Vec<Winner<'_>> = ranked_groups
@@ -349,12 +345,50 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
         by_hash.entry(hash).or_default().push(i);
     }
 
+    // ---- 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.
+    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)?;
+        Some(match &winners[i].candidate.replacement {
+            Replacement::Rewrite(rc) => PostAsapSubstitution::Rewrite(Rc::clone(rc)),
+            Replacement::Summary(rc) => PostAsapSubstitution::Summary(Rc::clone(rc)),
+        })
+    };
+    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).
+    // 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()];
@@ -370,40 +404,38 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
             }
         }
     }
+
+    // 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 = classify_strategy(winner.target, winner.candidate);
             eprintln!(
-                "dag_export: post-asap replacement ({strategy}) matched no DagNode in any query graph"
+                "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"
             );
         }
     }
 
-    // ---- Merged, whole-query `post_graph`, one per query ---------------
-    //
-    // A fresh `HashCache` here (rather than reusing `lookup_cache` above):
-    // `export_post_asap` calls `find_winner` at every node of every query's
-    // own tree, not just at nodes a plain `export` already flattened, so
-    // this is a genuinely separate hashing pass, not a re-walk of the same
-    // nodes the loop above already visited.
-    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)?;
-        Some(match &winners[i].candidate.replacement {
-            Replacement::Rewrite(rc) => PostAsapSubstitution::Rewrite(Rc::clone(rc)),
-            Replacement::Summary(rc) => PostAsapSubstitution::Summary(Rc::clone(rc)),
-        })
-    };
-    let post_graphs: Vec<(String, DagGraph)> = lowered_queries
-        .iter()
-        .map(|(name, _, qe)| {
-            (
-                name.clone(),
-                dag_export::export_post_asap(qe, &mut find_winner),
-            )
-        })
-        .collect();
-
     PostAsapResults {
         replacements,
         post_graphs,

From 08b4f7ba7af79997d114002ff29d62fbcfc9f2d0 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 20:35:21 -0600
Subject: [PATCH 05/27] fix(devtools): don't splice a trivial keep_pre_asap
 fallback into post_graph

Found via manual testing against real corpus queries (not the toy
examples used so far): a single, standalone STDDEV_POP aggregate
crashed dag_export --post-asap with a stack overflow, no sharing or
rewriting involved at all.

Root cause: STDDEV_POP (like AVG) dispatches to
Implementation::PassThrough with no alternative strategy of its own,
so SketchAlgorithmStrategy's only candidate for it is
keep_pre_asap()'s conservative fallback -- Replacement::Summary
wrapping the entire target as SummaryExpr::KeepPreAsap. run_post_asap
was treating this like any other winner and handing it to
export_post_asap, whose find_winner re-checks every node inside a
spliced KeepPreAsap payload by design (so a target nested underneath
one still gets found) -- but this payload structurally is the
enclosing target, so the fresh check finds the identical winner again,
unconditionally, forever.

This is the exact "no-op candidate" concept explanation.rs's own
sketch_finding_reason already excludes from being reported as a
finding. run_post_asap's own winner selection just wasn't applying
that same filter. Fixed by skipping a candidate whose
Replacement::Summary is a bare top-level KeepPreAsap when building
winners, with a regression test exercising the exact repro.

Also verified against several real corpus queries end to end
(previously only exercised with hand-written toy SQL): PR-PKT/FT-PKT
(#44/#49 in synthetic_packet_trace_queries.sql) now correctly show a
genuine Rollup relationship, and P-LEN-AVG (#14) shows the real
avg -> sum/count rewrite -- both screenshotted for the PR description.

Verified: cargo test --workspace, fmt, and clippy all clean.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 crates/devtools/src/bin/dag_export.rs | 80 +++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index d07e6644..0bb399e2 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -324,10 +324,38 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
     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(Box::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,
@@ -642,4 +670,56 @@ mod tests {
             );
         }
     }
+
+    /// 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 = 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());
+    }
 }

From 60102ef29d21c2763d37d799c34883fb58f87d71 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:34:10 -0600
Subject: [PATCH 06/27] feat: visualize explicit post-ASAP planner decisions

---
 crates/asap-aware-mapping/src/cost_model.rs  |   5 +
 crates/asap-aware-mapping/src/grouping.rs    |   1 +
 crates/asap-aware-mapping/src/replacement.rs |  38 +-
 crates/asap-aware-mapping/src/rewrite.rs     |   1 +
 crates/asap-aware-mapping/src/rollup.rs      |   1 +
 crates/devtools/src/bin/dag_export.rs        | 118 +++---
 crates/types/src/dag_export.rs               |  93 ++++-
 tools/dag-viewer/README.md                   |  80 +++--
 tools/dag-viewer/index.html                  |  52 +++
 tools/dag-viewer/planner-ui.js               |  48 +++
 tools/dag-viewer/render.py                   | 199 ++++++++++-
 tools/dag-viewer/server.py                   | 107 ++++++
 tools/dag-viewer/test_render.py              | 103 +++++-
 tools/dag-viewer/viewer.js                   | 355 ++++++++-----------
 14 files changed, 862 insertions(+), 339 deletions(-)
 create mode 100644 tools/dag-viewer/planner-ui.js
 create mode 100644 tools/dag-viewer/server.py

diff --git a/crates/asap-aware-mapping/src/cost_model.rs b/crates/asap-aware-mapping/src/cost_model.rs
index 9e92cf60..a5b910e3 100644
--- a/crates/asap-aware-mapping/src/cost_model.rs
+++ b/crates/asap-aware-mapping/src/cost_model.rs
@@ -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/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/replacement.rs b/crates/asap-aware-mapping/src/replacement.rs
index 257455c7..1a0b65ca 100644
--- a/crates/asap-aware-mapping/src/replacement.rs
+++ b/crates/asap-aware-mapping/src/replacement.rs
@@ -446,6 +446,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 +480,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 +1107,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,
@@ -1493,6 +1508,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 +1520,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".
@@ -2565,11 +2582,23 @@ 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
+                    },
+                ));
             }
 
             for candidate in &proposed {
@@ -4314,16 +4343,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 +4610,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 +4832,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/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 0bb399e2..cd885de4 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -53,15 +53,12 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use asap_aware_mapping::cost_model::DefaultCostModel;
-use asap_aware_mapping::replacement::{
-    search_workload, Replacement, ReplacementProvenance, ReplacementSubDAG,
-};
+use asap_aware_mapping::replacement::{search_workload, Replacement, ReplacementSubDAG};
 use asap_types::dag_export::{
-    self, DagGraph, DagNote, NamedGraph, PostAsapSubstitution, TargetReplacement,
+    self, DagDecision, DagGraph, DagNote, NamedGraph, PostAsapSubstitution, TargetReplacement,
     TargetReplacementAfter, WorkloadGraph,
 };
-use asap_types::post_asap::{GroupingStrategy, SummaryExpr};
-use asap_types::pre_asap::agg_intent::AggIntent;
+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};
@@ -178,65 +175,6 @@ fn annotate_with_explanations(
     }
 }
 
-/// Which display `strategy` label a winning candidate earns, derived from
-/// its `ReplacementProvenance` plus (for `SummaryImplementation`/
-/// `LogicalRewrite`, which each cover more than one concrete strategy) a
-/// look at the winning candidate's own shape:
-///
-/// - `SummaryImplementation` covers both `SketchAlgorithmStrategy` and
-///   `HydraGroupingStrategy` — both produce `Replacement::Summary`
-///   candidates with this same provenance, distinguished only by whether
-///   the bound `SummaryAgg`'s own `grouping` chose
-///   `GroupingStrategy::SharedMultiSubpopulation` (Hydra) or not (an
-///   ordinary per-subpopulation sketch instance).
-/// - `CseShare`/`CseRecompute` both come from `SharedSubtreeStrategy`'s own
-///   two-way share-vs-recompute pair — one label either way, since the
-///   *choice* of which of the two won is exactly what `rank`/`cost`/`after`
-///   already show, not something the strategy label itself needs to encode.
-/// - `LogicalRewrite` covers both `AvgToSumOverCountStrategy` and
-///   `RollupStrategy` — both emit a `Replacement::Rewrite` with this same
-///   provenance, and (per `rollup.rs`) `RollupStrategy` never sets
-///   `provenance` to anything else either, so provenance alone can't tell
-///   them apart. Disambiguated instead by `target`'s own shape:
-///   `AvgToSumOverCountStrategy::matches` requires exactly one
-///   `AggIntent::Avg` measure (`rewrite.rs`'s own `avg_rewrite_target`
-///   precondition) — and `Avg` has no summary/accumulator realization at
-///   all (`implementations_for_with` dispatches it straight to
-///   `PassThrough`), so it can never be a `RollupStrategy` source either
-///   (that strategy only rolls up ordinary mergeable accumulators). A
-///   target whose sole measure is `Avg` is therefore unambiguously an
-///   `AvgToSumOverCountStrategy` candidate, and everything else this
-///   provenance produces is `RollupStrategy`'s.
-fn classify_strategy(target: &QueryExpr, winner: &ReplacementSubDAG) -> String {
-    match winner.provenance {
-        ReplacementProvenance::SummaryImplementation => match &winner.replacement {
-            Replacement::Summary(node) => match &node.expr {
-                SummaryExpr::SummaryAgg {
-                    grouping: GroupingStrategy::SharedMultiSubpopulation { .. },
-                    ..
-                } => "HydraGrouping".to_string(),
-                _ => "Sketch".to_string(),
-            },
-            // Never actually produced by SketchAlgorithmStrategy/
-            // HydraGroupingStrategy (both only ever emit
-            // Replacement::Summary) — a defensive fallback, not a case this
-            // binary expects to hit.
-            Replacement::Rewrite(_) => "Sketch".to_string(),
-        },
-        ReplacementProvenance::CseShare | ReplacementProvenance::CseRecompute => {
-            "SharedSubtree".to_string()
-        }
-        ReplacementProvenance::LogicalRewrite => {
-            if let QueryExpr::Aggregate { measures, .. } = target {
-                if let [AggIntent::Avg { .. }] = measures.as_slice() {
-                    return "AvgToSumRewrite".to_string();
-                }
-            }
-            "Rollup".to_string()
-        }
-    }
-}
-
 /// 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
@@ -271,8 +209,12 @@ fn lookup_winner(
 
 /// Build a [`TargetReplacement`] for `winner`, matching this file's own
 /// per-target `before`/`after` construction.
-fn target_replacement(target_pre_id: u32, winner: &Winner<'_>) -> TargetReplacement {
-    let strategy = classify_strategy(winner.target, winner.candidate);
+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) => {
@@ -283,6 +225,7 @@ fn target_replacement(target_pre_id: u32, winner: &Winner<'_>) -> TargetReplacem
         }
     };
     TargetReplacement {
+        decision_id,
         target_pre_id,
         strategy,
         rationale: winner.candidate.rationale.clone(),
@@ -391,9 +334,24 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
     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: winner.candidate.rationale.clone(),
+            rank: 0,
+            cost: winner.cost,
+            role: "replacement_region",
+        };
         Some(match &winners[i].candidate.replacement {
-            Replacement::Rewrite(rc) => PostAsapSubstitution::Rewrite(Rc::clone(rc)),
-            Replacement::Summary(rc) => PostAsapSubstitution::Summary(Rc::clone(rc)),
+            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
@@ -427,7 +385,10 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
                 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(node.id, &winners[i])));
+                replacements.push((
+                    name.clone(),
+                    target_replacement(i as u32, node.id, &winners[i]),
+                ));
                 matched[i] = true;
             }
         }
@@ -454,7 +415,7 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
     // `post_graph`'s own construction already handled correctly.
     for (winner, matched) in winners.iter().zip(&matched) {
         if !matched {
-            let strategy = classify_strategy(winner.target, winner.candidate);
+            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 \
@@ -660,7 +621,7 @@ mod tests {
         assert!(results
             .replacements
             .iter()
-            .any(|(_, r)| r.strategy == "AvgToSumRewrite"));
+            .any(|(_, r)| r.strategy == "AvgToSumOverCountStrategy"));
 
         assert_eq!(results.post_graphs.len(), 2, "one post_graph per query");
         for (name, graph) in &results.post_graphs {
@@ -669,6 +630,19 @@ mod tests {
                 "post_graph for {name:?} must not be empty"
             );
         }
+        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());
+        }
     }
 
     /// Regression test for a real stack overflow found via manual testing
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 9534eed6..6904d7f6 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -100,6 +100,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
@@ -120,6 +125,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 {
@@ -417,13 +436,18 @@ fn build_summary(node: &SummaryNode, nodes: &mut Vec<SummaryDagNode>) -> u32 {
 /// 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"` /
-    /// `"AvgToSumRewrite"` / `"Rollup"`. The higher layer derives this from
+    /// `"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.
@@ -498,11 +522,17 @@ pub enum PostAsapSubstitution {
     /// [`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(Rc<QueryExpr>),
+    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(Rc<SummaryNode>),
+    Summary {
+        replacement: Rc<SummaryNode>,
+        decision: DagDecision,
+    },
 }
 
 /// Build one merged "whole query, but post-ASAP" [`DagGraph`] by walking
@@ -579,6 +609,7 @@ fn push_node(
         hash,
         source_expr: Some(expr.clone()),
         notes: Vec::new(),
+        decision: None,
     });
     id
 }
@@ -610,6 +641,7 @@ fn push_summary_originated_node(
         hash: None,
         source_expr: None,
         notes: Vec::new(),
+        decision: None,
     });
     id
 }
@@ -677,11 +709,43 @@ fn build(
     find_winner: &mut dyn FnMut(&QueryExpr) -> Option<PostAsapSubstitution>,
 ) -> u32 {
     match find_winner(expr) {
-        Some(PostAsapSubstitution::Rewrite(replacement)) => {
-            return build_no_recheck(&replacement, nodes, cache, find_winner);
+        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(node)) => {
-            return build_summary_hybrid(&node, nodes, cache, find_winner);
+        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 => {}
     }
@@ -1110,20 +1174,23 @@ 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());
         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]
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index f4789b83..7e690ea7 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -20,7 +20,22 @@ 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.
 
-## Open the viewer
+## Run the interactive planner viewer
+
+```sh
+python3 tools/dag-viewer/server.py
+# open http://127.0.0.1:8000
+```
+
+The server builds `dag_export` once, serves the UI, and exposes a local
+`POST /api/plan`. Open **Query editor**, add SQL/PromQL entries, choose which
+ones belong to the workload, and click **Plan selected workload**. The backend
+passes the whole batch to the real `dag_export --post-asap` binary as an argv
+array (never a shell command), running pre-ASAP lowering, ASAP-aware workload
+mapping, and post-ASAP export before returning the `WorkloadGraph` to the UI.
+It listens on `127.0.0.1` by default.
+
+## Open a static export
 
 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
@@ -33,18 +48,16 @@ picker.
   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,
+- Each query's root node (its final output) gets a heavier border.
+- A node whose `notes` array is non-empty gets a double border; click it to
+  see each note's kind and reason in the side panel.
+- Node color 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.
 - If a query's export carries `replacements` (`dag_export --post-asap`),
-  switch to **Before/After** mode to see one claimed replacement's before
-  and after subtrees side by side — see "Before/After mode" below.
+  switch to **Before/After** mode for complete pre-/post-ASAP DAGs — see below.
 
 ## Render a standalone page from Python
 
@@ -76,14 +89,13 @@ 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.
+Pre-ASAP nodes have no per-node execution cost. Post-ASAP replacement nodes
+do carry the chosen candidate's estimated cost as part of `decision` and the
+side panel renders it alongside strategy/rationale.
 
 ## Visual style and node categories
 
-Node colors, icons, and shapes are adapted from
+Node colors 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
@@ -242,15 +254,13 @@ 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.
+In the viewer, a node with non-empty `notes` gets a double border; click the
+node to see each note's kind and full reason text in the side panel, the same
+"click for detail" pattern used for IR content and translation decisions.
 
 ## Before/After mode
 
-`dag_export --post-asap` additionally attaches a `replacements` array to each
+`dag_export --post-asap` attaches a `replacements` array to each
 query — one entry per place in the query where `asap-aware-mapping` actually
 *chose* a real optimization (cost-ranked, not just "could apply"): a sketch
 mapping, a CSE share/recompute, a workload-aware rollup, Hydra
@@ -262,24 +272,20 @@ carries its own small `before` subtree (the pre-ASAP nodes it replaced) and
 `provenance`, a human `rationale`, and this candidate's `rank`/`cost` among
 whatever else was considered for the same target (`rank: 0` is the winner).
 
-**Before/After** mode (only shown once a query with `replacements` is
-loaded) reuses the Single-mode tab bar to pick a query, then shows a
-secondary picker below the tabs listing every entry, grouped by which
-pre-ASAP node it targets (so a node with several ranked candidates — e.g.
-one query's Kll sketch vs. a Hydra-grouped alternative for the same
-aggregate — reads as one section instead of unrelated rows) and sorted by
-rank within a group so the winner is always first and marked. Pick a row and
-the main view draws that entry's `before` and `after` as two fixed lanes —
-**Before** / **After** — using the same compound-lane layout Compare mode
-uses for its per-query lanes, just with exactly two lanes fed from one
-entry's two subtrees instead of N lanes fed from N queries.
-
-The picker also always offers a **Whole query** option: `query.graph`
-(Before) against the query's whole-query merged post-ASAP graph,
-`query.post_graph` (After) — the `NamedGraph`-level counterpart to picking
-one target's tiny subtrees. It's disabled rather than hidden when a query's
-export has no `post_graph` (no `--post-asap`, or the query had zero
-replacements) — the option always exists, it just isn't always populated.
+**Before/After** uses checkbox tabs as a workload selector. Select one query
+to see its complete `graph` (pre-ASAP) and complete `post_graph` side by side.
+Select several queries to see every selected query's complete pre-ASAP DAG
+and post-ASAP DAG in one batch view. Per-target mini-subtrees are not the main
+view; their replacement records instead explain clicked nodes.
+
+Every `post_graph.nodes[]` entry produced or carried by a winning replacement
+contains a self-contained `decision` object with `id`, `strategy`,
+`rationale`, `rank`, `cost`, and `role` (`replacement_root` or
+`replacement_region`). This is a hard export contract: the viewer reads that
+field directly and never guesses provenance from a label, structural hash, or
+similarity to a replacement subtree. Clicking a post-ASAP node shows exactly
+why it was translated (or carried inside a translated region), while clicking
+the corresponding pre-ASAP target shows the selected replacement entry.
 
 A Summary graph's nodes (`SummaryDagNode`, from `after.kind === "Summary"` or
 from `post_graph`) are a different shape than the pre-ASAP `DagNode`s
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 72ee9ce9..9a23e793 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -110,6 +110,26 @@
   .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 140px 90px minmax(280px, 1fr) auto; gap: 0.45rem; align-items: center; }
+  .plannerRow input, .plannerRow select, .plannerRow textarea, #plannerEpsilon {
+    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; }
+  .plannerActions { display: flex; align-items: center; gap: 0.5rem; margin-top: 0.55rem; }
+  #plannerStatus { color: var(--muted); font-size: 0.75rem; }
   #baPicker {
     display: none;
     flex-wrap: wrap;
@@ -283,6 +303,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;
@@ -336,6 +376,7 @@ <h1>ASAP query DAG viewer</h1>
     <button class="btn" id="modeBeforeAfterBtn" data-mode="beforeafter">Before/After</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 />
@@ -343,6 +384,16 @@ <h1>ASAP query DAG viewer</h1>
   </label>
 </header>
 
+<div id="plannerPanel">
+  <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="baPicker"></div>
 
@@ -384,5 +435,6 @@ <h2>Legend</h2>
 </div>
 
 <script src="viewer.js"></script>
+<script src="planner-ui.js"></script>
 </body>
 </html>
diff --git a/tools/dag-viewer/planner-ui.js b/tools/dag-viewer/planner-ui.js
new file mode 100644
index 00000000..002edcb3
--- /dev/null
+++ b/tools/dag-viewer/planner-ui.js
@@ -0,0 +1,48 @@
+const plannerPanel = document.getElementById('plannerPanel');
+const plannerRows = document.getElementById('plannerRows');
+const plannerStatus = document.getElementById('plannerStatus');
+
+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>
+    <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('.plannerRemove').addEventListener('click', () => row.remove());
+  plannerRows.appendChild(row);
+}
+
+document.getElementById('plannerToggle').addEventListener('click', () => plannerPanel.classList.toggle('visible'));
+document.getElementById('plannerAdd').addEventListener('click', () => addPlannerRow({ text: '' }));
+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,
+    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, 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;
+  }
+});
+
+addPlannerRow({ name: 'count_by_service' });
+addPlannerRow({ name: 'avg_latency', text: 'SELECT service, AVG(latency) FROM metrics GROUP BY service' });
diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index d70245bf..21b647e5 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -40,7 +40,9 @@
 from __future__ import annotations
 
 import argparse
+import copy
 import json
+import re
 import sys
 from pathlib import Path
 
@@ -51,7 +53,197 @@
 # 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:
+    """Render one IR value compactly enough to fit inside a DAG node."""
+    if value is None:
+        return "none"
+    if isinstance(value, bool):
+        return str(value).lower()
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        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):
+        return value["Table"].get("table_ref", _compact(value["Table"]))
+    if set(value) == {"TimeSeries"} and isinstance(value["TimeSeries"], dict):
+        return value["TimeSeries"].get("metric", _compact(value["TimeSeries"]))
+    if len(value) == 1:
+        tag, payload = next(iter(value.items()))
+        if payload is None:
+            return tag
+        return f"{tag}({_compact(payload)})"
+    return ", ".join(f"{key}={_compact(item)}" for key, item in value.items())
+
+
+def _column(value: object) -> str:
+    if isinstance(value, int):
+        return f"col[{value}]"
+    return _compact(value)
+
+
+def _measure(value: object) -> 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"]))
+    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:
+    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"])
+    if isinstance(keys, list):
+        return "group by " + (", ".join(_column(key) for key in keys) or "all rows")
+    return "group by " + _compact(keys)
+
+
+def _sort_key(value: object) -> str:
+    if not isinstance(value, dict):
+        return _compact(value)
+    expr = _compact(value.get("expr"))
+    direction = "ascending" if value.get("ascending", True) else "descending"
+    nulls = "nulls first" if value.get("nulls_first", False) else "nulls last"
+    return f"{expr} {direction}, {nulls}"
+
+
+def _semantic_label(node: dict) -> 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":
+        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":
+        measures = detail.get("measures") or []
+        lines.extend(f"compute: {_measure(measure)}" for measure in measures)
+        grouping = _grouping(detail.get("reduction"))
+        if grouping:
+            lines.append(grouping)
+        if detail.get("having"):
+            lines.append(f"having: {_compact(detail['having'])}")
+    elif kind == "Sort":
+        lines.extend(f"sort: {_sort_key(key)}" for key in detail.get("keys") or [])
+        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)}")
+    elif kind == "Filter":
+        lines.append(f"where: {_compact(detail.get('pred'))}")
+    elif kind == "Join":
+        lines.append(f"type: {_compact(detail.get('kind'))}")
+        if detail.get("pred"):
+            lines.append(f"on: {_compact(detail['pred'])}")
+    elif kind == "Limit":
+        lines.append(f"rows: {_compact(detail.get('n'))}")
+        if detail.get("offset"):
+            lines.append(f"offset: {_compact(detail['offset'])}")
+    elif kind == "BinaryOp":
+        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"}:
+        lines.append(f"family: {_compact(detail.get('family'))}")
+        for key in ("col", "key", "reduction", "grouping"):
+            if key in detail:
+                lines.append(f"{key}: {_compact(detail[key])}")
+    elif kind == "SummaryEstimate":
+        lines.append(f"query: {_compact(detail.get('query'))}")
+    elif kind == "SummaryDelete":
+        lines.append(f"key: {_compact(detail.get('key'))}")
+    elif kind == "KeepPreAsap":
+        nested = detail.get("pre_asap_subgraph")
+        nested_nodes = nested.get("nodes", []) if isinstance(nested, dict) else []
+        nested_root = nested.get("root") if isinstance(nested, dict) else None
+        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)
+
+
+def prepare_workload(workload: dict) -> dict:
+    """Copy a workload and replace every graph label with readable IR text."""
+    prepared = copy.deepcopy(workload)
+
+    def prepare_graph(graph: object) -> None:
+        if not isinstance(graph, dict):
+            return
+        for node in graph.get("nodes", []):
+            node["label"] = _semantic_label(node)
+            nested = (node.get("detail") or {}).get("pre_asap_subgraph")
+            prepare_graph(nested)
+
+    def append_root_line(graph: object, line: str) -> None:
+        if not isinstance(graph, dict):
+            return
+        root_id = graph.get("root")
+        root = next((node for node in graph.get("nodes", []) if node.get("id") == root_id), None)
+        if root is not None:
+            root["label"] += f"\n{line}"
+
+    for query in prepared.get("queries", []):
+        prepare_graph(query.get("graph"))
+        prepare_graph(query.get("post_graph"))
+        for replacement in query.get("replacements", []):
+            before = replacement.get("before")
+            after = replacement.get("after") or {}
+            after_graph = after.get("graph")
+            prepare_graph(before)
+            prepare_graph(after_graph)
+            if replacement.get("strategy") == "SharedSubtree" or replacement.get("provenance") == "CseShare":
+                rationale = str(replacement.get("rationale", ""))
+                count = re.search(r"(\d+)\s+consumers?", rationale)
+                suffix = f" ({count.group(1)} consumers)" if count else ""
+                append_root_line(before, "reuse: recomputed per consumer")
+                append_root_line(after_graph, f"reuse: shared across workload{suffix}")
+    return prepared
 
 
 def load_workload(paths: list[Path]) -> dict:
@@ -81,6 +273,7 @@ def _json_script(obj: object) -> str:
 
 
 def render(workload: dict, mode: str) -> str:
+    workload = prepare_workload(workload)
     html = (HERE / "index.html").read_text()
 
     for name in _INLINE_LIBS:
@@ -116,9 +309,9 @@ def main() -> None:
     parser.add_argument("-o", "--output", type=Path, required=True, help="output HTML file path")
     parser.add_argument(
         "--mode",
-        choices=["single", "compare", "union"],
+        choices=["single", "compare", "union", "beforeafter"],
         default="single",
-        help="view mode the page opens into; compare/union pre-select every loaded query (default: single)",
+        help="initial view mode; Before/After starts with the first query selected (default: single)",
     )
     args = parser.parse_args()
 
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
new file mode 100644
index 00000000..e90f446c
--- /dev/null
+++ b/tools/dag-viewer/server.py
@@ -0,0 +1,107 @@
+#!/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
+from http import HTTPStatus
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+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")
+
+    args = [str(BINARY), "--post-asap", "--epsilon", str(epsilon)]
+    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")
+        args.extend([f"--{language}", text, "--name", str(name)])
+
+    result = subprocess.run(args, cwd=REPO, text=True, capture_output=True, timeout=120)
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "dag_export failed")
+    workload = json.loads(result.stdout)
+    workload["planner_stderr"] = result.stderr
+    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 _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 1b4778d9..50229b99 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -28,7 +28,7 @@
 import unittest
 from pathlib import Path
 
-from render import _json_script, load_workload, render
+from render import _json_script, _semantic_label, load_workload, prepare_workload, render
 
 HERE = Path(__file__).resolve().parent
 
@@ -111,7 +111,13 @@ def test_embedded_workload_round_trips(self):
             re.S,
         )
         self.assertIsNotNone(m, "embedded-workload <script> tag not found")
-        self.assertEqual(json.loads(m.group(1)), workload)
+        self.assertEqual(json.loads(m.group(1)), prepare_workload(workload))
+
+    def test_render_does_not_mutate_callers_workload(self):
+        workload = {"queries": [named_graph("q1")]}
+        original = json.loads(json.dumps(workload))
+        render(workload, mode="single")
+        self.assertEqual(workload, original)
 
     def test_single_mode_adds_no_render_config(self):
         # Bare "__DAG_RENDER__" also matches viewer.js's own header comment
@@ -166,6 +172,99 @@ def test_escapes_angle_bracket_but_stays_valid_json(self):
         self.assertEqual(json.loads(encoded), {"x": "</script>"})
 
 
+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]",
+        )
+
+    def test_sort_names_expression_direction_and_null_order(self):
+        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": [],
+        }
+        graph = {"nodes": [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"],
+            query["replacements"][0]["before"]["nodes"][0]["label"],
+            query["replacements"][0]["after"]["graph"]["nodes"][0]["label"],
+        ]
+        self.assertEqual(labels, ["Aggregate\ncompute: avg(col[3])"] * 4)
+
+    def test_cse_before_after_makes_reuse_decision_visible(self):
+        node = {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(metrics)",
+            "detail": {},
+            "children": [],
+        }
+        def graph():
+            return {"nodes": [dict(node)], "root": 0}
+
+        workload = {
+            "queries": [
+                {
+                    "graph": graph(),
+                    "replacements": [
+                        {
+                            "strategy": "SharedSubtree",
+                            "provenance": "CseShare",
+                            "rationale": "Scan(metrics) has 2 consumers across this workload",
+                            "before": graph(),
+                            "after": {"graph": graph()},
+                        }
+                    ],
+                }
+            ]
+        }
+        replacement = prepare_workload(workload)["queries"][0]["replacements"][0]
+        self.assertEqual(
+            replacement["before"]["nodes"][0]["label"],
+            "Scan\nsource: metrics\nreuse: recomputed per consumer",
+        )
+        self.assertEqual(
+            replacement["after"]["graph"]["nodes"][0]["label"],
+            "Scan\nsource: metrics\nreuse: shared across workload (2 consumers)",
+        )
+
+
 class MainCliTests(unittest.TestCase):
     """Exercises main()'s own error handling via subprocess, rather than
     calling main() in-process, since what's under test here is exactly the
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index de31d310..beb07a51 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -32,22 +32,13 @@ let zoom = 1;
 // '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. 'beforeafter'
-// picks one query (via the same tab bar as 'single') and one entry from its
-// `replacements[]` (via the secondary picker in #baPicker), then draws that
-// entry's `before` and `after.graph` as two fixed Compare-mode-style lanes.
+// draws the complete pre-ASAP and post-ASAP DAG for every checked query.
+// One checked query is the single-query view; 2+ checked queries are a
+// workload/batch view. Replacement entries are explanations attached to
+// clicked nodes, not separate tiny-subtree views.
 let mode = 'single';
 // Indices into `queries` currently selected to participate in compare/union.
 let participants = new Set();
-// Before/After mode only: index into `queries[activeIndex].replacements`
-// currently shown in the two lanes. -1 means "nothing picked yet" (defaults
-// to the first entry on render). Reset whenever the active query changes,
-// since an index is only meaningful within that query's own array.
-let baSelectedIndex = -1;
-// Before/After mode only: true when the picker's "Whole query" option is
-// selected instead of a per-target replacement entry — draws the query's
-// whole `graph` (Before) against its whole `post_graph` (After) rather than
-// one entry's tiny before/after subgraphs. Reset alongside baSelectedIndex.
-let baWholeQuery = false;
 
 const dropzone = document.getElementById('dropzone');
 const fileInput = document.getElementById('fileInput');
@@ -80,8 +71,6 @@ clearBtn.addEventListener('click', () => {
   activeIndex = -1;
   mode = 'single';
   participants = new Set();
-  baSelectedIndex = -1;
-  baWholeQuery = false;
   setModeButtons();
   render();
 });
@@ -99,13 +88,11 @@ document.querySelectorAll('#modeToggle .btn').forEach((btn) => {
     if ((mode === 'compare' || mode === 'union') && participants.size === 0) {
       queries.forEach((_, i) => participants.add(i));
     }
-    // First switch into Before/After: reuse the single-view tab selection
-    // (defaulting to the first query) and let renderBeforeAfter default
-    // baSelectedIndex to that query's first replacement.
+    // First switch into Before/After: start with the currently active query.
+    // The checkbox tabs can then expand that into a batch workload.
     if (mode === 'beforeafter') {
       if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
-      baSelectedIndex = -1;
-      baWholeQuery = false;
+      if (participants.size === 0 && activeIndex >= 0) participants.add(activeIndex);
     }
     render();
   });
@@ -216,24 +203,20 @@ function render() {
 
 function renderTabs() {
   tabsEl.innerHTML = '';
-  if (mode === 'single' || mode === 'beforeafter') {
+  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;
-        if (mode === 'beforeafter') {
-          baSelectedIndex = -1;
-          baWholeQuery = false;
-        }
         render();
       });
       tabsEl.appendChild(tab);
     });
     return;
   }
-  // Compare/Union: checkboxes choose which loaded queries participate.
+  // Compare/Union/Before-After: checkboxes choose the workload.
   queries.forEach((q, i) => {
     const chip = document.createElement('label');
     chip.className = 'tab checkTab' + (participants.has(i) ? ' active' : '');
@@ -279,18 +262,11 @@ function buildCyStyle() {
         'text-wrap': 'wrap',
         'text-valign': 'center',
         'text-halign': 'center',
-        'text-margin-y': 9,
         'font-size': 10,
         'width': 'label',
         'height': 'label',
-        'padding': '16px',
+        'padding': '12px',
         'border-width': 1.5,
-        'background-fit': 'contain',
-        'background-position-x': '50%',
-        'background-position-y': '17%',
-        'background-width': '30%',
-        'background-height': '30%',
-        'background-clip': 'none',
         // Lets class/style changes below (the '.shared' ring, '.unionShared'
         // double border, ':selected' outline, and buildCy's fade-in) animate
         // instead of snapping — cytoscape treats these like CSS transitions,
@@ -305,7 +281,10 @@ function buildCyStyle() {
       selector: 'node[category = "data"]',
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
-    ...categoryStyles,
+    ...categoryStyles.map((entry) => ({
+      ...entry,
+      style: { ...entry.style, 'background-image': 'none' },
+    })),
     {
       // KeepPreAsap (Before/After mode's After lane only) is post-ASAP-only
       // as a *kind*, but represents literally unchanged pre-ASAP content —
@@ -320,9 +299,17 @@ function buildCyStyle() {
         'background-color': panelColor,
         'border-color': borderColor,
         'border-style': 'dashed',
-        'background-image': keepPreAsapIconDataUri(),
+        'background-image': 'none',
       },
     },
+    {
+      selector: 'node.root',
+      style: { 'border-width': 2.5 },
+    },
+    {
+      selector: 'node.hasNotes',
+      style: { 'border-style': 'double', 'border-width': 3 },
+    },
     {
       selector: 'node.shared',
       style: {
@@ -435,41 +422,16 @@ function buildCy(elements, layout) {
 // Root badges + notes badges + click/tap wiring — identical across
 // single/compare/union.
 function finalizeGraphInteractions() {
-  // Root nodes get a second, smaller badge icon layered in the corner —
-  // QueryExpr has no dedicated terminal "output" kind the way the reference
-  // repo's BGP `out_*` steps do, so the root is marked structurally instead.
-  cy.nodes('[?root]').forEach((n) => {
-    n.addClass('root').style({
-      'background-image': [categoryIconDataUri(n.data('category')), rootBadgeIconDataUri()],
-      'background-position-x': ['46%', '86%'],
-      'background-position-y': ['17%', '15%'],
-      'background-width': ['26%', '22%'],
-      'background-height': ['26%', '22%'],
-      'background-clip': ['none', 'none'],
-    });
-  });
+  // Use borders rather than pictograms so IR text owns the whole node box.
+  cy.nodes('[?root]').addClass('root');
 
-  // Nodes carrying a non-empty `notes` array (issue #257: asap-aware-mapping
-  // explained a replacement at this node, matched by structural hash — see
-  // README.md) get a third badge in the opposite corner from the root badge,
-  // so a node can be both at once without the two colliding.
+  // 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;
-    const isRoot = n.hasClass('root');
-    n.addClass('hasNotes').style({
-      'background-image': [
-        categoryIconDataUri(n.data('category')),
-        ...(isRoot ? [rootBadgeIconDataUri()] : []),
-        noteBadgeIconDataUri(node.notes),
-      ],
-      'background-position-x': ['46%', ...(isRoot ? ['86%'] : []), '86%'],
-      'background-position-y': ['17%', ...(isRoot ? ['15%'] : []), '83%'],
-      'background-width': ['26%', ...(isRoot ? ['22%'] : []), '22%'],
-      'background-height': ['26%', ...(isRoot ? ['22%'] : []), '22%'],
-      'background-clip': isRoot ? ['none', 'none', 'none'] : ['none', 'none'],
-    });
+    n.addClass('hasNotes');
   });
 
   cy.on('tap', 'node', (evt) => {
@@ -521,7 +483,7 @@ function renderGraph(query) {
     elements.push({
       data: {
         id: String(node.id),
-        label: `${node.kind}\n${node.label}`,
+        label: node.label,
         node,
         category: categoryOf(node.kind),
         root: node.id === query.graph.root,
@@ -584,7 +546,7 @@ function renderCompare(chosen) {
         data: {
           id: `q${qIdx}-${node.id}`,
           parent: laneId,
-          label: `${node.kind}\n${node.label}`,
+          label: node.label,
           node,
           category: categoryOf(node.kind),
           root: node.id === q.graph.root,
@@ -718,7 +680,7 @@ function renderUnion(chosen) {
     elements.push({
       data: {
         id: key,
-        label: `${entry.node.kind}\n${entry.node.label}`,
+        label: entry.node.label,
         node: entry.node,
         category: entry.category,
         isUnion: true,
@@ -738,63 +700,41 @@ function renderUnion(chosen) {
   fitAndSyncZoom();
 }
 
-// ── Before/After mode: one replacement site's before/after subtree ───────
-// Reuses the Single-mode tab bar to pick a query, then a secondary picker
-// (#baPicker, built by renderBaPicker) to pick one entry from that query's
-// `replacements[]`. The chosen entry's `before` and `after.graph` are drawn
-// as exactly two Compare-mode-style lanes ("Before" / "After") via the same
-// compound-lane pattern renderCompare uses for N query lanes — here it's
-// always exactly 2, and both lanes come from one entry instead of from two
-// different queries.
+// ── Before/After mode: complete query/workload pre/post DAGs ─────────────
+// Checkbox tabs select one query or a batch. Every selected query contributes
+// a complete pre-ASAP lane and complete post-ASAP lane. Replacement records
+// power node-click explanations instead of being rendered as tiny subtrees.
 function renderBeforeAfter() {
-  const query = activeIndex >= 0 ? queries[activeIndex] : undefined;
-  const replacements = (query && query.replacements) || [];
-  const hasPostGraph = !!(query && query.post_graph);
-  renderBaPicker(query, replacements, hasPostGraph);
+  const chosen = getParticipants();
+  const selected = chosen.map((i) => queries[i]);
+  renderBaScopeSummary(selected);
+  renderSourcePanel(selected);
 
-  if (!query) {
+  if (selected.length === 0) {
     viewTitleEl.textContent = 'Before/After';
-    renderSourcePanel([]);
-    showModeHint('Select a query above to inspect its replacements.');
+    showModeHint('Select one query for a complete pre/post DAG, or several queries for a batch workload view.');
     return;
   }
-  renderSourcePanel([query]);
-  if (replacements.length === 0 && !hasPostGraph) {
-    viewTitleEl.textContent = `Before/After: ${query.name}`;
-    showModeHint(`${query.name} has no recorded replacements in this export.`);
+  const missing = selected.filter((q) => !q.post_graph);
+  if (missing.length > 0) {
+    viewTitleEl.textContent = selected.length === 1 ? `Before/After: ${selected[0].name}` : `Batch Before/After: ${selected.length} queries`;
+    showModeHint(`No post-ASAP graph for: ${missing.map((q) => q.name).join(', ')}. Re-export with dag_export --post-asap.`);
     return;
   }
-  // A query with no per-target replacements but a post_graph (or the user's
-  // explicit pick) falls back to the whole-query view rather than a hint —
-  // it's the one option that's actually available.
-  if (!baWholeQuery && replacements.length === 0) baWholeQuery = true;
   hideModeHint();
+  viewTitleEl.textContent = selected.length === 1
+    ? `Before/After: ${selected[0].name} — complete IR DAG`
+    : `Batch Before/After: ${selected.length} queries`;
 
-  let beforeNodes, beforeRoot, afterNodes, afterRoot, titleSuffix, afterLabel;
-  if (baWholeQuery) {
-    beforeNodes = query.graph.nodes;
-    beforeRoot = query.graph.root;
-    afterNodes = query.post_graph.nodes;
-    afterRoot = query.post_graph.root;
-    titleSuffix = 'whole query';
-    afterLabel = 'After (post-ASAP graph)';
-  } else {
-    if (baSelectedIndex === -1 || baSelectedIndex >= replacements.length) baSelectedIndex = 0;
-    const entry = replacements[baSelectedIndex];
-    beforeNodes = entry.before.nodes;
-    beforeRoot = entry.before.root;
-    afterNodes = entry.after.graph.nodes;
-    afterRoot = entry.after.graph.root;
-    titleSuffix = `${entry.strategy} (rank ${entry.rank})`;
-    afterLabel = entry.after.kind === 'Summary' ? 'After (Summary)' : 'After (Rewrite)';
-  }
-
-  viewTitleEl.textContent = `Before/After: ${query.name} — ${titleSuffix}`;
-
-  const elements = [
-    ...laneElements('ba-before', 'Before', beforeNodes, beforeRoot),
-    ...laneElements('ba-after', afterLabel, afterNodes, afterRoot),
-  ];
+  const elements = [];
+  chosen.forEach((qIdx) => {
+    const query = queries[qIdx];
+    elements.push(...laneElements(`ba-pre-${qIdx}`, `${query.name} · pre-ASAP`, query.graph, query, 'pre'));
+  });
+  chosen.forEach((qIdx) => {
+    const query = queries[qIdx];
+    elements.push(...laneElements(`ba-post-${qIdx}`, `${query.name} · post-ASAP`, query.post_graph, query, 'post'));
+  });
 
   buildCy(elements);
   finalizeGraphInteractions();
@@ -810,7 +750,8 @@ function renderBeforeAfter() {
 // 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 showBeforeAfterDetail below.
-function laneElements(laneId, laneLabel, nodes, rootId) {
+function laneElements(laneId, laneLabel, graph, query, stage) {
+  const nodes = graph.nodes;
   const elements = [
     { data: { id: laneId, label: laneLabel, isLane: true }, classes: 'laneParent', selectable: false, grabbable: false },
   ];
@@ -819,7 +760,7 @@ function laneElements(laneId, laneLabel, nodes, rootId) {
       data: {
         id: `${laneId}-${node.id}`,
         parent: laneId,
-        label: `${node.kind}\n${node.label}`,
+        label: node.label,
         node,
         // Flat (not nested under `node`) so buildCyStyle's
         // `node[kind = "KeepPreAsap"]` selector can actually match it —
@@ -827,9 +768,12 @@ function laneElements(laneId, laneLabel, nodes, rootId) {
         // object.
         kind: node.kind,
         category: categoryOf(node.kind),
-        root: node.id === rootId,
+        root: node.id === graph.root,
         isBeforeAfter: true,
         laneId,
+        stage,
+        queryName: query.name,
+        translations: translationsForNode(query, node, stage),
       },
     });
   }
@@ -849,109 +793,63 @@ function laneElements(laneId, laneLabel, nodes, rootId) {
   return elements;
 }
 
-// Secondary picker shown below #tabs while Before/After mode is active:
-// a "Whole query" option (query.graph vs query.post_graph in full, disabled
-// rather than omitted when this query's export has no post_graph — the
-// option always exists, it just isn't always populated) followed by one row
-// per `replacements[]` entry, grouped by `target_pre_id` (so a node with
-// multiple ranked candidates — e.g. p95_pktlen's Sketch vs HydraGrouping
-// fixture — reads as one section instead of two unrelated rows) and sorted
-// by rank within a group so the winner (rank 0) is always listed first and
-// visually marked.
-function renderBaPicker(query, replacements, hasPostGraph) {
-  baPickerEl.innerHTML = '';
-  if (!query || (replacements.length === 0 && !hasPostGraph)) {
-    baPickerEl.classList.remove('visible');
-    return;
-  }
+function renderBaScopeSummary(selected) {
   baPickerEl.classList.add('visible');
+  const strategies = new Set();
+  selected.forEach((q) => (q.replacements || []).filter((r) => r.rank === 0).forEach((r) => strategies.add(r.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';
+  baPickerEl.innerHTML = `<div class="baGroup"><div class="baGroupLabel">View scope</div><div class="baRow active"><span>${escapeHtml(scope)}</span><span class="baMeta">${escapeHtml(strategyText)}</span></div></div>`;
+}
 
-  const wholeGroup = document.createElement('div');
-  wholeGroup.className = 'baGroup';
-  const wholeLabel = document.createElement('div');
-  wholeLabel.className = 'baGroupLabel';
-  wholeLabel.textContent = 'Whole query';
-  wholeGroup.appendChild(wholeLabel);
-  const wholeRow = document.createElement('button');
-  wholeRow.type = 'button';
-  wholeRow.className = 'baRow' + (baWholeQuery ? ' active' : '');
-  wholeRow.disabled = !hasPostGraph;
-  wholeRow.innerHTML = hasPostGraph
-    ? `<span>Whole query — ${query.graph.nodes.length} nodes vs. post-ASAP graph</span>`
-    : `<span>Whole query</span><span class="baMeta">no post-ASAP graph in this export</span>`;
-  if (hasPostGraph) {
-    wholeRow.addEventListener('click', () => {
-      baWholeQuery = true;
-      render();
-    });
-  }
-  wholeGroup.appendChild(wholeRow);
-  baPickerEl.appendChild(wholeGroup);
-
-  if (replacements.length === 0) return;
-
-  const groups = new Map(); // target_pre_id -> [index into replacements]
-  replacements.forEach((r, idx) => {
-    if (!groups.has(r.target_pre_id)) groups.set(r.target_pre_id, []);
-    groups.get(r.target_pre_id).push(idx);
-  });
-  const byId = new Map(query.graph.nodes.map((n) => [n.id, n]));
-
-  for (const [targetId, idxs] of groups) {
-    idxs.sort((a, b) => replacements[a].rank - replacements[b].rank);
-    const targetNode = byId.get(targetId);
-    const nodeDesc = targetNode ? `${targetNode.kind} — ${targetNode.label}` : `node #${targetId}`;
-
-    const group = document.createElement('div');
-    group.className = 'baGroup';
-    const groupLabel = document.createElement('div');
-    groupLabel.className = 'baGroupLabel';
-    groupLabel.textContent = idxs.length > 1 ? `${nodeDesc} — ${idxs.length} candidates` : nodeDesc;
-    group.appendChild(groupLabel);
-
-    idxs.forEach((idx) => {
-      const r = replacements[idx];
-      const row = document.createElement('button');
-      row.type = 'button';
-      row.className = 'baRow' + (!baWholeQuery && idx === baSelectedIndex ? ' active' : '');
-      const rationale = r.rationale || '';
-      const rationalePrefix = rationale.length > 90 ? `${rationale.slice(0, 90)}…` : rationale;
-      row.innerHTML = `${r.rank === 0 ? '<span class="baWinner">winner</span>' : ''}<span>${escapeHtml(r.strategy)} — ${escapeHtml(rationalePrefix)}</span><span class="baMeta">rank ${r.rank}, cost ${r.cost}</span>`;
-      row.addEventListener('click', () => {
-        baWholeQuery = false;
-        baSelectedIndex = idx;
-        render();
-      });
-      group.appendChild(row);
-    });
-    baPickerEl.appendChild(group);
-  }
+function translationsForNode(query, node, stage) {
+  const replacements = (query.replacements || []).filter((r) => r.rank === 0);
+  if (stage === 'pre') return replacements.filter((r) => r.target_pre_id === node.id);
+  if (!node.decision) return [];
+  const replacement = replacements.find((r) => r.decision_id === node.decision.id);
+  return [{
+    ...node.decision,
+    target_pre_id: replacement ? replacement.target_pre_id : undefined,
+    after: replacement ? replacement.after : undefined,
+  }];
 }
 
-// Before/After mode's variant of showDetail/showUnionDetail: `data` is one
-// lane node's cytoscape data (see laneElements above). Deliberately skips
-// the cross-query "shared with" note those two render (meaningless for two
-// lanes drawn from one entry's own before/after subtrees) — notesHtml and
-// JSON.stringify(node.detail) below already degrade cleanly when `notes`/
-// other pre-ASAP-only fields are simply absent, which is the SummaryDagNode
-// case (no `hash`, no `notes`).
 function showBeforeAfterDetail(data) {
   const node = data.node;
   const category = categoryOf(node.kind);
   const catColors = categoryColors(category);
   const catLabel = (CATEGORIES[category] || {}).label || category;
-  const laneName = data.laneId === 'ba-before' ? 'Before' : 'After';
+  const stageName = data.stage === 'pre' ? 'pre-ASAP' : 'post-ASAP';
 
   const rootHtml = data.root
-    ? `<div class="rootNote">This is the root of the ${laneName} subtree.</div>`
+    ? `<div class="rootNote">This is the root of ${escapeHtml(data.queryName)}'s complete ${stageName} DAG.</div>`
     : '';
 
+  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.after || {}).kind || node.kind)}</div>
+      </div>`).join('');
+    const heading = data.stage === 'post' ? 'Why this post-ASAP translation' : 'Selected post-ASAP strategy for this node';
+    translationHtml = `<div class="translationBlock"><h3>${heading}</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>`;
+  }
+
   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}
+    ${translationHtml}
     ${notesHtml(node)}
+    <h3 class="detailSubhead">IR node content</h3>
     <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
   `;
 }
@@ -984,11 +882,30 @@ function renderSourcePanel(qs) {
 function applyHighlighting() {
   if (!cy) return;
   if (mode === 'beforeafter') {
-    // Shared-subtree highlighting is a cross-query proxy (computeHashOwners
-    // matches a hash across distinct query names) — meaningless for two
-    // lanes drawn from one query's own before/after subtrees, so Before/
-    // After mode never marks '.shared'.
-    cy.nodes().forEach((n) => n.removeClass('shared'));
+    const selected = getParticipants().map((i) => queries[i]);
+    const ownersFor = (graphOf) => {
+      const owners = new Map();
+      selected.forEach((q) => {
+        const seen = new Set();
+        const graph = graphOf(q);
+        (graph ? graph.nodes : []).forEach((node) => {
+          if (node.hash === undefined || seen.has(node.hash)) return;
+          seen.add(node.hash);
+          if (!owners.has(node.hash)) owners.set(node.hash, new Set());
+          owners.get(node.hash).add(q.name);
+        });
+      });
+      return owners;
+    };
+    const preOwners = ownersFor((q) => q.graph);
+    const postOwners = ownersFor((q) => q.post_graph);
+    cy.nodes().forEach((n) => {
+      if (n.data('isLane')) return;
+      const node = n.data('node');
+      const owners = n.data('stage') === 'post' ? postOwners : preOwners;
+      const sharedWith = node && owners.get(node.hash);
+      n.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
+    });
     return;
   }
   const owners = mode === 'single' ? computeHashOwners() : computeHashOwners(getParticipants().map((i) => queries[i]));
@@ -1143,6 +1060,20 @@ function loadWorkload(parsed) {
   if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
 }
 
+// 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));
+  mode = 'beforeafter';
+  setModeButtons();
+  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
@@ -1161,7 +1092,11 @@ if (embeddedEl) {
   const requestedMode = window.__DAG_RENDER__ && window.__DAG_RENDER__.mode;
   if (requestedMode && requestedMode !== 'single') {
     mode = requestedMode;
-    queries.forEach((_, i) => participants.add(i));
+    if (mode === 'beforeafter') {
+      if (queries.length > 0) participants.add(0);
+    } else {
+      queries.forEach((_, i) => participants.add(i));
+    }
     setModeButtons();
   }
   render();

From 358a7d7967ccccd2cdb33d391d19cc51deec7ba9 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:39:31 -0600
Subject: [PATCH 07/27] fix: generate default DAG example with post-ASAP graphs

---
 tools/dag-viewer/dag.example.json | 1199 ++++++++++++++++++++++++++++-
 tools/dag-viewer/viewer.js        |    5 +-
 2 files changed, 1202 insertions(+), 2 deletions(-)

diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index 4de7e77d..1fe5911c 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -87,7 +87,7 @@
             "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"
               }
             ]
           },
@@ -119,6 +119,339 @@
           }
         ],
         "root": 2
+      },
+      "replacements": [
+        {
+          "decision_id": 0,
+          "target_pre_id": 1,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+          "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"
+                    }
+                  }
+                },
+                "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
+                    ]
+                  }
+                },
+                "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)"
+                        }
+                      ],
+                      "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,
+            "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"
+                }
+              }
+            },
+            "children": [],
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "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
+            ],
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "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 }"
+            },
+            "children": [
+              1
+            ],
+            "decision": {
+              "id": 0,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 3,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 1
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "children": [
+              2
+            ],
+            "hash": 17063396757587155626
+          }
+        ],
+        "root": 3
       }
     },
     {
@@ -232,6 +565,575 @@
           }
         ],
         "root": 2
+      },
+      "replacements": [
+        {
+          "decision_id": 1,
+          "target_pre_id": 1,
+          "strategy": "AvgToSumOverCountStrategy",
+          "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+          "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"
+                    }
+                  }
+                },
+                "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
+                    ]
+                  }
+                },
+                "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"
+                      }
+                    }
+                  },
+                  "children": [],
+                  "hash": 2606922452740434172
+                },
+                {
+                  "id": 1,
+                  "kind": "Aggregate",
+                  "label": "Aggregate(1 measures)",
+                  "detail": {
+                    "having": null,
+                    "measures": [
+                      {
+                        "col": 3,
+                        "kind": "sum"
+                      }
+                    ],
+                    "output_names": [],
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "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
+                  },
+                  "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"
+                      }
+                    }
+                  },
+                  "children": [],
+                  "hash": 2606922452740434172
+                },
+                {
+                  "id": 4,
+                  "kind": "Aggregate",
+                  "label": "Aggregate(1 measures)",
+                  "detail": {
+                    "having": null,
+                    "measures": [
+                      {
+                        "accuracy": "Exact",
+                        "kind": "count"
+                      }
+                    ],
+                    "output_names": [],
+                    "reduction": {
+                      "Reduce": [
+                        1
+                      ]
+                    }
+                  },
+                  "children": [
+                    3
+                  ],
+                  "hash": 6760740959892251122
+                },
+                {
+                  "id": 5,
+                  "kind": "BinaryOp",
+                  "label": "BinaryOp(/)",
+                  "detail": {
+                    "op": "/",
+                    "vector_match": null
+                  },
+                  "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"
+                }
+              }
+            },
+            "children": [],
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "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
+                ]
+              }
+            },
+            "children": [
+              0
+            ],
+            "decision": {
+              "id": 3,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "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
+            },
+            "children": [
+              1
+            ],
+            "hash": 11401885529025699918,
+            "decision": {
+              "id": 1,
+              "strategy": "AvgToSumOverCountStrategy",
+              "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+              "rank": 0,
+              "cost": 2.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "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"
+                }
+              }
+            },
+            "children": [],
+            "hash": 2606922452740434172,
+            "decision": {
+              "id": 4,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as an exact Count accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 4,
+            "kind": "SummaryAgg",
+            "label": "SummaryAgg(ExactAggregate(Count))",
+            "detail": {
+              "col": "SampleValue",
+              "family": "ExactAggregate(Count, Count)",
+              "grouping": "PerSubpopulationInstance",
+              "reduction": {
+                "Reduce": [
+                  1
+                ]
+              }
+            },
+            "children": [
+              3
+            ],
+            "decision": {
+              "id": 4,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "count realizes as an exact Count accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rank": 0,
+              "cost": 3.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 5,
+            "kind": "BinaryOp",
+            "label": "BinaryOp(/)",
+            "detail": {
+              "op": "/",
+              "vector_match": null
+            },
+            "children": [
+              2,
+              4
+            ],
+            "hash": 16391872732257280252,
+            "decision": {
+              "id": 1,
+              "strategy": "AvgToSumOverCountStrategy",
+              "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+              "rank": 0,
+              "cost": 2.0,
+              "role": "replacement_root"
+            }
+          },
+          {
+            "id": 6,
+            "kind": "Project",
+            "label": "Project(2 cols)",
+            "detail": {
+              "cols": [
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 0
+                  }
+                },
+                {
+                  "alias": null,
+                  "expr": {
+                    "Column": 1
+                  }
+                }
+              ],
+              "qualifier": null
+            },
+            "children": [
+              5
+            ],
+            "hash": 5277207484379927121
+          }
+        ],
+        "root": 6
       }
     },
     {
@@ -345,6 +1247,301 @@
           }
         ],
         "root": 4
+      },
+      "replacements": [
+        {
+          "decision_id": 2,
+          "target_pre_id": 2,
+          "strategy": "SketchAlgorithmStrategy",
+          "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+          "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"
+                    }
+                  }
+                },
+                "children": [],
+                "hash": 16569634401303792668
+              },
+              {
+                "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"
+                    }
+                  ],
+                  "output_names": [
+                    ""
+                  ],
+                  "reduction": "PerEntity"
+                },
+                "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)"
+                        },
+                        {
+                          "children": [
+                            0
+                          ],
+                          "detail": {
+                            "range": {
+                              "nanos": 0,
+                              "secs": 300
+                            }
+                          },
+                          "hash": 12007712336004404578,
+                          "id": 1,
+                          "kind": "TimeRange",
+                          "label": "TimeRange(300s)"
+                        }
+                      ],
+                      "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"
+                }
+              }
+            },
+            "children": [],
+            "hash": 16569634401303792668,
+            "decision": {
+              "id": 2,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rank": 0,
+              "cost": 4.0,
+              "role": "replacement_region"
+            }
+          },
+          {
+            "id": 1,
+            "kind": "TimeRange",
+            "label": "TimeRange(300s)",
+            "detail": {
+              "range": {
+                "nanos": 0,
+                "secs": 300
+              }
+            },
+            "children": [
+              0
+            ],
+            "hash": 12007712336004404578,
+            "decision": {
+              "id": 2,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "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"
+            },
+            "children": [
+              1
+            ],
+            "decision": {
+              "id": 2,
+              "strategy": "SketchAlgorithmStrategy",
+              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "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": []
+            },
+            "children": [
+              2
+            ],
+            "hash": 3760917937445997010
+          },
+          {
+            "id": 4,
+            "kind": "Limit",
+            "label": "Limit(5)",
+            "detail": {
+              "n": 5,
+              "offset": 0
+            },
+            "children": [
+              3
+            ],
+            "hash": 7672123412300577486
+          }
+        ],
+        "root": 4
       }
     }
   ]
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index beb07a51..844ca9f6 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -718,7 +718,10 @@ function renderBeforeAfter() {
   const missing = selected.filter((q) => !q.post_graph);
   if (missing.length > 0) {
     viewTitleEl.textContent = selected.length === 1 ? `Before/After: ${selected[0].name}` : `Batch Before/After: ${selected.length} queries`;
-    showModeHint(`No post-ASAP graph for: ${missing.map((q) => q.name).join(', ')}. Re-export with dag_export --post-asap.`);
+    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();

From e1431e8cf54032a7e22ab062e16352a14833da27 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:42:21 -0600
Subject: [PATCH 08/27] feat: stream planner pipeline progress from server

---
 crates/devtools/src/bin/dag_export.rs | 34 +++++++++++++++++---
 tools/dag-viewer/server.py            | 46 +++++++++++++++++++++++----
 2 files changed, 69 insertions(+), 11 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index cd885de4..3eb889b4 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -100,11 +100,12 @@ fn catalog() -> SqlCatalog {
 /// "<label>"` pairs off argv, in the order given, plus one optional global
 /// `--epsilon <f64>` and one optional global `--post-asap` flag. `--name` is
 /// optional and applies to the immediately preceding `--sql`/`--promql`.
-fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool) {
+fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool, bool) {
     let mut entries: Vec<(String, Lang, String)> = Vec::new();
     let mut pending: Option<(Lang, String)> = None;
     let mut accuracy = AccuracyTarget::Exact;
     let mut post_asap = false;
+    let mut progress = false;
     let mut args = std::env::args().skip(1);
 
     fn flush(entries: &mut Vec<(String, Lang, String)>, pending: &mut Option<(Lang, String)>) {
@@ -142,11 +143,14 @@ fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool) {
             "--post-asap" => {
                 post_asap = true;
             }
+            "--progress" => {
+                progress = true;
+            }
             other => panic!("unrecognized argument: {other}"),
         }
     }
     flush(&mut entries, &mut pending);
-    (entries, accuracy, post_asap)
+    (entries, accuracy, post_asap, progress)
 }
 
 /// Attach workload-wide replacement explanations to their exact graph nodes.
@@ -259,7 +263,13 @@ struct PostAsapResults {
 /// 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(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapResults {
+fn run_post_asap_with_progress(
+    lowered_queries: &[(String, String, QueryExpr)],
+    progress: bool,
+) -> PostAsapResults {
+    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())))
@@ -331,6 +341,9 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
     // 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 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)?;
@@ -431,9 +444,14 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
     }
 }
 
+#[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, post_asap) = parse_args();
+    let (entries, accuracy, post_asap, progress) = parse_args();
     if entries.is_empty() {
         eprintln!(
             "usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] [--post-asap] ..."
@@ -442,6 +460,9 @@ async fn main() {
     }
 
     let mut lowered_queries = Vec::new();
+    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())
@@ -457,6 +478,9 @@ async fn main() {
         }
     }
 
+    if progress {
+        eprintln!("[2/4] Pre-ASAP DAG generation is running…");
+    }
     let explanations = asap_aware_mapping::explain_replacements(
         lowered_queries
             .iter()
@@ -486,7 +510,7 @@ async fn main() {
     }
 
     if post_asap {
-        let results = run_post_asap(&lowered_queries);
+        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);
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index e90f446c..5e8d1bde 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -6,6 +6,8 @@
 import argparse
 import json
 import subprocess
+import tempfile
+import threading
 from http import HTTPStatus
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
@@ -31,7 +33,7 @@ def plan_workload(payload: dict) -> dict:
     if not 0 < epsilon < 1:
         raise ValueError("epsilon must be between 0 and 1")
 
-    args = [str(BINARY), "--post-asap", "--epsilon", str(epsilon)]
+    args = [str(BINARY), "--post-asap", "--progress", "--epsilon", str(epsilon)]
     for index, query in enumerate(queries, 1):
         if not isinstance(query, dict):
             raise ValueError(f"query #{index} must be an object")
@@ -44,11 +46,43 @@ def plan_workload(payload: dict) -> dict:
             raise ValueError(f"query #{index}: text must contain 1–100000 characters")
         args.extend([f"--{language}", text, "--name", str(name)])
 
-    result = subprocess.run(args, cwd=REPO, text=True, capture_output=True, timeout=120)
-    if result.returncode != 0:
-        raise RuntimeError(result.stderr.strip() or "dag_export failed")
-    workload = json.loads(result.stdout)
-    workload["planner_stderr"] = result.stderr
+    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 = json.loads(stdout)
+    workload["planner_stderr"] = stderr
+    print(f"[planner] Complete: generated {len(workload.get('queries', []))} pre/post DAG pairs", flush=True)
     return workload
 
 

From 0327ad89abb28c5b512f5018b3e00c07e35d2073 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:43:05 -0600
Subject: [PATCH 09/27] fix: prevent stale DAG viewer assets

---
 tools/dag-viewer/server.py |  6 ++++++
 tools/dag-viewer/viewer.js | 15 +++++----------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index 5e8d1bde..b231cede 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -108,6 +108,12 @@ def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
         except Exception as error:  # surface planner failures to this local UI
             self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
 
+    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)
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 844ca9f6..b82801a3 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -1104,16 +1104,11 @@ if (embeddedEl) {
   }
   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')))
+  // 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 Before/After appear broken. Users can load scratch
+  // exports explicitly with the picker or run them through Query planner.
+  fetch('dag.example.json', { cache: 'no-store' })
     .then((r) => (r.ok ? r.json() : null))
     .then(loadWorkload)
     .catch(() => {})

From 0b246d0b9e7d5028f7c65dfce1e5120e32b8dadb Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:46:49 -0600
Subject: [PATCH 10/27] fix: simplify post-ASAP node explanations

---
 crates/devtools/src/bin/dag_export.rs | 41 +++++++++++++++++++++++++--
 tools/dag-viewer/server.py            |  4 ++-
 tools/dag-viewer/viewer.js            |  5 ++--
 3 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 3eb889b4..6a1f6598 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -189,6 +189,43 @@ struct Winner<'a> {
     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()
+        }
+        _ => {
+            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
@@ -232,7 +269,7 @@ fn target_replacement(
         decision_id,
         target_pre_id,
         strategy,
-        rationale: winner.candidate.rationale.clone(),
+        rationale: decision_rationale(winner),
         rank: 0,
         cost: winner.cost,
         before,
@@ -351,7 +388,7 @@ fn run_post_asap_with_progress(
         let decision = DagDecision {
             id: i as u32,
             strategy: winner.candidate.strategy.to_string(),
-            rationale: winner.candidate.rationale.clone(),
+            rationale: decision_rationale(winner),
             rank: 0,
             cost: winner.cost,
             role: "replacement_region",
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index b231cede..81c1eba8 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -12,6 +12,8 @@
 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"
@@ -80,7 +82,7 @@ def relay_stderr() -> None:
     stderr = "\n".join(stderr_lines)
     if returncode != 0:
         raise RuntimeError(stderr.strip() or "dag_export failed")
-    workload = json.loads(stdout)
+    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
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index b82801a3..bf74f3f4 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -823,6 +823,7 @@ function showBeforeAfterDetail(data) {
   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}`;
 
   const rootHtml = data.root
     ? `<div class="rootNote">This is the root of ${escapeHtml(data.queryName)}'s complete ${stageName} DAG.</div>`
@@ -847,11 +848,11 @@ function showBeforeAfterDetail(data) {
 
   detailSection.innerHTML = `
     <h2>Selected node</h2>
-    <span class="chip" style="color:${catColors.border}; background:${catColors.bg}">${escapeHtml(catLabel)} · ${escapeHtml(node.kind)}</span>
+    <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}
-    ${notesHtml(node)}
+    ${data.stage === 'pre' ? notesHtml(node) : ''}
     <h3 class="detailSubhead">IR node content</h3>
     <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
   `;

From 63a77e14ab10b3dd48b76d0f6d4f0ff26bbd20c4 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:47:28 -0600
Subject: [PATCH 11/27] fix: keep pre-ASAP lanes free of strategy metadata

---
 tools/dag-viewer/viewer.js | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index bf74f3f4..ed20eaf9 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -428,7 +428,9 @@ function finalizeGraphInteractions() {
   // 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;
+    // Before/After has a strict stage split: pre-ASAP is the unannotated IR,
+    // while post-ASAP carries explicit decision explanations.
+    if (n.data('isLane') || n.data('isBeforeAfter')) return;
     const node = n.data('node');
     if (!node || !node.notes || !node.notes.length) return;
     n.addClass('hasNotes');
@@ -806,8 +808,10 @@ function renderBaScopeSummary(selected) {
 }
 
 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((r) => r.rank === 0);
-  if (stage === 'pre') return replacements.filter((r) => r.target_pre_id === node.id);
   if (!node.decision) return [];
   const replacement = replacements.find((r) => r.decision_id === node.decision.id);
   return [{
@@ -840,8 +844,7 @@ function showBeforeAfterDetail(data) {
         <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.after || {}).kind || node.kind)}</div>
       </div>`).join('');
-    const heading = data.stage === 'post' ? 'Why this post-ASAP translation' : 'Selected post-ASAP strategy for this node';
-    translationHtml = `<div class="translationBlock"><h3>${heading}</h3>${cards}</div>`;
+    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>`;
   }
@@ -852,7 +855,6 @@ function showBeforeAfterDetail(data) {
     <div style="font-weight:650; margin:0.3rem 0 0.4rem">${escapeHtml(node.label)}</div>
     ${rootHtml}
     ${translationHtml}
-    ${data.stage === 'pre' ? notesHtml(node) : ''}
     <h3 class="detailSubhead">IR node content</h3>
     <pre>${escapeHtml(JSON.stringify(node.detail, null, 2))}</pre>
   `;

From f2f12fec9b1acca628b3f39cb06c9ab11782045a Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 21:54:40 -0600
Subject: [PATCH 12/27] fix: preserve shared inputs in post-ASAP DAG export

---
 crates/asap-aware-mapping/src/cost_model.rs  |   2 +-
 crates/asap-aware-mapping/src/replacement.rs |  10 +-
 crates/devtools/src/bin/dag_export.rs        |  17 +++-
 crates/types/src/dag_export.rs               |  43 +++++++-
 crates/types/src/post_asap/expr.rs           |   4 +-
 tools/dag-viewer/dag.example.json            | 100 ++++---------------
 6 files changed, 87 insertions(+), 89 deletions(-)

diff --git a/crates/asap-aware-mapping/src/cost_model.rs b/crates/asap-aware-mapping/src/cost_model.rs
index a5b910e3..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,
diff --git a/crates/asap-aware-mapping/src/replacement.rs b/crates/asap-aware-mapping/src/replacement.rs
index 1a0b65ca..a4aa34be 100644
--- a/crates/asap-aware-mapping/src/replacement.rs
+++ b/crates/asap-aware-mapping/src/replacement.rs
@@ -1234,10 +1234,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),
     }))
 }
@@ -1307,7 +1311,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
diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 6a1f6598..86620df4 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -316,7 +316,7 @@ fn run_post_asap_with_progress(
 
     // A group's top candidate can be `keep_pre_asap`'s own conservative
     // fallback — `Replacement::Summary(SummaryNode { expr:
-    // KeepPreAsap(Box::new(target.clone())), .. })` — the *whole target*
+    // 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
@@ -691,6 +691,21 @@ mod tests {
                 "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()
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 6904d7f6..e038bd0d 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -41,6 +41,7 @@
 //! `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;
@@ -91,6 +92,11 @@ pub struct DagNode {
     /// 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)]
+    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
@@ -577,9 +583,40 @@ pub fn export_post_asap(
     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,
-        root: root_id,
+        nodes: deduplicated,
+        root: old_to_new[root as usize],
     }
 }
 
@@ -608,6 +645,7 @@ fn push_node(
         children,
         hash,
         source_expr: Some(expr.clone()),
+        source_ptr: Some(expr as *const QueryExpr as usize),
         notes: Vec::new(),
         decision: None,
     });
@@ -640,6 +678,7 @@ fn push_summary_originated_node(
         children,
         hash: None,
         source_expr: None,
+        source_ptr: None,
         notes: Vec::new(),
         decision: None,
     });
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/dag.example.json b/tools/dag-viewer/dag.example.json
index 1fe5911c..77d29db1 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -125,7 +125,7 @@
           "decision_id": 0,
           "target_pre_id": 1,
           "strategy": "SketchAlgorithmStrategy",
-          "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+          "rationale": "count realizes as a Cms sketch",
           "rank": 0,
           "cost": 3.0,
           "before": {
@@ -373,7 +373,7 @@
             "decision": {
               "id": 0,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "rationale": "count realizes as a Cms sketch",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_region"
@@ -399,7 +399,7 @@
             "decision": {
               "id": 0,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "rationale": "count realizes as a Cms sketch",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_region"
@@ -418,7 +418,7 @@
             "decision": {
               "id": 0,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "count realizes as a Cms sketch — one of summary_candidates' alternatives for this intent (asap_aware_mapping::replacement::implementations_for_with)",
+              "rationale": "count realizes as a Cms sketch",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_root"
@@ -571,7 +571,7 @@
           "decision_id": 1,
           "target_pre_id": 1,
           "strategy": "AvgToSumOverCountStrategy",
-          "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+          "rationale": "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT.",
           "rank": 0,
           "cost": 2.0,
           "before": {
@@ -921,7 +921,7 @@
             "decision": {
               "id": 3,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_region"
@@ -952,7 +952,7 @@
             "decision": {
               "id": 3,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_root"
@@ -992,7 +992,7 @@
             "decision": {
               "id": 1,
               "strategy": "AvgToSumOverCountStrategy",
-              "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+              "rationale": "Rewrites AVG into SUM and COUNT under the same grouping, then divides SUM by COUNT.",
               "rank": 0,
               "cost": 2.0,
               "role": "replacement_region"
@@ -1000,66 +1000,6 @@
           },
           {
             "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"
-                }
-              }
-            },
-            "children": [],
-            "hash": 2606922452740434172,
-            "decision": {
-              "id": 4,
-              "strategy": "SketchAlgorithmStrategy",
-              "rationale": "count realizes as an exact Count accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
-              "rank": 0,
-              "cost": 3.0,
-              "role": "replacement_region"
-            }
-          },
-          {
-            "id": 4,
             "kind": "SummaryAgg",
             "label": "SummaryAgg(ExactAggregate(Count))",
             "detail": {
@@ -1073,19 +1013,19 @@
               }
             },
             "children": [
-              3
+              0
             ],
             "decision": {
               "id": 4,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "count realizes as an exact Count accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "count realizes as an exact Count accumulator",
               "rank": 0,
               "cost": 3.0,
               "role": "replacement_root"
             }
           },
           {
-            "id": 5,
+            "id": 4,
             "kind": "BinaryOp",
             "label": "BinaryOp(/)",
             "detail": {
@@ -1094,20 +1034,20 @@
             },
             "children": [
               2,
-              4
+              3
             ],
             "hash": 16391872732257280252,
             "decision": {
               "id": 1,
               "strategy": "AvgToSumOverCountStrategy",
-              "rationale": "avg has no summary realization at all (replacement::implementations_for_with dispatches it to PassThrough) and so can never share or sketch; rewriting it into sum/count under the same grouping — re-divided back into the original avg column by a wrapping Project — computes the same result from two ordinary mergeable accumulators SharedSubtreeStrategy (and a future sketch-family search) can actually reuse across the workload",
+              "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": 6,
+            "id": 5,
             "kind": "Project",
             "label": "Project(2 cols)",
             "detail": {
@@ -1128,12 +1068,12 @@
               "qualifier": null
             },
             "children": [
-              5
+              4
             ],
             "hash": 5277207484379927121
           }
         ],
-        "root": 6
+        "root": 5
       }
     },
     {
@@ -1253,7 +1193,7 @@
           "decision_id": 2,
           "target_pre_id": 2,
           "strategy": "SketchAlgorithmStrategy",
-          "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+          "rationale": "Rate realizes as an exact Rate accumulator",
           "rank": 0,
           "cost": 4.0,
           "before": {
@@ -1455,7 +1395,7 @@
             "decision": {
               "id": 2,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
               "cost": 4.0,
               "role": "replacement_region"
@@ -1478,7 +1418,7 @@
             "decision": {
               "id": 2,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
               "cost": 4.0,
               "role": "replacement_region"
@@ -1500,7 +1440,7 @@
             "decision": {
               "id": 2,
               "strategy": "SketchAlgorithmStrategy",
-              "rationale": "Rate realizes as an exact Rate accumulator — the only realization implementations_for_with produces for this intent (no approximate candidate applies)",
+              "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
               "cost": 4.0,
               "role": "replacement_root"

From 2c1848089535ca69c5d8f9cd1dfb31bd7a6e9b86 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 22:10:47 -0600
Subject: [PATCH 13/27] feat: unify viewer around Pre/Post-ASAP workload DAGs

---
 tools/dag-viewer/README.md      | 352 ++++++--------------------------
 tools/dag-viewer/RUNNING.md     |   4 +-
 tools/dag-viewer/index.html     |   6 +-
 tools/dag-viewer/render.py      |  28 +--
 tools/dag-viewer/test_render.py |  27 +--
 tools/dag-viewer/viewer.js      | 238 ++++++++++-----------
 6 files changed, 196 insertions(+), 459 deletions(-)

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 7e690ea7..be0a99b7 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -1,315 +1,91 @@
-# 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. Structurally identical nodes and edges 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.
 
-```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
-```
+There are no separate Single, Compare, or Union modes.
 
-`--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.
+## Interactive query editor
 
-## Run the interactive planner viewer
+From the repository root:
 
 ```sh
 python3 tools/dag-viewer/server.py
-# open http://127.0.0.1:8000
 ```
 
-The server builds `dag_export` once, serves the UI, and exposes a local
-`POST /api/plan`. Open **Query editor**, add SQL/PromQL entries, choose which
-ones belong to the workload, and click **Plan selected workload**. The backend
-passes the whole batch to the real `dag_export --post-asap` binary as an argv
-array (never a shell command), running pre-ASAP lowering, ASAP-aware workload
-mapping, and post-ASAP export before returning the `WorkloadGraph` to the UI.
-It listens on `127.0.0.1` by default.
-
-## Open a static export
+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:
 
-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.
+1. SQL/PromQL parsing and lowering
+2. pre-ASAP DAG generation
+3. ASAP-aware mapping
+4. post-ASAP DAG generation
 
-- 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 heavier border.
-- A node whose `notes` array is non-empty gets a double border; click it to
-  see each note's kind and reason in the side panel.
-- Node color 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.
-- If a query's export carries `replacements` (`dag_export --post-asap`),
-  switch to **Before/After** mode for complete pre-/post-ASAP DAGs — see below.
+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.
 
-## 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:
+## Export JSON directly
 
 ```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
+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
 ```
 
-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.
-
-Pre-ASAP nodes have no per-node execution cost. Post-ASAP replacement nodes
-do carry the chosen candidate's estimated cost as part of `decision` and the
-side panel renders it alongside strategy/rationale.
-
-## Visual style and node categories
-
-Node colors 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).
-
-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.
-
-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.
-
-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.
+Load the JSON with the page's file picker. A post-ASAP visualization requires
+`--post-asap`; ordinary exports intentionally omit `post_graph`.
 
-### "Shared" here means matching hash, not real CSE
+## Standalone HTML
 
-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.
-
-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.
-
-## Replacement explanations (`notes`)
-
-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 from a
+node label, hash, or client-side signature. Union signatures are used only to
+collapse structurally identical visualization nodes; they do not infer
+planner decisions.
 
-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 double border; click the
-node to see each note's kind and full reason text in the side panel, the same
-"click for detail" pattern used for IR content and translation decisions.
-
-## Before/After mode
-
-`dag_export --post-asap` attaches a `replacements` array to each
-query — one entry per place in the query where `asap-aware-mapping` actually
-*chose* a real optimization (cost-ranked, not just "could apply"): a sketch
-mapping, a CSE share/recompute, a workload-aware rollup, Hydra
-frequency-sketch grouping, or an `avg`→`sum`/`count` rewrite. Each entry
-carries its own small `before` subtree (the pre-ASAP nodes it replaced) and
-`after` subtree — either a rewritten pre-ASAP graph (`after.kind ===
-"Rewrite"`, e.g. the `avg` rewrite) or a post-ASAP "Summary" graph
-(`after.kind === "Summary"`, e.g. a sketch realization), plus `strategy`,
-`provenance`, a human `rationale`, and this candidate's `rank`/`cost` among
-whatever else was considered for the same target (`rank: 0` is the winner).
-
-**Before/After** uses checkbox tabs as a workload selector. Select one query
-to see its complete `graph` (pre-ASAP) and complete `post_graph` side by side.
-Select several queries to see every selected query's complete pre-ASAP DAG
-and post-ASAP DAG in one batch view. Per-target mini-subtrees are not the main
-view; their replacement records instead explain clicked nodes.
-
-Every `post_graph.nodes[]` entry produced or carried by a winning replacement
-contains a self-contained `decision` object with `id`, `strategy`,
-`rationale`, `rank`, `cost`, and `role` (`replacement_root` or
-`replacement_region`). This is a hard export contract: the viewer reads that
-field directly and never guesses provenance from a label, structural hash, or
-similarity to a replacement subtree. Clicking a post-ASAP node shows exactly
-why it was translated (or carried inside a translated region), while clicking
-the corresponding pre-ASAP target shows the selected replacement entry.
-
-A Summary graph's nodes (`SummaryDagNode`, from `after.kind === "Summary"` or
-from `post_graph`) are a different shape than the pre-ASAP `DagNode`s
-everywhere else in this viewer: `kind` is one of `KeepPreAsap`, `SummaryAgg`,
-`SummaryJoin`, `SummarySubtract`, `SummaryDelete`, `SummaryEstimate`,
-`SummaryMerge`, and there's no `hash` (no corresponding `QueryExpr` to hash)
-and no `notes`. `node-style.js` maps all seven to a new `summary` category —
-neutral gray rather than another saturated hue, both because a 10th vivid
-color starts crowding the other 9 and because "materialized post-ASAP
-structure" reads better as its own muted family than as one more member of
-the pre-ASAP rainbow. `KeepPreAsap` — literally an unchanged pre-ASAP subtree
-carried through as-is — gets an even more washed-out, dashed treatment on
-top of that (see `buildCyStyle`'s `node[kind = "KeepPreAsap"]` override in
-`viewer.js`), so a glance at an After lane separates "the planner did
-something here" from "left alone." Side-panel node inspection is otherwise
-identical to every other mode: click a node, get its `detail` dumped
-verbatim; a `SummaryDagNode`'s missing `hash`/`notes` just means the
-cross-query "shared with" note and notes block don't render, not a crash.
-
-## 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/index.html b/tools/dag-viewer/index.html
index 9a23e793..fd615c08 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -370,12 +370,8 @@ <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" id="modeBeforeAfterBtn" data-mode="beforeafter">Before/After</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">
diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index 21b647e5..76a7c2ad 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
@@ -272,7 +272,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()
 
@@ -283,13 +283,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
@@ -307,12 +306,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", "beforeafter"],
-        default="single",
-        help="initial view mode; Before/After starts with the first query selected (default: single)",
-    )
     args = parser.parse_args()
 
     try:
@@ -327,14 +320,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/test_render.py b/tools/dag-viewer/test_render.py
index 50229b99..537abd10 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>',
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index ed20eaf9..60f9e63d 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -26,18 +26,8 @@ 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. 'beforeafter'
-// draws the complete pre-ASAP and post-ASAP DAG for every checked query.
-// One checked query is the single-query view; 2+ checked queries are a
-// workload/batch view. Replacement entries are explanations attached to
-// clicked nodes, not separate tiny-subtree views.
-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');
@@ -55,7 +45,6 @@ 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'); });
@@ -69,9 +58,7 @@ fileInput.addEventListener('change', (e) => loadFiles(e.target.files));
 clearBtn.addEventListener('click', () => {
   queries = [];
   activeIndex = -1;
-  mode = 'single';
   participants = new Set();
-  setModeButtons();
   render();
 });
 highlightToggle.addEventListener('change', () => {
@@ -79,30 +66,6 @@ highlightToggle.addEventListener('change', () => {
   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 === 'compare' || mode === 'union') && participants.size === 0) {
-      queries.forEach((_, i) => participants.add(i));
-    }
-    // First switch into Before/After: start with the currently active query.
-    // The checkbox tabs can then expand that into a batch workload.
-    if (mode === 'beforeafter') {
-      if (activeIndex === -1 && queries.length > 0) activeIndex = 0;
-      if (participants.size === 0 && activeIndex >= 0) participants.add(activeIndex);
-    }
-    render();
-  });
-});
-
-function setModeButtons() {
-  document.querySelectorAll('#modeToggle .btn').forEach((b) => b.classList.toggle('active', b.dataset.mode === mode));
-  proxyNote.style.display = mode === 'compare' || mode === 'union' ? 'inline' : 'none';
-}
-
 function loadFiles(fileList) {
   const files = Array.from(fileList || []);
   let pending = files.length;
@@ -126,6 +89,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();
       }
     };
@@ -185,38 +149,13 @@ function render() {
 
   renderTabs();
 
-  if (mode === 'single') {
-    baPickerEl.classList.remove('visible');
-    if (activeIndex === -1) activeIndex = 0;
-    renderGraph(queries[activeIndex]);
-  } else if (mode === 'compare') {
-    baPickerEl.classList.remove('visible');
-    renderCompare(getParticipants());
-  } else if (mode === 'union') {
-    baPickerEl.classList.remove('visible');
-    renderUnion(getParticipants());
-  } else {
-    renderBeforeAfter();
-  }
+  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/Before-After: checkboxes choose the workload.
+  // 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' : '');
@@ -448,7 +387,7 @@ function finalizeGraphInteractions() {
       return;
     }
     const query = queries.find((q) => q.name === n.data('queryName'));
-    showDetail(n.data('node'), query, mode === 'compare' ? getParticipants().map((i) => queries[i]) : undefined);
+    showDetail(n.data('node'), query);
   });
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
 }
@@ -702,24 +641,21 @@ function renderUnion(chosen) {
   fitAndSyncZoom();
 }
 
-// ── Before/After mode: complete query/workload pre/post DAGs ─────────────
-// Checkbox tabs select one query or a batch. Every selected query contributes
-// a complete pre-ASAP lane and complete post-ASAP lane. Replacement records
-// power node-click explanations instead of being rendered as tiny subtrees.
-function renderBeforeAfter() {
+// ── Pre/Post-ASAP: one query or two workload-union DAGs ──────────────────
+function renderPrePostAsap() {
   const chosen = getParticipants();
   const selected = chosen.map((i) => queries[i]);
   renderBaScopeSummary(selected);
   renderSourcePanel(selected);
 
   if (selected.length === 0) {
-    viewTitleEl.textContent = 'Before/After';
+    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 ? `Before/After: ${selected[0].name}` : `Batch Before/After: ${selected.length} queries`;
+    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.';
@@ -728,24 +664,106 @@ function renderBeforeAfter() {
   }
   hideModeHint();
   viewTitleEl.textContent = selected.length === 1
-    ? `Before/After: ${selected[0].name} — complete IR DAG`
-    : `Batch Before/After: ${selected.length} queries`;
+    ? `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();
+  clearDetail();
+  fitAndSyncZoom();
+}
+
+function unionStageLaneElements(stage, chosen) {
+  const laneId = `${stage}-asap-union`;
+  const graphFor = (query) => (stage === 'pre' ? query.graph : query.post_graph);
+  const signatures = new Map();
+  const owners = new Map();
 
-  const elements = [];
   chosen.forEach((qIdx) => {
     const query = queries[qIdx];
-    elements.push(...laneElements(`ba-pre-${qIdx}`, `${query.name} · pre-ASAP`, query.graph, query, 'pre'));
+    const graph = graphFor(query);
+    const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+    const perQuery = new Map();
+    const signatureFor = (node) => {
+      if (perQuery.has(node.id)) return perQuery.get(node.id);
+      const childSignatures = node.children.map((id) => signatureFor(byId.get(id)));
+      const signature = JSON.stringify([node.kind, node.detail, childSignatures]);
+      perQuery.set(node.id, signature);
+      if (!owners.has(signature)) owners.set(signature, new Set());
+      owners.get(signature).add(query.name);
+      return signature;
+    };
+    graph.nodes.forEach(signatureFor);
+    signatures.set(qIdx, perQuery);
+  });
+
+  const sharedIds = new Map();
+  let nextSharedId = 0;
+  owners.forEach((queryNames, signature) => {
+    if (queryNames.size > 1) sharedIds.set(signature, `${laneId}-shared-${nextSharedId++}`);
   });
+  const keyFor = (qIdx, node) => sharedIds.get(signatures.get(qIdx).get(node.id)) || `${laneId}-q${qIdx}-${node.id}`;
+  const entries = new Map();
+  const edges = new Set();
+  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];
-    elements.push(...laneElements(`ba-post-${qIdx}`, `${query.name} · post-ASAP`, query.post_graph, query, 'post'));
+    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, query, sourceQueries: new Set(), rootFor: new Set() };
+        entries.set(key, entry);
+      }
+      entry.sourceQueries.add(query.name);
+      if (node.id === graph.root) entry.rootFor.add(query.name);
+      node.children.forEach((childId) => {
+        const childKey = keyFor(qIdx, byId.get(childId));
+        edges.add(`${childKey}\u0000${key}`);
+      });
+    });
   });
 
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
+  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),
+      isBeforeAfter: true,
+      stage,
+      queryName: entry.query.name,
+      translations: translationsForNode(entry.query, entry.node, stage),
+    },
+    classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
+  }));
+  let edgeIndex = 0;
+  edges.forEach((edge) => {
+    const [source, target] = edge.split('\u0000');
+    elements.push({ data: { id: `${laneId}-edge-${edgeIndex++}`, source, target } });
+  });
+  return elements;
 }
 
 // Builds one Compare-mode-style lane (a dashed compound parent plus its
@@ -829,8 +847,9 @@ function showBeforeAfterDetail(data) {
   const stageName = data.stage === 'pre' ? 'pre-ASAP' : 'post-ASAP';
   const chipLabel = catLabel === node.kind ? node.kind : `${catLabel} · ${node.kind}`;
 
+  const rootNames = data.rootFor && data.rootFor.length ? data.rootFor : [data.queryName];
   const rootHtml = data.root
-    ? `<div class="rootNote">This is the root of ${escapeHtml(data.queryName)}'s complete ${stageName} DAG.</div>`
+    ? `<div class="rootNote">Root of the complete ${stageName} DAG for: ${rootNames.map(escapeHtml).join(', ')}.</div>`
     : '';
 
   const decisions = data.translations || [];
@@ -887,8 +906,7 @@ function renderSourcePanel(qs) {
 
 function applyHighlighting() {
   if (!cy) return;
-  if (mode === 'beforeafter') {
-    const selected = getParticipants().map((i) => queries[i]);
+  const selected = getParticipants().map((i) => queries[i]);
     const ownersFor = (graphOf) => {
       const owners = new Map();
       selected.forEach((q) => {
@@ -912,17 +930,6 @@ function applyHighlighting() {
       const sharedWith = node && owners.get(node.hash);
       n.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
     });
-    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);
-  });
 }
 
 function clearDetail() {
@@ -1022,20 +1029,10 @@ function renderLegend() {
     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>`);
-  }
-  if (mode === 'beforeafter') {
-    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>`);
-  }
+  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('');
 }
 
@@ -1064,6 +1061,7 @@ function loadWorkload(parsed) {
   const incoming = (parsed && parsed.queries) || [];
   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
@@ -1075,8 +1073,6 @@ window.renderPlannerWorkload = function renderPlannerWorkload(parsed) {
   activeIndex = -1;
   loadWorkload(parsed);
   queries.forEach((_, index) => participants.add(index));
-  mode = 'beforeafter';
-  setModeButtons();
   render();
 };
 
@@ -1086,8 +1082,7 @@ window.renderPlannerWorkload = function renderPlannerWorkload(parsed) {
 // 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 {
@@ -1095,16 +1090,7 @@ 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;
-    if (mode === 'beforeafter') {
-      if (queries.length > 0) participants.add(0);
-    } else {
-      queries.forEach((_, i) => participants.add(i));
-    }
-    setModeButtons();
-  }
+  if (queries.length > 0 && participants.size === 0) participants.add(0);
   render();
 } else {
   // Plain index.html starts with the committed, post-ASAP-generated example.

From d29cb0437df72c73d54d13f4690ec5017a8db761 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Tue, 25 Aug 2026 22:14:39 -0600
Subject: [PATCH 14/27] fix: show aggregate reductions in DAG nodes

---
 tools/dag-viewer/render.py      | 36 ++++++++++++++++++++++++---------
 tools/dag-viewer/test_render.py | 16 +++++++++++++++
 2 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index 76a7c2ad..581075d3 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -86,8 +86,14 @@ 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)
 
@@ -109,16 +115,16 @@ def _measure(value: object) -> str:
     return f"{kind}({', '.join(args)})" if args else f"{kind}()"
 
 
-def _grouping(reduction: object) -> str | None:
+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)
 
 
@@ -131,7 +137,7 @@ 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 {}
@@ -152,7 +158,7 @@ def _semantic_label(node: dict) -> str:
     elif kind == "Aggregate":
         measures = detail.get("measures") or []
         lines.extend(f"compute: {_measure(measure)}" for measure in measures)
-        grouping = _grouping(detail.get("reduction"))
+        grouping = _grouping(detail.get("reduction"), input_schema)
         if grouping:
             lines.append(grouping)
         if detail.get("having"):
@@ -183,9 +189,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":
@@ -215,8 +230,11 @@ 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("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)
 
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index 537abd10..dee3f030 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -181,6 +181,22 @@ def test_aggregate_names_measure_input_and_grouping(self):
             "Aggregate\ncompute: 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"
+            "group by col[1]\nsummary layout: PerSubpopulationInstance",
+        )
+
     def test_sort_names_expression_direction_and_null_order(self):
         node = {
             "kind": "Sort",

From 216c013dca917ad785d15d7a067159c266633bf0 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 05:48:54 -0600
Subject: [PATCH 15/27] feat: optionally display schemas on DAG edges

---
 crates/types/src/dag_export.rs    |   25 +-
 tools/dag-viewer/README.md        |    3 +
 tools/dag-viewer/dag.example.json | 1002 ++++++++++++++++++++++++++++-
 tools/dag-viewer/index.html       |    4 +
 tools/dag-viewer/render.py        |    6 +-
 tools/dag-viewer/viewer.js        |   53 +-
 6 files changed, 1084 insertions(+), 9 deletions(-)

diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index e038bd0d..2429ff0b 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -61,6 +61,10 @@ 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>,
@@ -642,6 +646,10 @@ fn push_node(
         kind,
         label,
         detail,
+        schema: expr
+            .output_schema()
+            .ok()
+            .and_then(|schema| serde_json::to_value(schema).ok()),
         children,
         hash,
         source_expr: Some(expr.clone()),
@@ -675,6 +683,7 @@ fn push_summary_originated_node(
         kind,
         label,
         detail,
+        schema: None,
         children,
         hash: None,
         source_expr: None,
@@ -710,7 +719,20 @@ fn build_summary_hybrid(
         .map(|child| build_summary_hybrid(child, nodes, cache, find_winner))
         .collect();
     let (kind, label, detail) = summary_shape(&node.expr);
-    push_summary_originated_node(nodes, kind, label, detail, children)
+    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 {
@@ -1221,6 +1243,7 @@ mod tests {
         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"),
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index be0a99b7..ef824dd8 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -9,6 +9,9 @@ The viewer has one visualization mode: **Pre/Post-ASAP**.
 - 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.
+- **Show edge schemas** optionally labels each data-flow edge with the source
+  node's output columns and types. It is off by default to keep large DAGs
+  readable.
 
 There are no separate Single, Compare, or Union modes.
 
diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index 77d29db1..1b306b8a 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -54,6 +54,43 @@
                 }
               }
             },
+            "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
           },
@@ -80,6 +117,29 @@
                 ]
               }
             },
+            "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
             ],
@@ -112,6 +172,29 @@
               ],
               "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
             ],
@@ -179,6 +262,43 @@
                     }
                   }
                 },
+                "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
               },
@@ -205,6 +325,29 @@
                     ]
                   }
                 },
+                "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
                 ],
@@ -274,7 +417,44 @@
                           "hash": 2606922452740434172,
                           "id": 0,
                           "kind": "Scan",
-                          "label": "Scan(metrics)"
+                          "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
@@ -368,6 +548,43 @@
                 }
               }
             },
+            "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,
             "decision": {
@@ -393,6 +610,21 @@
                 ]
               }
             },
+            "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
             ],
@@ -412,6 +644,21 @@
             "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
             ],
@@ -445,6 +692,29 @@
               ],
               "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": [
               2
             ],
@@ -508,6 +778,43 @@
                 }
               }
             },
+            "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
           },
@@ -532,6 +839,29 @@
                 ]
               }
             },
+            "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
             ],
@@ -558,6 +888,29 @@
               ],
               "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
             ],
@@ -625,6 +978,43 @@
                     }
                   }
                 },
+                "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
               },
@@ -649,6 +1039,29 @@
                     ]
                   }
                 },
+                "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
                 ],
@@ -710,6 +1123,43 @@
                       }
                     }
                   },
+                  "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
                 },
@@ -732,6 +1182,29 @@
                       ]
                     }
                   },
+                  "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
                   ],
@@ -764,6 +1237,29 @@
                     ],
                     "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
                   ],
@@ -818,6 +1314,43 @@
                       }
                     }
                   },
+                  "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
                 },
@@ -840,6 +1373,29 @@
                       ]
                     }
                   },
+                  "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
                   ],
@@ -853,6 +1409,29 @@
                     "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
@@ -916,6 +1495,43 @@
                 }
               }
             },
+            "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,
             "decision": {
@@ -946,6 +1562,21 @@
                 ]
               }
             },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Sum, Sum)",
+                  "name": "sum",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
             "children": [
               0
             ],
@@ -985,6 +1616,29 @@
               ],
               "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
             ],
@@ -1012,6 +1666,21 @@
                 ]
               }
             },
+            "schema": {
+              "fields": [
+                {
+                  "dtype": "Plain(Utf8)",
+                  "name": "service",
+                  "nullable": false
+                },
+                {
+                  "dtype": "ExactAggregate(Count, Count)",
+                  "name": "count",
+                  "nullable": false
+                }
+              ],
+              "time_index": null
+            },
             "children": [
               0
             ],
@@ -1032,6 +1701,29 @@
               "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
@@ -1067,6 +1759,29 @@
               ],
               "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
             ],
@@ -1112,6 +1827,25 @@
                 }
               }
             },
+            "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
           },
@@ -1125,6 +1859,25 @@
                 "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
             ],
@@ -1146,6 +1899,25 @@
               ],
               "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
             ],
@@ -1167,6 +1939,25 @@
               ],
               "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
             ],
@@ -1180,6 +1971,25 @@
               "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
             ],
@@ -1229,6 +2039,25 @@
                     }
                   }
                 },
+                "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
               },
@@ -1242,6 +2071,25 @@
                     "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
                 ],
@@ -1263,6 +2111,25 @@
                   ],
                   "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
                 ],
@@ -1314,7 +2181,26 @@
                           "hash": 16569634401303792668,
                           "id": 0,
                           "kind": "Scan",
-                          "label": "Scan(http_requests_total)"
+                          "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": [
@@ -1329,7 +2215,26 @@
                           "hash": 12007712336004404578,
                           "id": 1,
                           "kind": "TimeRange",
-                          "label": "TimeRange(300s)"
+                          "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
@@ -1390,6 +2295,25 @@
                 }
               }
             },
+            "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,
             "decision": {
@@ -1411,6 +2335,25 @@
                 "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
             ],
@@ -1434,6 +2377,21 @@
               "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
             ],
@@ -1462,6 +2420,25 @@
               ],
               "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
             ],
@@ -1475,6 +2452,25 @@
               "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
             ],
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index fd615c08..59ff9cb1 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -378,6 +378,10 @@ <h1>ASAP query DAG viewer</h1>
     <input id="highlightToggle" type="checkbox" checked />
     Highlight shared subtrees
   </label>
+  <label class="toggle">
+    <input id="schemaToggle" type="checkbox" />
+    Show edge schemas
+  </label>
 </header>
 
 <div id="plannerPanel">
diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index 581075d3..eecd2374 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -233,7 +233,11 @@ def prepare_graph(graph: object) -> None:
         by_id = {node.get("id"): node for node in graph.get("nodes", [])}
         for node in graph.get("nodes", []):
             child = by_id.get((node.get("children") or [None])[0])
-            input_schema = (child.get("detail") or {}).get("schema") if isinstance(child, dict) else None
+            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)
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 60f9e63d..0ae09ca6 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -25,6 +25,7 @@ let queries = [];
 let activeIndex = -1;
 let cy = null;
 let highlightOn = true;
+let showEdgeSchemas = false;
 let zoom = 1;
 // 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.
@@ -34,6 +35,7 @@ const dropzone = document.getElementById('dropzone');
 const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
+const schemaToggle = document.getElementById('schemaToggle');
 const tabsEl = document.getElementById('tabs');
 const baPickerEl = document.getElementById('baPicker');
 const cyOuterEl = document.getElementById('cyOuter');
@@ -65,6 +67,10 @@ highlightToggle.addEventListener('change', () => {
   highlightOn = highlightToggle.checked;
   applyHighlighting();
 });
+schemaToggle.addEventListener('change', () => {
+  showEdgeSchemas = schemaToggle.checked;
+  applyEdgeSchemaVisibility();
+});
 
 function loadFiles(fileList) {
   const files = Array.from(fileList || []);
@@ -304,11 +310,26 @@ 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',
       },
     },
+    {
+      selector: 'edge.showSchema',
+      style: {
+        'label': 'data(schemaLabel)',
+      },
+    },
     {
       // Compare mode's cross-lane "same hash" connector: dashed, no
       // arrowhead (it isn't a data-flow edge), added after layout so it
@@ -449,6 +470,7 @@ function renderGraph(query) {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
+  applyEdgeSchemaVisibility();
   clearDetail();
   zoom = 1;
   applyZoom();
@@ -637,6 +659,7 @@ function renderUnion(chosen) {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
+  applyEdgeSchemaVisibility();
   clearDetail();
   fitAndSyncZoom();
 }
@@ -680,6 +703,7 @@ function renderPrePostAsap() {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
+  applyEdgeSchemaVisibility();
   clearDetail();
   fitAndSyncZoom();
 }
@@ -715,7 +739,7 @@ function unionStageLaneElements(stage, chosen) {
   });
   const keyFor = (qIdx, node) => sharedIds.get(signatures.get(qIdx).get(node.id)) || `${laneId}-q${qIdx}-${node.id}`;
   const entries = new Map();
-  const edges = new Set();
+  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 },
   ];
@@ -735,7 +759,8 @@ function unionStageLaneElements(stage, chosen) {
       if (node.id === graph.root) entry.rootFor.add(query.name);
       node.children.forEach((childId) => {
         const childKey = keyFor(qIdx, byId.get(childId));
-        edges.add(`${childKey}\u0000${key}`);
+        const child = byId.get(childId);
+        edges.set(`${childKey}\u0000${key}`, formatSchema(child.schema));
       });
     });
   });
@@ -759,9 +784,9 @@ function unionStageLaneElements(stage, chosen) {
     classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
   }));
   let edgeIndex = 0;
-  edges.forEach((edge) => {
+  edges.forEach((schemaLabel, edge) => {
     const [source, target] = edge.split('\u0000');
-    elements.push({ data: { id: `${laneId}-edge-${edgeIndex++}`, source, target } });
+    elements.push({ data: { id: `${laneId}-edge-${edgeIndex++}`, source, target, schemaLabel } });
   });
   return elements;
 }
@@ -775,6 +800,7 @@ function unionStageLaneElements(stage, chosen) {
 // read by this function or by showBeforeAfterDetail 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 },
   ];
@@ -809,6 +835,7 @@ function laneElements(laneId, laneLabel, graph, query, stage) {
           id: `e-${laneId}-${node.id}-${childId}`,
           source: `${laneId}-${childId}`,
           target: `${laneId}-${node.id}`,
+          schemaLabel: formatSchema(byId.get(childId).schema),
         },
       });
     }
@@ -816,6 +843,24 @@ function laneElements(laneId, laneLabel, graph, query, stage) {
   return elements;
 }
 
+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';
+  return fields.map((field) => {
+    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}: ${dtype}${field && field.nullable ? '?' : ''}`;
+  }).join(' · ');
+}
+
+function applyEdgeSchemaVisibility() {
+  if (!cy) return;
+  cy.edges().toggleClass('showSchema', showEdgeSchemas);
+}
+
 function renderBaScopeSummary(selected) {
   baPickerEl.classList.add('visible');
   const strategies = new Set();

From cd58a100fce972d0faa8e84cfa2b705919accc4f Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 05:52:19 -0600
Subject: [PATCH 16/27] feat: add summary-sharing q4 demo and planner timings

---
 crates/devtools/src/bin/dag_export.rs |  36 ++
 tools/dag-viewer/dag.example.json     | 695 +++++++++++++++++++++++++-
 tools/dag-viewer/planner-ui.js        |  10 +
 3 files changed, 738 insertions(+), 3 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 86620df4..834301a1 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -51,6 +51,7 @@
 
 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};
@@ -304,6 +305,7 @@ 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…");
     }
@@ -362,6 +364,12 @@ fn run_post_asap_with_progress(
         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 ---------------
     //
@@ -381,6 +389,7 @@ fn run_post_asap_with_progress(
     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)?;
@@ -474,6 +483,12 @@ fn run_post_asap_with_progress(
             );
         }
     }
+    if progress {
+        eprintln!(
+            "[4/4] Post-ASAP DAG generation done in {:.2} ms",
+            post_started.elapsed().as_secs_f64() * 1000.0
+        );
+    }
 
     PostAsapResults {
         replacements,
@@ -489,6 +504,7 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
 #[tokio::main]
 async fn main() {
     let (entries, accuracy, post_asap, progress) = parse_args();
+    let planner_started = Instant::now();
     if entries.is_empty() {
         eprintln!(
             "usage: dag_export --sql \"<query>\" [--name <label>] [--epsilon <f64>] [--post-asap] ..."
@@ -497,6 +513,7 @@ async fn main() {
     }
 
     let mut lowered_queries = Vec::new();
+    let lowering_started = Instant::now();
     if progress {
         eprintln!("[1/4] Parsing and lowering SQL/PromQL queries…");
     }
@@ -514,7 +531,14 @@ 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…");
     }
@@ -545,6 +569,12 @@ 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);
@@ -561,6 +591,12 @@ async fn main() {
     }
 
     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());
 }
 
diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index 1b306b8a..d3de388b 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -1535,7 +1535,7 @@
             "children": [],
             "hash": 2606922452740434172,
             "decision": {
-              "id": 3,
+              "id": 4,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1581,7 +1581,7 @@
               0
             ],
             "decision": {
-              "id": 3,
+              "id": 4,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1685,7 +1685,7 @@
               0
             ],
             "decision": {
-              "id": 4,
+              "id": 5,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "count realizes as an exact Count accumulator",
               "rank": 0,
@@ -2479,6 +2479,695 @@
         ],
         "root": 4
       }
+    },
+    {
+      "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": [],
+            "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
+          }
+        ],
+        "root": 4
+      },
+      "replacements": [
+        {
+          "decision_id": 2,
+          "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": [],
+            "hash": 16569634401303792668,
+            "decision": {
+              "id": 2,
+              "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
+            ],
+            "hash": 12007712336004404578,
+            "decision": {
+              "id": 2,
+              "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
+            ],
+            "decision": {
+              "id": 2,
+              "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
+            ],
+            "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
+          }
+        ],
+        "root": 4
+      }
     }
   ]
 }
diff --git a/tools/dag-viewer/planner-ui.js b/tools/dag-viewer/planner-ui.js
index 002edcb3..d265fd98 100644
--- a/tools/dag-viewer/planner-ui.js
+++ b/tools/dag-viewer/planner-ui.js
@@ -46,3 +46,13 @@ document.getElementById('plannerRun').addEventListener('click', async () => {
 
 addPlannerRow({ name: 'count_by_service' });
 addPlannerRow({ name: 'avg_latency', 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: 'q4',
+  language: 'promql',
+  text: 'topk(10, rate(http_requests_total[5m]))',
+});

From c8c7e8f6daedfee401bce150a5d24fa41e2cb3a6 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 06:44:49 -0600
Subject: [PATCH 17/27] feat: reuse larger top-k results and improve schema
 inspection

---
 crates/asap-aware-mapping/src/lib.rs         |   2 +
 crates/asap-aware-mapping/src/replacement.rs |  18 +
 crates/asap-aware-mapping/src/topk_reuse.rs  | 168 ++++++
 crates/devtools/src/bin/dag_export.rs        | 117 ++++
 crates/types/src/dag_export.rs               |   7 +
 tools/dag-viewer/README.md                   |  15 +-
 tools/dag-viewer/dag.example.json            | 574 ++++++++++++++++++-
 tools/dag-viewer/generate-sample.sh          |   8 +-
 tools/dag-viewer/index.html                  |  24 +-
 tools/dag-viewer/viewer.js                   | 115 +++-
 10 files changed, 991 insertions(+), 57 deletions(-)
 create mode 100644 crates/asap-aware-mapping/src/topk_reuse.rs

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 a4aa34be..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
@@ -2549,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 {
@@ -2604,6 +2613,15 @@ fn search_cse_workload_with<'s, Id>(
                     },
                 ));
             }
+            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 {
                 if let Replacement::Rewrite(rc) = &candidate.replacement {
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 834301a1..8bb3cfa4 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -213,6 +213,10 @@ fn decision_rationale(winner: &Winner<'_>) -> 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
@@ -293,6 +297,48 @@ struct PostAsapResults {
     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
@@ -590,6 +636,18 @@ async fn main() {
         }
     }
 
+    {
+        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!(
@@ -757,6 +815,65 @@ mod tests {
         }
     }
 
+    #[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);
+    }
+
     /// 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
diff --git a/crates/types/src/dag_export.rs b/crates/types/src/dag_export.rs
index 2429ff0b..252d319a 100644
--- a/crates/types/src/dag_export.rs
+++ b/crates/types/src/dag_export.rs
@@ -68,6 +68,11 @@ pub struct DagNode {
     /// 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
@@ -651,6 +656,7 @@ fn push_node(
             .ok()
             .and_then(|schema| serde_json::to_value(schema).ok()),
         children,
+        workload_node_id: None,
         hash,
         source_expr: Some(expr.clone()),
         source_ptr: Some(expr as *const QueryExpr as usize),
@@ -685,6 +691,7 @@ fn push_summary_originated_node(
         detail,
         schema: None,
         children,
+        workload_node_id: None,
         hash: None,
         source_expr: None,
         source_ptr: None,
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index ef824dd8..7be1a372 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -9,9 +9,10 @@ The viewer has one visualization mode: **Pre/Post-ASAP**.
 - 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.
-- **Show edge schemas** optionally labels each data-flow edge with the source
-  node's output columns and types. It is off by default to keep large DAGs
-  readable.
+- 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.
 
 There are no separate Single, Compare, or Union modes.
 
@@ -76,10 +77,10 @@ a selected replacement directly contains:
 }
 ```
 
-The viewer reads this explicit metadata. It never guesses a strategy from a
-node label, hash, or client-side signature. Union signatures are used only to
-collapse structurally identical visualization nodes; they do not infer
-planner decisions.
+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.
 
 Node boxes use concrete IR fields: aggregate measures/grouping, sort keys,
 filter predicates, projections, sources, summary families, and readout
diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index d3de388b..0c3e2e70 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -92,6 +92,7 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 0,
             "hash": 2606922452740434172
           },
           {
@@ -143,6 +144,7 @@
             "children": [
               0
             ],
+            "workload_node_id": 1,
             "hash": 12396162568747900801,
             "notes": [
               {
@@ -198,6 +200,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 2,
             "hash": 17063396757587155626
           }
         ],
@@ -586,6 +589,7 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 0,
             "hash": 2606922452740434172,
             "decision": {
               "id": 0,
@@ -628,6 +632,7 @@
             "children": [
               0
             ],
+            "workload_node_id": 1,
             "decision": {
               "id": 0,
               "strategy": "SketchAlgorithmStrategy",
@@ -662,6 +667,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 2,
             "decision": {
               "id": 0,
               "strategy": "SketchAlgorithmStrategy",
@@ -718,6 +724,7 @@
             "children": [
               2
             ],
+            "workload_node_id": 3,
             "hash": 17063396757587155626
           }
         ],
@@ -816,6 +823,7 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 0,
             "hash": 2606922452740434172
           },
           {
@@ -865,6 +873,7 @@
             "children": [
               0
             ],
+            "workload_node_id": 3,
             "hash": 5109904469838189862
           },
           {
@@ -914,6 +923,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 4,
             "hash": 5277207484379927121
           }
         ],
@@ -1533,9 +1543,10 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 0,
             "hash": 2606922452740434172,
             "decision": {
-              "id": 4,
+              "id": 5,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1580,8 +1591,9 @@
             "children": [
               0
             ],
+            "workload_node_id": 4,
             "decision": {
-              "id": 4,
+              "id": 5,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1642,6 +1654,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 5,
             "hash": 11401885529025699918,
             "decision": {
               "id": 1,
@@ -1684,8 +1697,9 @@
             "children": [
               0
             ],
+            "workload_node_id": 6,
             "decision": {
-              "id": 5,
+              "id": 6,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "count realizes as an exact Count accumulator",
               "rank": 0,
@@ -1728,6 +1742,7 @@
               2,
               3
             ],
+            "workload_node_id": 7,
             "hash": 16391872732257280252,
             "decision": {
               "id": 1,
@@ -1785,6 +1800,7 @@
             "children": [
               4
             ],
+            "workload_node_id": 8,
             "hash": 5277207484379927121
           }
         ],
@@ -1847,6 +1863,7 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 5,
             "hash": 16569634401303792668
           },
           {
@@ -1881,6 +1898,7 @@
             "children": [
               0
             ],
+            "workload_node_id": 6,
             "hash": 12007712336004404578
           },
           {
@@ -1921,6 +1939,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 7,
             "hash": 12607242477503010192
           },
           {
@@ -1961,6 +1980,7 @@
             "children": [
               2
             ],
+            "workload_node_id": 8,
             "hash": 3760917937445997010
           },
           {
@@ -1993,6 +2013,7 @@
             "children": [
               3
             ],
+            "workload_node_id": 9,
             "hash": 7672123412300577486
           }
         ],
@@ -2000,7 +2021,7 @@
       },
       "replacements": [
         {
-          "decision_id": 2,
+          "decision_id": 3,
           "target_pre_id": 2,
           "strategy": "SketchAlgorithmStrategy",
           "rationale": "Rate realizes as an exact Rate accumulator",
@@ -2260,6 +2281,457 @@
               "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": {
@@ -2315,9 +2787,10 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 9,
             "hash": 16569634401303792668,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -2357,9 +2830,10 @@
             "children": [
               0
             ],
+            "workload_node_id": 10,
             "hash": 12007712336004404578,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -2395,8 +2869,9 @@
             "children": [
               1
             ],
+            "workload_node_id": 11,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -2442,11 +2917,61 @@
             "children": [
               2
             ],
-            "hash": 3760917937445997010
+            "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,
@@ -2472,12 +2997,21 @@
               "unique_keys": []
             },
             "children": [
-              3
+              4
             ],
-            "hash": 7672123412300577486
+            "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": 4
+        "root": 5
       }
     },
     {
@@ -2536,6 +3070,7 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 5,
             "hash": 16569634401303792668
           },
           {
@@ -2570,6 +3105,7 @@
             "children": [
               0
             ],
+            "workload_node_id": 6,
             "hash": 12007712336004404578
           },
           {
@@ -2610,6 +3146,7 @@
             "children": [
               1
             ],
+            "workload_node_id": 7,
             "hash": 12607242477503010192
           },
           {
@@ -2650,6 +3187,7 @@
             "children": [
               2
             ],
+            "workload_node_id": 8,
             "hash": 3760917937445997010
           },
           {
@@ -2682,6 +3220,7 @@
             "children": [
               3
             ],
+            "workload_node_id": 10,
             "hash": 10822644126224715622
           }
         ],
@@ -2689,7 +3228,7 @@
       },
       "replacements": [
         {
-          "decision_id": 2,
+          "decision_id": 3,
           "target_pre_id": 2,
           "strategy": "SketchAlgorithmStrategy",
           "rationale": "Rate realizes as an exact Rate accumulator",
@@ -3004,9 +3543,10 @@
               "unique_keys": []
             },
             "children": [],
+            "workload_node_id": 9,
             "hash": 16569634401303792668,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -3046,9 +3586,10 @@
             "children": [
               0
             ],
+            "workload_node_id": 10,
             "hash": 12007712336004404578,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -3084,8 +3625,9 @@
             "children": [
               1
             ],
+            "workload_node_id": 11,
             "decision": {
-              "id": 2,
+              "id": 3,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Rate realizes as an exact Rate accumulator",
               "rank": 0,
@@ -3131,6 +3673,7 @@
             "children": [
               2
             ],
+            "workload_node_id": 12,
             "hash": 3760917937445997010
           },
           {
@@ -3163,6 +3706,7 @@
             "children": [
               3
             ],
+            "workload_node_id": 13,
             "hash": 10822644126224715622
           }
         ],
diff --git a/tools/dag-viewer/generate-sample.sh b/tools/dag-viewer/generate-sample.sh
index 7032fcc5..b185eb6a 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,12 @@ 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 \
+  > 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 59ff9cb1..35449189 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -256,12 +256,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);
@@ -378,10 +392,7 @@ <h1>ASAP query DAG viewer</h1>
     <input id="highlightToggle" type="checkbox" checked />
     Highlight shared subtrees
   </label>
-  <label class="toggle">
-    <input id="schemaToggle" type="checkbox" />
-    Show edge schemas
-  </label>
+  <span class="proxyNote">Click an edge to inspect its schema</span>
 </header>
 
 <div id="plannerPanel">
@@ -418,6 +429,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>
@@ -427,6 +439,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>
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 0ae09ca6..83a426e5 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -25,7 +25,6 @@ let queries = [];
 let activeIndex = -1;
 let cy = null;
 let highlightOn = true;
-let showEdgeSchemas = false;
 let zoom = 1;
 // 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.
@@ -35,7 +34,6 @@ const dropzone = document.getElementById('dropzone');
 const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
-const schemaToggle = document.getElementById('schemaToggle');
 const tabsEl = document.getElementById('tabs');
 const baPickerEl = document.getElementById('baPicker');
 const cyOuterEl = document.getElementById('cyOuter');
@@ -43,6 +41,7 @@ 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');
@@ -67,9 +66,22 @@ highlightToggle.addEventListener('change', () => {
   highlightOn = highlightToggle.checked;
   applyHighlighting();
 });
-schemaToggle.addEventListener('change', () => {
-  showEdgeSchemas = schemaToggle.checked;
-  applyEdgeSchemaVisibility();
+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 loadFiles(fileList) {
@@ -146,12 +158,14 @@ function render() {
     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();
 
@@ -410,6 +424,7 @@ function finalizeGraphInteractions() {
     const query = queries.find((q) => q.name === n.data('queryName'));
     showDetail(n.data('node'), query);
   });
+  cy.on('tap', 'edge', (evt) => showEdgeDetail(evt.target));
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
 }
 
@@ -470,7 +485,6 @@ function renderGraph(query) {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
-  applyEdgeSchemaVisibility();
   clearDetail();
   zoom = 1;
   applyZoom();
@@ -659,7 +673,6 @@ function renderUnion(chosen) {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
-  applyEdgeSchemaVisibility();
   clearDetail();
   fitAndSyncZoom();
 }
@@ -703,41 +716,33 @@ function renderPrePostAsap() {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
-  applyEdgeSchemaVisibility();
   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 signatures = new Map();
   const owners = new Map();
 
   chosen.forEach((qIdx) => {
     const query = queries[qIdx];
     const graph = graphFor(query);
-    const byId = new Map(graph.nodes.map((node) => [node.id, node]));
-    const perQuery = new Map();
-    const signatureFor = (node) => {
-      if (perQuery.has(node.id)) return perQuery.get(node.id);
-      const childSignatures = node.children.map((id) => signatureFor(byId.get(id)));
-      const signature = JSON.stringify([node.kind, node.detail, childSignatures]);
-      perQuery.set(node.id, signature);
-      if (!owners.has(signature)) owners.set(signature, new Set());
-      owners.get(signature).add(query.name);
-      return signature;
-    };
-    graph.nodes.forEach(signatureFor);
-    signatures.set(qIdx, perQuery);
+    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, signature) => {
-    if (queryNames.size > 1) sharedIds.set(signature, `${laneId}-shared-${nextSharedId++}`);
+  owners.forEach((queryNames, workloadNodeId) => {
+    if (queryNames.size > 1) sharedIds.set(workloadNodeId, `${laneId}-shared-${nextSharedId++}`);
   });
-  const keyFor = (qIdx, node) => sharedIds.get(signatures.get(qIdx).get(node.id)) || `${laneId}-q${qIdx}-${node.id}`;
+  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 = [
@@ -856,9 +861,46 @@ function formatSchema(schema) {
   }).join(' · ');
 }
 
-function applyEdgeSchemaVisibility() {
-  if (!cy) return;
-  cy.edges().toggleClass('showSchema', showEdgeSchemas);
+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.`;
+  }
+}
+
+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>
+  `;
 }
 
 function renderBaScopeSummary(selected) {
@@ -928,6 +970,7 @@ function showBeforeAfterDetail(data) {
 
 function renderSourcePanel(qs) {
   const sourceBox = document.getElementById('sourceBox');
+  renderTableSchemas(qs);
   if (qs.length === 0) {
     sourceBox.textContent = 'Select queries above.';
     sourceBox.classList.add('placeholder');
@@ -949,6 +992,22 @@ function renderSourcePanel(qs) {
   sourceBox.classList.remove('placeholder');
 }
 
+function renderTableSchemas(qs) {
+  const box = document.getElementById('tableSchemaBox');
+  const seen = new Set();
+  const blocks = [];
+  qs.forEach((query) => {
+    (query.graph?.nodes || []).filter((node) => node.kind === 'Scan').forEach((node) => {
+      const key = JSON.stringify([node.detail, node.schema]);
+      if (seen.has(key)) return;
+      seen.add(key);
+      blocks.push(`${query.name} · ${node.label}\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 selected = getParticipants().map((i) => queries[i]);

From d46c7f859857b82356fd7237bdcc37222aaedd19 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 06:52:48 -0600
Subject: [PATCH 18/27] feat: add editable input schemas and join CSE demo

---
 crates/devtools/src/bin/dag_export.rs |  118 ++-
 tools/dag-viewer/README.md            |    9 +
 tools/dag-viewer/dag.example.json     | 1261 ++++++++++++++++++++++++-
 tools/dag-viewer/generate-sample.sh   |    1 +
 tools/dag-viewer/index.html           |   22 +-
 tools/dag-viewer/planner-ui.js        |   83 +-
 tools/dag-viewer/server.py            |   24 +
 tools/dag-viewer/viewer.js            |   10 +-
 8 files changed, 1508 insertions(+), 20 deletions(-)

diff --git a/crates/devtools/src/bin/dag_export.rs b/crates/devtools/src/bin/dag_export.rs
index 8bb3cfa4..3dd7dde5 100644
--- a/crates/devtools/src/bin/dag_export.rs
+++ b/crates/devtools/src/bin/dag_export.rs
@@ -72,7 +72,7 @@ enum Lang {
     PromQl,
 }
 
-fn catalog() -> SqlCatalog {
+fn default_catalog() -> SqlCatalog {
     SqlCatalog::new()
         .with_table(
             "metrics",
@@ -97,16 +97,70 @@ fn catalog() -> SqlCatalog {
         )
 }
 
+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>` and one optional global `--post-asap` flag. `--name` is
 /// optional and applies to the immediately preceding `--sql`/`--promql`.
-fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool, bool) {
+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 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)>) {
@@ -147,11 +201,20 @@ fn parse_args() -> (Vec<(String, Lang, String)>, AccuracyTarget, bool, bool) {
             "--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, post_asap, progress)
+    ParsedArgs {
+        entries,
+        accuracy,
+        post_asap,
+        progress,
+        table_schemas,
+    }
 }
 
 /// Attach workload-wide replacement explanations to their exact graph nodes.
@@ -549,7 +612,14 @@ fn run_post_asap(lowered_queries: &[(String, String, QueryExpr)]) -> PostAsapRes
 
 #[tokio::main]
 async fn main() {
-    let (entries, accuracy, post_asap, progress) = 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!(
@@ -565,7 +635,7 @@ async fn main() {
     }
     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()),
@@ -716,7 +786,7 @@ mod tests {
     /// other `--post-asap` output `main` wires up.
     #[tokio::test]
     async fn post_asap_run_produces_both_summary_and_rewrite_replacements() {
-        let cat = catalog();
+        let cat = default_catalog();
         let sketch_query = lower_sql(
             "SELECT approx_percentile_cont(latency, 0.95) FROM metrics",
             &cat,
@@ -874,6 +944,40 @@ mod tests {
         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
@@ -893,7 +997,7 @@ mod tests {
     /// stack.
     #[tokio::test]
     async fn post_asap_does_not_recurse_forever_on_a_trivial_keep_pre_asap_winner() {
-        let cat = catalog();
+        let cat = default_catalog();
         let stddev_query = lower_sql(
             "SELECT STDDEV_POP(latency) FROM metrics",
             &cat,
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 7be1a372..baaf5157 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -33,6 +33,15 @@ runs the real pipeline:
 3. ASAP-aware mapping
 4. post-ASAP DAG generation
 
+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 `name:type` (`!` means NOT NULL) and an optional time-index
+column. 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.
+
 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.
diff --git a/tools/dag-viewer/dag.example.json b/tools/dag-viewer/dag.example.json
index 0c3e2e70..401aa0a8 100644
--- a/tools/dag-viewer/dag.example.json
+++ b/tools/dag-viewer/dag.example.json
@@ -1546,7 +1546,7 @@
             "workload_node_id": 0,
             "hash": 2606922452740434172,
             "decision": {
-              "id": 5,
+              "id": 6,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1593,7 +1593,7 @@
             ],
             "workload_node_id": 4,
             "decision": {
-              "id": 5,
+              "id": 6,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "Sum { col: Some(3) } realizes as an exact Sum accumulator",
               "rank": 0,
@@ -1699,7 +1699,7 @@
             ],
             "workload_node_id": 6,
             "decision": {
-              "id": 6,
+              "id": 7,
               "strategy": "SketchAlgorithmStrategy",
               "rationale": "count realizes as an exact Count accumulator",
               "rank": 0,
@@ -3712,6 +3712,1261 @@
         ],
         "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 b185eb6a..e916cba5 100755
--- a/tools/dag-viewer/generate-sample.sh
+++ b/tools/dag-viewer/generate-sample.sh
@@ -16,6 +16,7 @@ cargo run -p asap-devtools --bin dag_export -- \
   --sql "SELECT service, AVG(latency) FROM metrics GROUP BY service" --name q2 \
   --promql "topk(5, rate(http_requests_total[5m]))" --name q3 \
   --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.example.json"
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 35449189..de846225 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -118,8 +118,9 @@
   }
   #plannerPanel.visible { display: block; }
   #plannerRows { display: flex; flex-direction: column; gap: 0.45rem; }
-  .plannerRow { display: grid; grid-template-columns: auto 140px 90px minmax(280px, 1fr) auto; gap: 0.45rem; align-items: center; }
-  .plannerRow input, .plannerRow select, .plannerRow textarea, #plannerEpsilon {
+  .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);
@@ -128,6 +129,15 @@
     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; }
   #baPicker {
@@ -396,6 +406,14 @@ <h1>ASAP query DAG viewer</h1>
 </header>
 
 <div id="plannerPanel">
+  <div class="schemaEditor">
+    <div class="schemaEditorHead">
+      <h2>Input table schemas</h2>
+      <button class="btn" id="schemaAdd" type="button">Add schema</button>
+      <span class="schemaHint">Columns: name:type! where ! means 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>
diff --git a/tools/dag-viewer/planner-ui.js b/tools/dag-viewer/planner-ui.js
index d265fd98..024f4af1 100644
--- a/tools/dag-viewer/planner-ui.js
+++ b/tools/dag-viewer/planner-ui.js
@@ -1,6 +1,60 @@
 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="2" aria-label="Columns">${escapeHtml(schema.columns || 'id:int64!, value: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(',').map((raw) => raw.trim()).filter(Boolean).map((raw) => {
+    const match = raw.match(/^([^:]+):([a-zA-Z0-9]+)(!)?$/);
+    if (!match) throw new Error(`Invalid column ${raw}; use name:type or name:type!`);
+    return { name: match[1].trim(), type: match[2], nullable: !match[3] };
+  });
+  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');
@@ -9,20 +63,29 @@ function addPlannerRow(query = {}) {
     <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…';
@@ -31,7 +94,13 @@ document.getElementById('plannerRun').addEventListener('click', async () => {
     const response = await fetch('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/api/plan', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ queries, epsilon: Number(document.getElementById('plannerEpsilon').value) }),
+      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}`);
@@ -44,13 +113,21 @@ document.getElementById('plannerRun').addEventListener('click', async () => {
   }
 });
 
-addPlannerRow({ name: 'count_by_service' });
-addPlannerRow({ name: 'avg_latency', text: 'SELECT service, AVG(latency) FROM metrics GROUP BY service' });
+addSchemaRow({ name: 'metrics', columns: 'ts:timestamp!, service:utf8!, region:utf8!, latency:float64!, bytes:int64!', timeIndex: 'ts' });
+addSchemaRow({ name: 'hosts', columns: 'service:utf8!, region:utf8!' });
+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',
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index 81c1eba8..983d56dd 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -35,7 +35,25 @@ def plan_workload(payload: dict) -> dict:
     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")
@@ -46,6 +64,12 @@ def plan_workload(payload: dict) -> dict:
             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)
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 83a426e5..230d8a41 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -994,16 +994,16 @@ function renderSourcePanel(qs) {
 
 function renderTableSchemas(qs) {
   const box = document.getElementById('tableSchemaBox');
-  const seen = new Set();
-  const blocks = [];
+  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 (seen.has(key)) return;
-      seen.add(key);
-      blocks.push(`${query.name} · ${node.label}\n${formatSchema(node.schema) || '(schema unavailable)'}`);
+      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);
 }

From f40119fce74014671a127866fc6cfe575507e932 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 07:22:53 -0600
Subject: [PATCH 19/27] style: make table schemas easier to read

---
 tools/dag-viewer/README.md     |  5 +++--
 tools/dag-viewer/index.html    |  4 ++--
 tools/dag-viewer/planner-ui.js | 27 ++++++++++++++++++++-------
 tools/dag-viewer/viewer.js     | 16 +++++++++++++---
 4 files changed, 38 insertions(+), 14 deletions(-)

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index baaf5157..8cd22c1a 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -35,8 +35,9 @@ runs the real pipeline:
 
 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 `name:type` (`!` means NOT NULL) and an optional time-index
-column. These definitions are passed to `dag_export` and used by the SQL
+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
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index de846225..4379cc58 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -409,8 +409,8 @@ <h1>ASAP query DAG viewer</h1>
   <div class="schemaEditor">
     <div class="schemaEditorHead">
       <h2>Input table schemas</h2>
-      <button class="btn" id="schemaAdd" type="button">Add schema</button>
-      <span class="schemaHint">Columns: name:type! where ! means NOT NULL. PromQL schemas are inferred from metric usage.</span>
+      <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>
diff --git a/tools/dag-viewer/planner-ui.js b/tools/dag-viewer/planner-ui.js
index 024f4af1..21651f61 100644
--- a/tools/dag-viewer/planner-ui.js
+++ b/tools/dag-viewer/planner-ui.js
@@ -9,7 +9,7 @@ function addSchemaRow(schema = {}) {
   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="2" aria-label="Columns">${escapeHtml(schema.columns || 'id:int64!, value:float64')}</textarea>
+    <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', () => {
@@ -41,10 +41,16 @@ function refreshSchemaSelectors() {
 }
 
 function parseSchemaRow(row) {
-  const columns = row.querySelector('.schemaColumns').value.split(',').map((raw) => raw.trim()).filter(Boolean).map((raw) => {
-    const match = raw.match(/^([^:]+):([a-zA-Z0-9]+)(!)?$/);
-    if (!match) throw new Error(`Invalid column ${raw}; use name:type or name:type!`);
-    return { name: match[1].trim(), type: match[2], nullable: !match[3] };
+  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;
@@ -113,8 +119,15 @@ document.getElementById('plannerRun').addEventListener('click', async () => {
   }
 });
 
-addSchemaRow({ name: 'metrics', columns: 'ts:timestamp!, service:utf8!, region:utf8!, latency:float64!, bytes:int64!', timeIndex: 'ts' });
-addSchemaRow({ name: 'hosts', columns: 'service:utf8!, region:utf8!' });
+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({
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 230d8a41..6618a208 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -852,13 +852,23 @@ 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';
-  return fields.map((field) => {
+  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}: ${dtype}${field && field.nullable ? '?' : ''}`;
-  }).join(' · ');
+    return {
+      name: String(name),
+      dtype: String(dtype).toUpperCase(),
+      nullable: field && field.nullable ? 'NULL' : 'NOT NULL',
+      timeIndex: schema.time_index === index,
+    };
+  });
+  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');
 }
 
 function schemaDerivation(target) {

From d2862a1b60d911a3ac8fd481d4cd877780991133 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 07:28:51 -0600
Subject: [PATCH 20/27] style: compact DAG labels and preload node details

---
 tools/dag-viewer/render.py      | 34 ++++++++++++++++++---------------
 tools/dag-viewer/server.py      | 10 ++++++++++
 tools/dag-viewer/test_render.py |  7 +++----
 tools/dag-viewer/viewer.js      | 14 +++++++++++---
 4 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index eecd2374..c77aba10 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -98,23 +98,27 @@ def _column(value: object, input_schema: object = None) -> str:
     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 _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"
@@ -157,7 +161,7 @@ def _semantic_label(node: dict, input_schema: object = None) -> str:
             lines.append(f"where: {_compact(detail['predicates'])}")
     elif kind == "Aggregate":
         measures = detail.get("measures") or []
-        lines.extend(f"compute: {_measure(measure)}" for measure in measures)
+        lines.extend(f"measure: {_measure(measure, input_schema)}" for measure in measures)
         grouping = _grouping(detail.get("reduction"), input_schema)
         if grouping:
             lines.append(grouping)
@@ -168,13 +172,13 @@ def _semantic_label(node: dict, input_schema: object = None) -> 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":
@@ -220,7 +224,7 @@ def _semantic_label(node: dict, input_schema: object = None) -> str:
             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:
diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index 983d56dd..552abb81 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -134,6 +134,16 @@ def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
         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.
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index dee3f030..b7994694 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -178,7 +178,7 @@ def test_aggregate_names_measure_input_and_grouping(self):
         }
         self.assertEqual(
             _semantic_label(node),
-            "Aggregate\ncompute: quantile(col[6], q=0.95)\ngroup by col[1]",
+            "Aggregate\nmeasure: quantile(col[6], q=0.95)\ngroup by col[1]",
         )
 
     def test_summary_aggregate_names_reduction_as_group_by(self):
@@ -193,8 +193,7 @@ def test_summary_aggregate_names_reduction_as_group_by(self):
         }
         self.assertEqual(
             _semantic_label(node),
-            "SummaryAgg\nfamily: Sketch(Cms)\ninput: SampleValue\n"
-            "group by col[1]\nsummary layout: PerSubpopulationInstance",
+            "SummaryAgg\nfamily: Sketch(Cms)\ninput: SampleValue\n… +2 more",
         )
 
     def test_sort_names_expression_direction_and_null_order(self):
@@ -232,7 +231,7 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
             query["replacements"][0]["before"]["nodes"][0]["label"],
             query["replacements"][0]["after"]["graph"]["nodes"][0]["label"],
         ]
-        self.assertEqual(labels, ["Aggregate\ncompute: avg(col[3])"] * 4)
+        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 4)
 
     def test_cse_before_after_makes_reuse_decision_visible(self):
         node = {
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 6618a208..d03541cc 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -716,7 +716,15 @@ function renderPrePostAsap() {
   buildCy(elements);
   finalizeGraphInteractions();
   applyHighlighting();
-  clearDetail();
+  const initial = cy.nodes().filter((node) =>
+    !node.data('isLane') && node.data('stage') === 'pre' && node.data('root')
+  ).first();
+  if (initial && initial.length) {
+    initial.select();
+    showBeforeAfterDetail(initial.data());
+  } else {
+    clearDetail();
+  }
   fitAndSyncZoom();
 }
 
@@ -1211,8 +1219,8 @@ if (embeddedEl) {
   // Do not silently prefer a leftover scratch dag.json: it may predate
   // post_graph and make Before/After appear broken. Users can load scratch
   // exports explicitly with the picker or run them through Query planner.
-  fetch('dag.example.json', { cache: 'no-store' })
-    .then((r) => (r.ok ? r.json() : null))
+  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);

From 999abc0f026d9e95cdba5c1bc0ace0e8547ddb6f Mon Sep 17 00:00:00 2001
From: Zeying Zhu <50204836+zzylol@users.noreply.github.com>
Date: Wed, 26 Aug 2026 10:01:25 -0400
Subject: [PATCH 21/27] fix(devtools): clean up Pre/Post-ASAP DAG viewer (#284)

---
 tools/dag-viewer/README.md      |   4 +-
 tools/dag-viewer/index.html     |  29 +-
 tools/dag-viewer/node-style.js  | 129 +--------
 tools/dag-viewer/render.py      |  20 --
 tools/dag-viewer/test_render.py |  56 +---
 tools/dag-viewer/viewer.js      | 497 ++++----------------------------
 6 files changed, 92 insertions(+), 643 deletions(-)

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 8cd22c1a..1c3fd694 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -4,8 +4,8 @@ The viewer has one visualization mode: **Pre/Post-ASAP**.
 
 - 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. Structurally identical nodes and edges are
-  collapsed while query roots and ownership are retained.
+  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.
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 4379cc58..cb1a1d01 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -140,7 +140,7 @@
   .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; }
-  #baPicker {
+  #scopePicker {
     display: none;
     flex-wrap: wrap;
     gap: 0.6rem 1.2rem;
@@ -148,15 +148,15 @@
     border-bottom: 1px solid var(--border);
     background: var(--panel);
   }
-  #baPicker.visible { display: flex; }
-  .baGroup { display: flex; flex-direction: column; gap: 0.3rem; min-width: 220px; }
-  .baGroupLabel {
+  #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);
   }
-  .baRow {
+  .scopeRow {
     display: flex;
     align-items: center;
     gap: 0.5rem;
@@ -165,29 +165,16 @@
     border-radius: 8px;
     background: var(--panel2);
     color: var(--fg);
-    cursor: pointer;
     font: inherit;
     font-size: 0.78rem;
     text-align: left;
   }
-  .baRow:hover { border-color: var(--accent); }
-  .baRow:disabled { opacity: 0.55; cursor: not-allowed; }
-  .baRow:disabled:hover { border-color: var(--border); }
-  .baRow.active {
+  .scopeRow.active {
     border-color: var(--accent);
     background: var(--bg);
     box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 15%, transparent);
   }
-  .baRow .baWinner {
-    font-size: 0.66rem;
-    font-weight: 700;
-    color: var(--accent);
-    border: 1px solid var(--accent);
-    border-radius: 999px;
-    padding: 0.05rem 0.4rem;
-    flex-shrink: 0;
-  }
-  .baRow .baMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
+  .scopeRow .scopeMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
   .proxyNote {
     font-size: 0.72rem;
     color: var(--muted);
@@ -424,7 +411,7 @@ <h2>Input table schemas</h2>
 </div>
 
 <div id="tabs"></div>
-<div id="baPicker"></div>
+<div id="scopePicker"></div>
 
 <div id="main">
   <div id="empty">
diff --git a/tools/dag-viewer/node-style.js b/tools/dag-viewer/node-style.js
index ca6c31d1..e688a80b 100644
--- a/tools/dag-viewer/node-style.js
+++ b/tools/dag-viewer/node-style.js
@@ -1,13 +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 only ever appear in Before/After mode's After lane when
-// an entry's `after.kind === "Summary"` — see the `summary` category below.
+// 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 = {
@@ -36,7 +35,7 @@ const KIND_CATEGORY = {
   Sort: 'sort',
   Limit: 'sort',
   LetBinding: 'bind',
-  // Post-ASAP SummaryDagNode kinds (Before/After mode's After lane only).
+  // Post-ASAP SummaryDagNode kinds (post-ASAP lane only).
   KeepPreAsap: 'summary',
   SummaryAgg: 'summary',
   SummaryJoin: 'summary',
@@ -46,47 +45,6 @@ const KIND_CATEGORY = {
   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: stacked layers, for the post-ASAP `summary` category — a materialized
-  // structure (a sketch, a rollup, a merged/estimated join) rather than a
-  // pre-ASAP relational operator.
-  summary: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="9" y="7" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="19" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="31" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
-};
-
-// KeepPreAsap-only: a dashed box with a through-arrow, standing in for
-// "unchanged pre-ASAP content carried through as-is" — see the `summary`
-// CATEGORIES entry and buildCyStyle's `node[kind = "KeepPreAsap"]` override
-// in viewer.js for why this doesn't just reuse ICONS.summary's stroke color.
-const KEEP_PRE_ASAP_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="7" y="14" width="34" height="20" rx="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-dasharray="4 3"/><path d="M13 24h22m0 0l-6-6m6 6l-6 6" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
-
-function keepPreAsapIconDataUri() {
-  const muted = getComputedStyle(document.documentElement).getPropertyValue('--muted').trim() || '#6b7280';
-  return svgDataUri(KEEP_PRE_ASAP_ICON(muted));
-}
-
-// 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: {
@@ -143,7 +101,7 @@ const CATEGORIES = {
     light: { bg: '#fff5ea', border: '#b45309' },
     dark: { bg: '#3a2408', border: '#fb923c' },
   },
-  // Post-ASAP only (Before/After mode's After lane): every other category
+  // 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
@@ -157,7 +115,7 @@ const CATEGORIES = {
   // through) rather than a different concept.
   summary: {
     label: 'Summary',
-    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures (Before/After mode only)',
+    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures',
     light: { bg: '#f1f2f4', border: '#4b5563' },
     dark: { bg: '#20242b', border: '#9ca3af' },
   },
@@ -170,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';
 }
@@ -208,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/render.py b/tools/dag-viewer/render.py
index c77aba10..2059597f 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -246,29 +246,9 @@ def prepare_graph(graph: object) -> None:
             nested = (node.get("detail") or {}).get("pre_asap_subgraph")
             prepare_graph(nested)
 
-    def append_root_line(graph: object, line: str) -> None:
-        if not isinstance(graph, dict):
-            return
-        root_id = graph.get("root")
-        root = next((node for node in graph.get("nodes", []) if node.get("id") == root_id), None)
-        if root is not None:
-            root["label"] += f"\n{line}"
-
     for query in prepared.get("queries", []):
         prepare_graph(query.get("graph"))
         prepare_graph(query.get("post_graph"))
-        for replacement in query.get("replacements", []):
-            before = replacement.get("before")
-            after = replacement.get("after") or {}
-            after_graph = after.get("graph")
-            prepare_graph(before)
-            prepare_graph(after_graph)
-            if replacement.get("strategy") == "SharedSubtree" or replacement.get("provenance") == "CseShare":
-                rationale = str(replacement.get("rationale", ""))
-                count = re.search(r"(\d+)\s+consumers?", rationale)
-                suffix = f" ({count.group(1)} consumers)" if count else ""
-                append_root_line(before, "reuse: recomputed per consumer")
-                append_root_line(after_graph, f"reuse: shared across workload{suffix}")
     return prepared
 
 
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index b7994694..6966287e 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -213,13 +213,14 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
             "detail": {"measures": [{"kind": "avg", "col": 3}]},
             "children": [],
         }
-        graph = {"nodes": [node], "root": 0}
+        def graph():
+            return {"nodes": [dict(node)], "root": 0}
         workload = {
             "queries": [
                 {
-                    "graph": graph,
-                    "post_graph": graph,
-                    "replacements": [{"before": graph, "after": {"graph": graph}}],
+                    "graph": graph(),
+                    "post_graph": graph(),
+                    "replacements": [{"before": graph(), "after": {"graph": graph()}}],
                 }
             ]
         }
@@ -228,47 +229,20 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
         labels = [
             query["graph"]["nodes"][0]["label"],
             query["post_graph"]["nodes"][0]["label"],
-            query["replacements"][0]["before"]["nodes"][0]["label"],
-            query["replacements"][0]["after"]["graph"]["nodes"][0]["label"],
         ]
-        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 4)
+        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 2)
+        self.assertEqual(
+            query["replacements"][0]["before"]["nodes"][0]["label"],
+            "Aggregate(1 measures)",
+        )
 
-    def test_cse_before_after_makes_reuse_decision_visible(self):
-        node = {
-            "id": 0,
-            "kind": "Scan",
-            "label": "Scan(metrics)",
-            "detail": {},
-            "children": [],
-        }
+    def test_replacement_subgraphs_are_not_prepared_for_the_current_viewer(self):
         def graph():
-            return {"nodes": [dict(node)], "root": 0}
-
-        workload = {
-            "queries": [
-                {
-                    "graph": graph(),
-                    "replacements": [
-                        {
-                            "strategy": "SharedSubtree",
-                            "provenance": "CseShare",
-                            "rationale": "Scan(metrics) has 2 consumers across this workload",
-                            "before": graph(),
-                            "after": {"graph": 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"],
-            "Scan\nsource: metrics\nreuse: recomputed per consumer",
-        )
-        self.assertEqual(
-            replacement["after"]["graph"]["nodes"][0]["label"],
-            "Scan\nsource: metrics\nreuse: shared across workload (2 consumers)",
-        )
+        self.assertEqual(replacement["before"]["nodes"][0]["label"], "legacy")
+        self.assertEqual(replacement["after"]["graph"]["nodes"][0]["label"], "legacy")
 
 
 class MainCliTests(unittest.TestCase):
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index d03541cc..feca4f8c 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -35,7 +35,7 @@ const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
 const tabsEl = document.getElementById('tabs');
-const baPickerEl = document.getElementById('baPicker');
+const scopePickerEl = document.getElementById('scopePicker');
 const cyOuterEl = document.getElementById('cyOuter');
 const cyEl = document.getElementById('cy');
 const modeHintEl = document.getElementById('modeHint');
@@ -116,35 +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) {
-      // A post-ASAP-only node (e.g. mixed into a whole-query post_graph) has
-      // no corresponding QueryExpr to hash — skip rather than bucketing
-      // every such node together under the key `undefined`. `graph.nodes`
-      // (as opposed to `post_graph.nodes`) never actually contains one of
-      // these today, but this stays correct if that ever changes.
-      if (node.hash === undefined) continue;
-      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)
@@ -154,7 +125,7 @@ function getParticipants() {
 function render() {
   if (queries.length === 0) {
     tabsEl.innerHTML = '';
-    baPickerEl.classList.remove('visible');
+    scopePickerEl.classList.remove('visible');
     emptyEl.style.display = 'flex';
     cyOuterEl.style.display = 'none';
     sidepanel.style.display = 'none';
@@ -206,7 +177,6 @@ function buildCyStyle() {
     style: {
       'border-color': categoryColors(name).border,
       'background-color': categoryColors(name).bg,
-      'background-image': categoryIconDataUri(name),
     },
   }));
 
@@ -240,12 +210,9 @@ function buildCyStyle() {
       selector: 'node[category = "data"]',
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
-    ...categoryStyles.map((entry) => ({
-      ...entry,
-      style: { ...entry.style, 'background-image': 'none' },
-    })),
+    ...categoryStyles,
     {
-      // KeepPreAsap (Before/After mode's After lane only) is post-ASAP-only
+      // 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
@@ -258,17 +225,12 @@ function buildCyStyle() {
         'background-color': panelColor,
         'border-color': borderColor,
         'border-style': 'dashed',
-        'background-image': 'none',
       },
     },
     {
       selector: 'node.root',
       style: { 'border-width': 2.5 },
     },
-    {
-      selector: 'node.hasNotes',
-      style: { 'border-style': 'double', 'border-width': 3 },
-    },
     {
       selector: 'node.shared',
       style: {
@@ -279,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',
@@ -296,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',
@@ -338,29 +300,6 @@ function buildCyStyle() {
         'transition-timing-function': 'ease-in-out',
       },
     },
-    {
-      selector: 'edge.showSchema',
-      style: {
-        'label': 'data(schemaLabel)',
-      },
-    },
-    {
-      // 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;
@@ -393,36 +332,15 @@ 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) => {
-    // Before/After has a strict stage split: pre-ASAP is the unannotated IR,
-    // while post-ASAP carries explicit decision explanations.
-    if (n.data('isLane') || n.data('isBeforeAfter')) 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;
-    }
-    if (n.data('isBeforeAfter')) {
-      showBeforeAfterDetail(n.data());
-      return;
-    }
-    const query = queries.find((q) => q.name === n.data('queryName'));
-    showDetail(n.data('node'), query);
+    showPrePostDetail(n.data());
   });
   cy.on('tap', 'edge', (evt) => showEdgeDetail(evt.target));
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
@@ -448,240 +366,11 @@ function hideModeHint() {
   cyEl.style.display = 'block';
 }
 
-// ── Single-query view (default, unchanged behavior) ──────────────────────
-
-function renderGraph(query) {
-  hideModeHint();
-  viewTitleEl.textContent = query.name;
-  renderSourcePanel([query]);
-
-  const elements = [];
-  for (const node of query.graph.nodes) {
-    elements.push({
-      data: {
-        id: String(node.id),
-        label: node.label,
-        node,
-        category: categoryOf(node.kind),
-        root: node.id === query.graph.root,
-        queryName: query.name,
-      },
-    });
-  }
-  for (const node of query.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-${node.id}-${childId}`,
-          source: String(childId),
-          target: String(node.id),
-        },
-      });
-    }
-  }
-
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  zoom = 1;
-  applyZoom();
-}
-
-// ── 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}`,
-          },
-        });
-      }
-    }
-  });
-
-  buildCy(elements);
-  cy.add(buildSharedLinkEdges(chosen));
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
-}
-
-// 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;
-    });
-  }
-  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();
-
-  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}`);
-
-  const nodeEntries = new Map(); // key -> accumulator
-  const edgeKeys = new Set();
-  const elements = [];
-
-  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);
-    }
-  });
-
-  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 } });
-      }
-    }
-  });
-
-  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' : '',
-    });
-  }
-
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
-}
-
 // ── Pre/Post-ASAP: one query or two workload-union DAGs ──────────────────
 function renderPrePostAsap() {
   const chosen = getParticipants();
   const selected = chosen.map((i) => queries[i]);
-  renderBaScopeSummary(selected);
+  renderScopeSummary(selected);
   renderSourcePanel(selected);
 
   if (selected.length === 0) {
@@ -721,7 +410,7 @@ function renderPrePostAsap() {
   ).first();
   if (initial && initial.length) {
     initial.select();
-    showBeforeAfterDetail(initial.data());
+    showPrePostDetail(initial.data());
   } else {
     clearDetail();
   }
@@ -765,10 +454,13 @@ function unionStageLaneElements(stage, chosen) {
       const key = keyFor(qIdx, node);
       let entry = entries.get(key);
       if (!entry) {
-        entry = { node, query, sourceQueries: new Set(), rootFor: new Set() };
+        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));
@@ -789,10 +481,10 @@ function unionStageLaneElements(stage, chosen) {
       root: entry.rootFor.size > 0,
       rootFor: Array.from(entry.rootFor),
       sourceQueries: Array.from(entry.sourceQueries),
-      isBeforeAfter: true,
+      isPrePost: true,
       stage,
-      queryName: entry.query.name,
-      translations: translationsForNode(entry.query, entry.node, stage),
+      queryName: Array.from(entry.sourceQueries)[0],
+      translations: Array.from(entry.decisions.values()),
     },
     classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
   }));
@@ -804,13 +496,13 @@ function unionStageLaneElements(stage, chosen) {
   return elements;
 }
 
-// Builds one Compare-mode-style lane (a dashed compound parent plus its
-// nodes/edges) for Before/After mode. `nodes` is either a plain pre-ASAP
+// 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 showBeforeAfterDetail below.
+// 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]));
@@ -831,7 +523,7 @@ function laneElements(laneId, laneLabel, graph, query, stage) {
         kind: node.kind,
         category: categoryOf(node.kind),
         root: node.id === graph.root,
-        isBeforeAfter: true,
+        isPrePost: true,
         laneId,
         stage,
         queryName: query.name,
@@ -921,30 +613,32 @@ function showEdgeDetail(edge) {
   `;
 }
 
-function renderBaScopeSummary(selected) {
-  baPickerEl.classList.add('visible');
+function renderScopeSummary(selected) {
+  scopePickerEl.classList.add('visible');
   const strategies = new Set();
-  selected.forEach((q) => (q.replacements || []).filter((r) => r.rank === 0).forEach((r) => strategies.add(r.strategy)));
+  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';
-  baPickerEl.innerHTML = `<div class="baGroup"><div class="baGroupLabel">View scope</div><div class="baRow active"><span>${escapeHtml(scope)}</span><span class="baMeta">${escapeHtml(strategyText)}</span></div></div>`;
+  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>`;
 }
 
 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((r) => r.rank === 0);
+  const replacements = (query.replacements || []).filter((replacement) => replacement.rank === 0);
   if (!node.decision) return [];
-  const replacement = replacements.find((r) => r.decision_id === node.decision.id);
+  const replacement = replacements.find((entry) => entry.decision_id === node.decision.id);
   return [{
     ...node.decision,
     target_pre_id: replacement ? replacement.target_pre_id : undefined,
-    after: replacement ? replacement.after : undefined,
+    output_kind: replacement ? replacement.after?.kind : undefined,
   }];
 }
 
-function showBeforeAfterDetail(data) {
+function showPrePostDetail(data) {
   const node = data.node;
   const category = categoryOf(node.kind);
   const catColors = categoryColors(category);
@@ -966,7 +660,7 @@ function showBeforeAfterDetail(data) {
         <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.after || {}).kind || node.kind)}</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') {
@@ -1029,110 +723,36 @@ function renderTableSchemas(qs) {
 function applyHighlighting() {
   if (!cy) return;
   const selected = getParticipants().map((i) => queries[i]);
-    const ownersFor = (graphOf) => {
-      const owners = new Map();
-      selected.forEach((q) => {
-        const seen = new Set();
-        const graph = graphOf(q);
-        (graph ? graph.nodes : []).forEach((node) => {
-          if (node.hash === undefined || seen.has(node.hash)) return;
-          seen.add(node.hash);
-          if (!owners.has(node.hash)) owners.set(node.hash, new Set());
-          owners.get(node.hash).add(q.name);
-        });
+  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((q) => q.graph);
-    const postOwners = ownersFor((q) => q.post_graph);
-    cy.nodes().forEach((n) => {
-      if (n.data('isLane')) return;
-      const node = n.data('node');
-      const owners = n.data('stage') === 'post' ? postOwners : preOwners;
-      const sharedWith = node && owners.get(node.hash);
-      n.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
     });
+    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));
+  });
 }
 
 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]) => {
@@ -1143,14 +763,9 @@ 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>`);
-  }
   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>
@@ -1217,7 +832,7 @@ if (embeddedEl) {
 } else {
   // 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 Before/After appear broken. Users can load scratch
+  // 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())))

From 064f028e4dd7ce37bec2b6f1a01bb2020ee40bf5 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 08:08:08 -0600
Subject: [PATCH 22/27] fix(devtools): explain empty file URL viewer

---
 tools/dag-viewer/viewer.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index feca4f8c..75d06de1 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -837,6 +837,11 @@ if (embeddedEl) {
   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(() => {})
+    .catch((error) => {
+      console.error('tools/dag-viewer: failed to load the example workload', error);
+      emptyEl.innerHTML = window.location.protocol === 'file:'
+        ? 'This source page cannot load planner data over <code>file://</code>. From the repository root, run <code>python3 tools/dag-viewer/server.py</code>, then open <code>http://127.0.0.1:8000</code>. For a directly-openable file, generate one with <code>render.py</code>.'
+        : `Could not load the example workload from this server: <code>${escapeHtml(error.message || error)}</code>`;
+    })
     .finally(render);
 }

From ade72c2fc7b68312edbda7b82808e5a484000f22 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 08:12:59 -0600
Subject: [PATCH 23/27] fix(devtools): serve self-contained viewer root

---
 tools/dag-viewer/server.py | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index 552abb81..d82e781a 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -11,14 +11,19 @@
 from http import HTTPStatus
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
+from urllib.parse import urlsplit
 
-from render import prepare_workload
+from render import prepare_workload, render
 
 HERE = Path(__file__).resolve().parent
 REPO = HERE.parents[1]
 BINARY = REPO / "target" / "debug" / "dag_export"
 
 
+def example_workload() -> dict:
+    return json.loads((HERE / "dag.example.json").read_text(encoding="utf-8"))
+
+
 def build_exporter() -> None:
     subprocess.run(
         ["cargo", "build", "-q", "-p", "asap-devtools", "--bin", "dag_export"],
@@ -135,10 +140,19 @@ def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
             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":
+        path = urlsplit(self.path).path
+        if path in {"/", "/index.html"}:
+            try:
+                # Serve one self-contained document so initial rendering does
+                # not depend on separate JS or /api/example requests. The
+                # planner remains interactive through POST /api/plan.
+                self._send_html(HTTPStatus.OK, render(example_workload()))
+            except Exception as error:
+                self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
+            return
+        if 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))
+                self._send_json(HTTPStatus.OK, prepare_workload(example_workload()))
             except Exception as error:
                 self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
             return
@@ -158,6 +172,14 @@ def _send_json(self, status: HTTPStatus, value: object) -> None:
         self.end_headers()
         self.wfile.write(body)
 
+    def _send_html(self, status: HTTPStatus, value: str) -> None:
+        body = value.encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)

From ccb465b25952dc8035a64a50f0980d5d09c760a7 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 08:14:25 -0600
Subject: [PATCH 24/27] Revert "fix(devtools): serve self-contained viewer
 root"

This reverts commit ade72c2fc7b68312edbda7b82808e5a484000f22.
---
 tools/dag-viewer/server.py | 30 ++++--------------------------
 1 file changed, 4 insertions(+), 26 deletions(-)

diff --git a/tools/dag-viewer/server.py b/tools/dag-viewer/server.py
index d82e781a..552abb81 100644
--- a/tools/dag-viewer/server.py
+++ b/tools/dag-viewer/server.py
@@ -11,19 +11,14 @@
 from http import HTTPStatus
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from urllib.parse import urlsplit
 
-from render import prepare_workload, render
+from render import prepare_workload
 
 HERE = Path(__file__).resolve().parent
 REPO = HERE.parents[1]
 BINARY = REPO / "target" / "debug" / "dag_export"
 
 
-def example_workload() -> dict:
-    return json.loads((HERE / "dag.example.json").read_text(encoding="utf-8"))
-
-
 def build_exporter() -> None:
     subprocess.run(
         ["cargo", "build", "-q", "-p", "asap-devtools", "--bin", "dag_export"],
@@ -140,19 +135,10 @@ def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
             self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
 
     def do_GET(self) -> None:  # noqa: N802 - stdlib handler API
-        path = urlsplit(self.path).path
-        if path in {"/", "/index.html"}:
-            try:
-                # Serve one self-contained document so initial rendering does
-                # not depend on separate JS or /api/example requests. The
-                # planner remains interactive through POST /api/plan.
-                self._send_html(HTTPStatus.OK, render(example_workload()))
-            except Exception as error:
-                self._send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": str(error)})
-            return
-        if path == "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/api/example":
+        if self.path == "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/api/example":
             try:
-                self._send_json(HTTPStatus.OK, prepare_workload(example_workload()))
+                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
@@ -172,14 +158,6 @@ def _send_json(self, status: HTTPStatus, value: object) -> None:
         self.end_headers()
         self.wfile.write(body)
 
-    def _send_html(self, status: HTTPStatus, value: str) -> None:
-        body = value.encode()
-        self.send_response(status)
-        self.send_header("Content-Type", "text/html; charset=utf-8")
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)

From a9e51fb1867c24085210c111a09042d048cdbf26 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 08:14:25 -0600
Subject: [PATCH 25/27] Revert "fix(devtools): explain empty file URL viewer"

This reverts commit 064f028e4dd7ce37bec2b6f1a01bb2020ee40bf5.
---
 tools/dag-viewer/viewer.js | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index 75d06de1..feca4f8c 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -837,11 +837,6 @@ if (embeddedEl) {
   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((error) => {
-      console.error('tools/dag-viewer: failed to load the example workload', error);
-      emptyEl.innerHTML = window.location.protocol === 'file:'
-        ? 'This source page cannot load planner data over <code>file://</code>. From the repository root, run <code>python3 tools/dag-viewer/server.py</code>, then open <code>http://127.0.0.1:8000</code>. For a directly-openable file, generate one with <code>render.py</code>.'
-        : `Could not load the example workload from this server: <code>${escapeHtml(error.message || error)}</code>`;
-    })
+    .catch(() => {})
     .finally(render);
 }

From 411ecb29eda5eb954a1e3ed5c9c58d69aabb77c4 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 08:15:35 -0600
Subject: [PATCH 26/27] Revert "fix(devtools): clean up Pre/Post-ASAP DAG
 viewer (#284)"

This reverts commit 999abc0f026d9e95cdba5c1bc0ace0e8547ddb6f.
---
 tools/dag-viewer/README.md      |   4 +-
 tools/dag-viewer/index.html     |  29 +-
 tools/dag-viewer/node-style.js  | 129 ++++++++-
 tools/dag-viewer/render.py      |  20 ++
 tools/dag-viewer/test_render.py |  56 +++-
 tools/dag-viewer/viewer.js      | 497 ++++++++++++++++++++++++++++----
 6 files changed, 643 insertions(+), 92 deletions(-)

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 1c3fd694..8cd22c1a 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -4,8 +4,8 @@ The viewer has one visualization mode: **Pre/Post-ASAP**.
 
 - 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.
+  and one post-ASAP union. Structurally identical nodes and edges 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.
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index cb1a1d01..4379cc58 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -140,7 +140,7 @@
   .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 {
+  #baPicker {
     display: none;
     flex-wrap: wrap;
     gap: 0.6rem 1.2rem;
@@ -148,15 +148,15 @@
     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 {
+  #baPicker.visible { display: flex; }
+  .baGroup { display: flex; flex-direction: column; gap: 0.3rem; min-width: 220px; }
+  .baGroupLabel {
     font-size: 0.72rem;
     text-transform: uppercase;
     letter-spacing: .03em;
     color: var(--muted);
   }
-  .scopeRow {
+  .baRow {
     display: flex;
     align-items: center;
     gap: 0.5rem;
@@ -165,16 +165,29 @@
     border-radius: 8px;
     background: var(--panel2);
     color: var(--fg);
+    cursor: pointer;
     font: inherit;
     font-size: 0.78rem;
     text-align: left;
   }
-  .scopeRow.active {
+  .baRow:hover { border-color: var(--accent); }
+  .baRow:disabled { opacity: 0.55; cursor: not-allowed; }
+  .baRow:disabled:hover { border-color: var(--border); }
+  .baRow.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; }
+  .baRow .baWinner {
+    font-size: 0.66rem;
+    font-weight: 700;
+    color: var(--accent);
+    border: 1px solid var(--accent);
+    border-radius: 999px;
+    padding: 0.05rem 0.4rem;
+    flex-shrink: 0;
+  }
+  .baRow .baMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
   .proxyNote {
     font-size: 0.72rem;
     color: var(--muted);
@@ -411,7 +424,7 @@ <h2>Input table schemas</h2>
 </div>
 
 <div id="tabs"></div>
-<div id="scopePicker"></div>
+<div id="baPicker"></div>
 
 <div id="main">
   <div id="empty">
diff --git a/tools/dag-viewer/node-style.js b/tools/dag-viewer/node-style.js
index e688a80b..ca6c31d1 100644
--- a/tools/dag-viewer/node-style.js
+++ b/tools/dag-viewer/node-style.js
@@ -1,12 +1,13 @@
 // Category table for QueryExpr node kinds — the single source of truth for
-// how the viewer colors and labels each `DagNode.kind`. Edit this file to
+// how the viewer colors/labels/icons each `DagNode.kind`. Edit this file to
 // reclassify a kind or retune a palette; nothing else in index.html needs to
-// change.
+// change. Icon SVGs are adapted from ProjectASAP/bgp-query-dag-explorer's
+// hand-drawn icon set (see tools/dag-viewer/README.md).
 //
 // 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.
+// SummaryMerge) that only ever appear in Before/After mode's After lane when
+// an entry's `after.kind === "Summary"` — see the `summary` category below.
 
 // kind (DagNode.kind from crates/ir/src/dag_export.rs) -> category name.
 const KIND_CATEGORY = {
@@ -35,7 +36,7 @@ const KIND_CATEGORY = {
   Sort: 'sort',
   Limit: 'sort',
   LetBinding: 'bind',
-  // Post-ASAP SummaryDagNode kinds (post-ASAP lane only).
+  // Post-ASAP SummaryDagNode kinds (Before/After mode's After lane only).
   KeepPreAsap: 'summary',
   SummaryAgg: 'summary',
   SummaryJoin: 'summary',
@@ -45,6 +46,47 @@ const KIND_CATEGORY = {
   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: stacked layers, for the post-ASAP `summary` category — a materialized
+  // structure (a sketch, a rollup, a merged/estimated join) rather than a
+  // pre-ASAP relational operator.
+  summary: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="9" y="7" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="19" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="31" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
+};
+
+// KeepPreAsap-only: a dashed box with a through-arrow, standing in for
+// "unchanged pre-ASAP content carried through as-is" — see the `summary`
+// CATEGORIES entry and buildCyStyle's `node[kind = "KeepPreAsap"]` override
+// in viewer.js for why this doesn't just reuse ICONS.summary's stroke color.
+const KEEP_PRE_ASAP_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="7" y="14" width="34" height="20" rx="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-dasharray="4 3"/><path d="M13 24h22m0 0l-6-6m6 6l-6 6" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+
+function keepPreAsapIconDataUri() {
+  const muted = getComputedStyle(document.documentElement).getPropertyValue('--muted').trim() || '#6b7280';
+  return svgDataUri(KEEP_PRE_ASAP_ICON(muted));
+}
+
+// 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: {
@@ -101,7 +143,7 @@ const CATEGORIES = {
     light: { bg: '#fff5ea', border: '#b45309' },
     dark: { bg: '#3a2408', border: '#fb923c' },
   },
-  // Post-ASAP only (post-ASAP lane): every other category
+  // Post-ASAP only (Before/After mode's After 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
@@ -115,7 +157,7 @@ const CATEGORIES = {
   // through) rather than a different concept.
   summary: {
     label: 'Summary',
-    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures',
+    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures (Before/After mode only)',
     light: { bg: '#f1f2f4', border: '#4b5563' },
     dark: { bg: '#20242b', border: '#9ca3af' },
   },
@@ -128,10 +170,35 @@ 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';
 }
@@ -141,12 +208,52 @@ 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, 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);
+  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);
   }
   root.setProperty('--cat-output-border', (isDarkMode() ? ROOT_BADGE.dark : ROOT_BADGE.light).border);
 }
diff --git a/tools/dag-viewer/render.py b/tools/dag-viewer/render.py
index 2059597f..c77aba10 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -246,9 +246,29 @@ def prepare_graph(graph: object) -> None:
             nested = (node.get("detail") or {}).get("pre_asap_subgraph")
             prepare_graph(nested)
 
+    def append_root_line(graph: object, line: str) -> None:
+        if not isinstance(graph, dict):
+            return
+        root_id = graph.get("root")
+        root = next((node for node in graph.get("nodes", []) if node.get("id") == root_id), None)
+        if root is not None:
+            root["label"] += f"\n{line}"
+
     for query in prepared.get("queries", []):
         prepare_graph(query.get("graph"))
         prepare_graph(query.get("post_graph"))
+        for replacement in query.get("replacements", []):
+            before = replacement.get("before")
+            after = replacement.get("after") or {}
+            after_graph = after.get("graph")
+            prepare_graph(before)
+            prepare_graph(after_graph)
+            if replacement.get("strategy") == "SharedSubtree" or replacement.get("provenance") == "CseShare":
+                rationale = str(replacement.get("rationale", ""))
+                count = re.search(r"(\d+)\s+consumers?", rationale)
+                suffix = f" ({count.group(1)} consumers)" if count else ""
+                append_root_line(before, "reuse: recomputed per consumer")
+                append_root_line(after_graph, f"reuse: shared across workload{suffix}")
     return prepared
 
 
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index 6966287e..b7994694 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -213,14 +213,13 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
             "detail": {"measures": [{"kind": "avg", "col": 3}]},
             "children": [],
         }
-        def graph():
-            return {"nodes": [dict(node)], "root": 0}
+        graph = {"nodes": [node], "root": 0}
         workload = {
             "queries": [
                 {
-                    "graph": graph(),
-                    "post_graph": graph(),
-                    "replacements": [{"before": graph(), "after": {"graph": graph()}}],
+                    "graph": graph,
+                    "post_graph": graph,
+                    "replacements": [{"before": graph, "after": {"graph": graph}}],
                 }
             ]
         }
@@ -229,20 +228,47 @@ def graph():
         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)",
-        )
+            query["replacements"][0]["after"]["graph"]["nodes"][0]["label"],
+        ]
+        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 4)
 
-    def test_replacement_subgraphs_are_not_prepared_for_the_current_viewer(self):
+    def test_cse_before_after_makes_reuse_decision_visible(self):
+        node = {
+            "id": 0,
+            "kind": "Scan",
+            "label": "Scan(metrics)",
+            "detail": {},
+            "children": [],
+        }
         def graph():
-            return {"nodes": [{"id": 0, "kind": "Scan", "label": "legacy", "detail": {}, "children": []}], "root": 0}
-        workload = {"queries": [{"graph": graph(), "replacements": [{"before": graph(), "after": {"graph": graph()}}]}]}
+            return {"nodes": [dict(node)], "root": 0}
+
+        workload = {
+            "queries": [
+                {
+                    "graph": graph(),
+                    "replacements": [
+                        {
+                            "strategy": "SharedSubtree",
+                            "provenance": "CseShare",
+                            "rationale": "Scan(metrics) has 2 consumers across this workload",
+                            "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")
+        self.assertEqual(
+            replacement["before"]["nodes"][0]["label"],
+            "Scan\nsource: metrics\nreuse: recomputed per consumer",
+        )
+        self.assertEqual(
+            replacement["after"]["graph"]["nodes"][0]["label"],
+            "Scan\nsource: metrics\nreuse: shared across workload (2 consumers)",
+        )
 
 
 class MainCliTests(unittest.TestCase):
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index feca4f8c..d03541cc 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -35,7 +35,7 @@ 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 baPickerEl = document.getElementById('baPicker');
 const cyOuterEl = document.getElementById('cyOuter');
 const cyEl = document.getElementById('cy');
 const modeHintEl = document.getElementById('modeHint');
@@ -116,6 +116,35 @@ 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) {
+      // A post-ASAP-only node (e.g. mixed into a whole-query post_graph) has
+      // no corresponding QueryExpr to hash — skip rather than bucketing
+      // every such node together under the key `undefined`. `graph.nodes`
+      // (as opposed to `post_graph.nodes`) never actually contains one of
+      // these today, but this stays correct if that ever changes.
+      if (node.hash === undefined) continue;
+      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)
@@ -125,7 +154,7 @@ function getParticipants() {
 function render() {
   if (queries.length === 0) {
     tabsEl.innerHTML = '';
-    scopePickerEl.classList.remove('visible');
+    baPickerEl.classList.remove('visible');
     emptyEl.style.display = 'flex';
     cyOuterEl.style.display = 'none';
     sidepanel.style.display = 'none';
@@ -177,6 +206,7 @@ function buildCyStyle() {
     style: {
       'border-color': categoryColors(name).border,
       'background-color': categoryColors(name).bg,
+      'background-image': categoryIconDataUri(name),
     },
   }));
 
@@ -210,9 +240,12 @@ function buildCyStyle() {
       selector: 'node[category = "data"]',
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
-    ...categoryStyles,
+    ...categoryStyles.map((entry) => ({
+      ...entry,
+      style: { ...entry.style, 'background-image': 'none' },
+    })),
     {
-      // KeepPreAsap (post-ASAP lane only) is post-ASAP-only
+      // KeepPreAsap (Before/After mode's After 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
@@ -225,12 +258,17 @@ function buildCyStyle() {
         'background-color': panelColor,
         'border-color': borderColor,
         'border-style': 'dashed',
+        'background-image': 'none',
       },
     },
     {
       selector: 'node.root',
       style: { 'border-width': 2.5 },
     },
+    {
+      selector: 'node.hasNotes',
+      style: { 'border-style': 'double', 'border-width': 3 },
+    },
     {
       selector: 'node.shared',
       style: {
@@ -241,7 +279,7 @@ function buildCyStyle() {
       },
     },
     {
-      // Workload-union collapsed nodes: a persistent double border marks the
+      // Union mode's 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',
@@ -258,7 +296,7 @@ function buildCyStyle() {
       },
     },
     {
-      // Pre/Post-ASAP lane container (a compound parent node).
+      // Compare mode's per-query lane container (a compound parent node).
       selector: 'node.laneParent',
       style: {
         'shape': 'round-rectangle',
@@ -300,6 +338,29 @@ function buildCyStyle() {
         'transition-timing-function': 'ease-in-out',
       },
     },
+    {
+      selector: 'edge.showSchema',
+      style: {
+        'label': 'data(schemaLabel)',
+      },
+    },
+    {
+      // 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;
@@ -332,15 +393,36 @@ function buildCy(elements, layout) {
   return cy;
 }
 
-// Root borders and click/tap wiring for the Pre/Post-ASAP lanes.
+// Root badges + notes badges + click/tap wiring — identical across
+// single/compare/union.
 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) => {
+    // Before/After has a strict stage split: pre-ASAP is the unannotated IR,
+    // while post-ASAP carries explicit decision explanations.
+    if (n.data('isLane') || n.data('isBeforeAfter')) 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;
-    showPrePostDetail(n.data());
+    if (n.data('isUnion')) {
+      showUnionDetail(n.data());
+      return;
+    }
+    if (n.data('isBeforeAfter')) {
+      showBeforeAfterDetail(n.data());
+      return;
+    }
+    const query = queries.find((q) => q.name === n.data('queryName'));
+    showDetail(n.data('node'), query);
   });
   cy.on('tap', 'edge', (evt) => showEdgeDetail(evt.target));
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
@@ -366,11 +448,240 @@ function hideModeHint() {
   cyEl.style.display = 'block';
 }
 
+// ── Single-query view (default, unchanged behavior) ──────────────────────
+
+function renderGraph(query) {
+  hideModeHint();
+  viewTitleEl.textContent = query.name;
+  renderSourcePanel([query]);
+
+  const elements = [];
+  for (const node of query.graph.nodes) {
+    elements.push({
+      data: {
+        id: String(node.id),
+        label: node.label,
+        node,
+        category: categoryOf(node.kind),
+        root: node.id === query.graph.root,
+        queryName: query.name,
+      },
+    });
+  }
+  for (const node of query.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-${node.id}-${childId}`,
+          source: String(childId),
+          target: String(node.id),
+        },
+      });
+    }
+  }
+
+  buildCy(elements);
+  finalizeGraphInteractions();
+  applyHighlighting();
+  clearDetail();
+  zoom = 1;
+  applyZoom();
+}
+
+// ── 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}`,
+          },
+        });
+      }
+    }
+  });
+
+  buildCy(elements);
+  cy.add(buildSharedLinkEdges(chosen));
+  finalizeGraphInteractions();
+  applyHighlighting();
+  clearDetail();
+  fitAndSyncZoom();
+}
+
+// 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;
+    });
+  }
+  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();
+
+  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}`);
+
+  const nodeEntries = new Map(); // key -> accumulator
+  const edgeKeys = new Set();
+  const elements = [];
+
+  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);
+    }
+  });
+
+  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 } });
+      }
+    }
+  });
+
+  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' : '',
+    });
+  }
+
+  buildCy(elements);
+  finalizeGraphInteractions();
+  applyHighlighting();
+  clearDetail();
+  fitAndSyncZoom();
+}
+
 // ── Pre/Post-ASAP: one query or two workload-union DAGs ──────────────────
 function renderPrePostAsap() {
   const chosen = getParticipants();
   const selected = chosen.map((i) => queries[i]);
-  renderScopeSummary(selected);
+  renderBaScopeSummary(selected);
   renderSourcePanel(selected);
 
   if (selected.length === 0) {
@@ -410,7 +721,7 @@ function renderPrePostAsap() {
   ).first();
   if (initial && initial.length) {
     initial.select();
-    showPrePostDetail(initial.data());
+    showBeforeAfterDetail(initial.data());
   } else {
     clearDetail();
   }
@@ -454,13 +765,10 @@ function unionStageLaneElements(stage, chosen) {
       const key = keyFor(qIdx, node);
       let entry = entries.get(key);
       if (!entry) {
-        entry = { node, sourceQueries: new Set(), rootFor: new Set(), decisions: new Map() };
+        entry = { node, query, sourceQueries: new Set(), rootFor: new Set() };
         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));
@@ -481,10 +789,10 @@ function unionStageLaneElements(stage, chosen) {
       root: entry.rootFor.size > 0,
       rootFor: Array.from(entry.rootFor),
       sourceQueries: Array.from(entry.sourceQueries),
-      isPrePost: true,
+      isBeforeAfter: true,
       stage,
-      queryName: Array.from(entry.sourceQueries)[0],
-      translations: Array.from(entry.decisions.values()),
+      queryName: entry.query.name,
+      translations: translationsForNode(entry.query, entry.node, stage),
     },
     classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
   }));
@@ -496,13 +804,13 @@ function unionStageLaneElements(stage, chosen) {
   return elements;
 }
 
-// Builds one Pre/Post-ASAP lane (a dashed compound parent plus its
-// nodes/edges). `nodes` is either a plain pre-ASAP
+// Builds one Compare-mode-style lane (a dashed compound parent plus its
+// nodes/edges) for Before/After mode. `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.
+// read by this function or by showBeforeAfterDetail below.
 function laneElements(laneId, laneLabel, graph, query, stage) {
   const nodes = graph.nodes;
   const byId = new Map(nodes.map((node) => [node.id, node]));
@@ -523,7 +831,7 @@ function laneElements(laneId, laneLabel, graph, query, stage) {
         kind: node.kind,
         category: categoryOf(node.kind),
         root: node.id === graph.root,
-        isPrePost: true,
+        isBeforeAfter: true,
         laneId,
         stage,
         queryName: query.name,
@@ -613,32 +921,30 @@ function showEdgeDetail(edge) {
   `;
 }
 
-function renderScopeSummary(selected) {
-  scopePickerEl.classList.add('visible');
+function renderBaScopeSummary(selected) {
+  baPickerEl.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);
-  }));
+  selected.forEach((q) => (q.replacements || []).filter((r) => r.rank === 0).forEach((r) => strategies.add(r.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>`;
+  baPickerEl.innerHTML = `<div class="baGroup"><div class="baGroupLabel">View scope</div><div class="baRow active"><span>${escapeHtml(scope)}</span><span class="baMeta">${escapeHtml(strategyText)}</span></div></div>`;
 }
 
 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);
+  const replacements = (query.replacements || []).filter((r) => r.rank === 0);
   if (!node.decision) return [];
-  const replacement = replacements.find((entry) => entry.decision_id === node.decision.id);
+  const replacement = replacements.find((r) => r.decision_id === node.decision.id);
   return [{
     ...node.decision,
     target_pre_id: replacement ? replacement.target_pre_id : undefined,
-    output_kind: replacement ? replacement.after?.kind : undefined,
+    after: replacement ? replacement.after : undefined,
   }];
 }
 
-function showPrePostDetail(data) {
+function showBeforeAfterDetail(data) {
   const node = data.node;
   const category = categoryOf(node.kind);
   const catColors = categoryColors(category);
@@ -660,7 +966,7 @@ function showPrePostDetail(data) {
         <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 class="translationTarget">${entry.target_pre_id === undefined ? `decision #${entry.id}` : `pre-ASAP target node #${entry.target_pre_id}`} · output ${escapeHtml((entry.after || {}).kind || node.kind)}</div>
       </div>`).join('');
     translationHtml = `<div class="translationBlock"><h3>Why this post-ASAP translation</h3>${cards}</div>`;
   } else if (data.stage === 'post') {
@@ -723,36 +1029,110 @@ function renderTableSchemas(qs) {
 function applyHighlighting() {
   if (!cy) return;
   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);
+    const ownersFor = (graphOf) => {
+      const owners = new Map();
+      selected.forEach((q) => {
+        const seen = new Set();
+        const graph = graphOf(q);
+        (graph ? graph.nodes : []).forEach((node) => {
+          if (node.hash === undefined || seen.has(node.hash)) return;
+          seen.add(node.hash);
+          if (!owners.has(node.hash)) owners.set(node.hash, new Set());
+          owners.get(node.hash).add(q.name);
+        });
       });
+      return owners;
+    };
+    const preOwners = ownersFor((q) => q.graph);
+    const postOwners = ownersFor((q) => q.post_graph);
+    cy.nodes().forEach((n) => {
+      if (n.data('isLane')) return;
+      const node = n.data('node');
+      const owners = n.data('stage') === 'post' ? postOwners : preOwners;
+      const sharedWith = node && owners.get(node.hash);
+      n.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
     });
-    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));
-  });
 }
 
 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]) => {
@@ -763,9 +1143,14 @@ 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 workload node</span><span class="swatchDesc">Explicitly identified by the exporter as shared across selected queries</span></span></div>`);
+    <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>`);
   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>`);
+  }
   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>
@@ -832,7 +1217,7 @@ if (embeddedEl) {
 } else {
   // 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
+  // post_graph and make Before/After 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())))

From 2c7b08ef7fe2df5ff895d0bcd0bee5a8a6b362fd Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Wed, 26 Aug 2026 09:06:35 -0600
Subject: [PATCH 27/27] Revert "Revert "fix(devtools): clean up Pre/Post-ASAP
 DAG viewer (#284)""

This reverts commit 411ecb29eda5eb954a1e3ed5c9c58d69aabb77c4.
---
 tools/dag-viewer/README.md      |   4 +-
 tools/dag-viewer/index.html     |  29 +-
 tools/dag-viewer/node-style.js  | 129 +--------
 tools/dag-viewer/render.py      |  20 --
 tools/dag-viewer/test_render.py |  56 +---
 tools/dag-viewer/viewer.js      | 497 ++++----------------------------
 6 files changed, 92 insertions(+), 643 deletions(-)

diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 8cd22c1a..1c3fd694 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -4,8 +4,8 @@ The viewer has one visualization mode: **Pre/Post-ASAP**.
 
 - 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. Structurally identical nodes and edges are
-  collapsed while query roots and ownership are retained.
+  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.
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 4379cc58..cb1a1d01 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -140,7 +140,7 @@
   .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; }
-  #baPicker {
+  #scopePicker {
     display: none;
     flex-wrap: wrap;
     gap: 0.6rem 1.2rem;
@@ -148,15 +148,15 @@
     border-bottom: 1px solid var(--border);
     background: var(--panel);
   }
-  #baPicker.visible { display: flex; }
-  .baGroup { display: flex; flex-direction: column; gap: 0.3rem; min-width: 220px; }
-  .baGroupLabel {
+  #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);
   }
-  .baRow {
+  .scopeRow {
     display: flex;
     align-items: center;
     gap: 0.5rem;
@@ -165,29 +165,16 @@
     border-radius: 8px;
     background: var(--panel2);
     color: var(--fg);
-    cursor: pointer;
     font: inherit;
     font-size: 0.78rem;
     text-align: left;
   }
-  .baRow:hover { border-color: var(--accent); }
-  .baRow:disabled { opacity: 0.55; cursor: not-allowed; }
-  .baRow:disabled:hover { border-color: var(--border); }
-  .baRow.active {
+  .scopeRow.active {
     border-color: var(--accent);
     background: var(--bg);
     box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 15%, transparent);
   }
-  .baRow .baWinner {
-    font-size: 0.66rem;
-    font-weight: 700;
-    color: var(--accent);
-    border: 1px solid var(--accent);
-    border-radius: 999px;
-    padding: 0.05rem 0.4rem;
-    flex-shrink: 0;
-  }
-  .baRow .baMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
+  .scopeRow .scopeMeta { color: var(--muted); font-size: 0.72rem; margin-left: auto; white-space: nowrap; }
   .proxyNote {
     font-size: 0.72rem;
     color: var(--muted);
@@ -424,7 +411,7 @@ <h2>Input table schemas</h2>
 </div>
 
 <div id="tabs"></div>
-<div id="baPicker"></div>
+<div id="scopePicker"></div>
 
 <div id="main">
   <div id="empty">
diff --git a/tools/dag-viewer/node-style.js b/tools/dag-viewer/node-style.js
index ca6c31d1..e688a80b 100644
--- a/tools/dag-viewer/node-style.js
+++ b/tools/dag-viewer/node-style.js
@@ -1,13 +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 only ever appear in Before/After mode's After lane when
-// an entry's `after.kind === "Summary"` — see the `summary` category below.
+// 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 = {
@@ -36,7 +35,7 @@ const KIND_CATEGORY = {
   Sort: 'sort',
   Limit: 'sort',
   LetBinding: 'bind',
-  // Post-ASAP SummaryDagNode kinds (Before/After mode's After lane only).
+  // Post-ASAP SummaryDagNode kinds (post-ASAP lane only).
   KeepPreAsap: 'summary',
   SummaryAgg: 'summary',
   SummaryJoin: 'summary',
@@ -46,47 +45,6 @@ const KIND_CATEGORY = {
   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: stacked layers, for the post-ASAP `summary` category — a materialized
-  // structure (a sketch, a rollup, a merged/estimated join) rather than a
-  // pre-ASAP relational operator.
-  summary: (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="9" y="7" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="19" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/><rect x="9" y="31" width="30" height="10" rx="3" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}"/></svg>`,
-};
-
-// KeepPreAsap-only: a dashed box with a through-arrow, standing in for
-// "unchanged pre-ASAP content carried through as-is" — see the `summary`
-// CATEGORIES entry and buildCyStyle's `node[kind = "KeepPreAsap"]` override
-// in viewer.js for why this doesn't just reuse ICONS.summary's stroke color.
-const KEEP_PRE_ASAP_ICON = (c) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><rect x="7" y="14" width="34" height="20" rx="4" fill="${ICON_FILL}" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-dasharray="4 3"/><path d="M13 24h22m0 0l-6-6m6 6l-6 6" fill="none" stroke="${c}" stroke-width="${ICON_STROKE}" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
-
-function keepPreAsapIconDataUri() {
-  const muted = getComputedStyle(document.documentElement).getPropertyValue('--muted').trim() || '#6b7280';
-  return svgDataUri(KEEP_PRE_ASAP_ICON(muted));
-}
-
-// 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: {
@@ -143,7 +101,7 @@ const CATEGORIES = {
     light: { bg: '#fff5ea', border: '#b45309' },
     dark: { bg: '#3a2408', border: '#fb923c' },
   },
-  // Post-ASAP only (Before/After mode's After lane): every other category
+  // 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
@@ -157,7 +115,7 @@ const CATEGORIES = {
   // through) rather than a different concept.
   summary: {
     label: 'Summary',
-    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures (Before/After mode only)',
+    description: 'KeepPreAsap, SummaryAgg, SummaryJoin, SummarySubtract, SummaryDelete, SummaryEstimate, SummaryMerge — post-ASAP materialized structures',
     light: { bg: '#f1f2f4', border: '#4b5563' },
     dark: { bg: '#20242b', border: '#9ca3af' },
   },
@@ -170,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';
 }
@@ -208,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/render.py b/tools/dag-viewer/render.py
index c77aba10..2059597f 100755
--- a/tools/dag-viewer/render.py
+++ b/tools/dag-viewer/render.py
@@ -246,29 +246,9 @@ def prepare_graph(graph: object) -> None:
             nested = (node.get("detail") or {}).get("pre_asap_subgraph")
             prepare_graph(nested)
 
-    def append_root_line(graph: object, line: str) -> None:
-        if not isinstance(graph, dict):
-            return
-        root_id = graph.get("root")
-        root = next((node for node in graph.get("nodes", []) if node.get("id") == root_id), None)
-        if root is not None:
-            root["label"] += f"\n{line}"
-
     for query in prepared.get("queries", []):
         prepare_graph(query.get("graph"))
         prepare_graph(query.get("post_graph"))
-        for replacement in query.get("replacements", []):
-            before = replacement.get("before")
-            after = replacement.get("after") or {}
-            after_graph = after.get("graph")
-            prepare_graph(before)
-            prepare_graph(after_graph)
-            if replacement.get("strategy") == "SharedSubtree" or replacement.get("provenance") == "CseShare":
-                rationale = str(replacement.get("rationale", ""))
-                count = re.search(r"(\d+)\s+consumers?", rationale)
-                suffix = f" ({count.group(1)} consumers)" if count else ""
-                append_root_line(before, "reuse: recomputed per consumer")
-                append_root_line(after_graph, f"reuse: shared across workload{suffix}")
     return prepared
 
 
diff --git a/tools/dag-viewer/test_render.py b/tools/dag-viewer/test_render.py
index b7994694..6966287e 100644
--- a/tools/dag-viewer/test_render.py
+++ b/tools/dag-viewer/test_render.py
@@ -213,13 +213,14 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
             "detail": {"measures": [{"kind": "avg", "col": 3}]},
             "children": [],
         }
-        graph = {"nodes": [node], "root": 0}
+        def graph():
+            return {"nodes": [dict(node)], "root": 0}
         workload = {
             "queries": [
                 {
-                    "graph": graph,
-                    "post_graph": graph,
-                    "replacements": [{"before": graph, "after": {"graph": graph}}],
+                    "graph": graph(),
+                    "post_graph": graph(),
+                    "replacements": [{"before": graph(), "after": {"graph": graph()}}],
                 }
             ]
         }
@@ -228,47 +229,20 @@ def test_prepares_before_after_and_whole_post_asap_graphs(self):
         labels = [
             query["graph"]["nodes"][0]["label"],
             query["post_graph"]["nodes"][0]["label"],
-            query["replacements"][0]["before"]["nodes"][0]["label"],
-            query["replacements"][0]["after"]["graph"]["nodes"][0]["label"],
         ]
-        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 4)
+        self.assertEqual(labels, ["Aggregate\nmeasure: avg(col[3])"] * 2)
+        self.assertEqual(
+            query["replacements"][0]["before"]["nodes"][0]["label"],
+            "Aggregate(1 measures)",
+        )
 
-    def test_cse_before_after_makes_reuse_decision_visible(self):
-        node = {
-            "id": 0,
-            "kind": "Scan",
-            "label": "Scan(metrics)",
-            "detail": {},
-            "children": [],
-        }
+    def test_replacement_subgraphs_are_not_prepared_for_the_current_viewer(self):
         def graph():
-            return {"nodes": [dict(node)], "root": 0}
-
-        workload = {
-            "queries": [
-                {
-                    "graph": graph(),
-                    "replacements": [
-                        {
-                            "strategy": "SharedSubtree",
-                            "provenance": "CseShare",
-                            "rationale": "Scan(metrics) has 2 consumers across this workload",
-                            "before": graph(),
-                            "after": {"graph": 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"],
-            "Scan\nsource: metrics\nreuse: recomputed per consumer",
-        )
-        self.assertEqual(
-            replacement["after"]["graph"]["nodes"][0]["label"],
-            "Scan\nsource: metrics\nreuse: shared across workload (2 consumers)",
-        )
+        self.assertEqual(replacement["before"]["nodes"][0]["label"], "legacy")
+        self.assertEqual(replacement["after"]["graph"]["nodes"][0]["label"], "legacy")
 
 
 class MainCliTests(unittest.TestCase):
diff --git a/tools/dag-viewer/viewer.js b/tools/dag-viewer/viewer.js
index d03541cc..feca4f8c 100644
--- a/tools/dag-viewer/viewer.js
+++ b/tools/dag-viewer/viewer.js
@@ -35,7 +35,7 @@ const fileInput = document.getElementById('fileInput');
 const clearBtn = document.getElementById('clearBtn');
 const highlightToggle = document.getElementById('highlightToggle');
 const tabsEl = document.getElementById('tabs');
-const baPickerEl = document.getElementById('baPicker');
+const scopePickerEl = document.getElementById('scopePicker');
 const cyOuterEl = document.getElementById('cyOuter');
 const cyEl = document.getElementById('cy');
 const modeHintEl = document.getElementById('modeHint');
@@ -116,35 +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) {
-      // A post-ASAP-only node (e.g. mixed into a whole-query post_graph) has
-      // no corresponding QueryExpr to hash — skip rather than bucketing
-      // every such node together under the key `undefined`. `graph.nodes`
-      // (as opposed to `post_graph.nodes`) never actually contains one of
-      // these today, but this stays correct if that ever changes.
-      if (node.hash === undefined) continue;
-      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)
@@ -154,7 +125,7 @@ function getParticipants() {
 function render() {
   if (queries.length === 0) {
     tabsEl.innerHTML = '';
-    baPickerEl.classList.remove('visible');
+    scopePickerEl.classList.remove('visible');
     emptyEl.style.display = 'flex';
     cyOuterEl.style.display = 'none';
     sidepanel.style.display = 'none';
@@ -206,7 +177,6 @@ function buildCyStyle() {
     style: {
       'border-color': categoryColors(name).border,
       'background-color': categoryColors(name).bg,
-      'background-image': categoryIconDataUri(name),
     },
   }));
 
@@ -240,12 +210,9 @@ function buildCyStyle() {
       selector: 'node[category = "data"]',
       style: { 'corner-radius': 999, 'border-style': 'dashed' },
     },
-    ...categoryStyles.map((entry) => ({
-      ...entry,
-      style: { ...entry.style, 'background-image': 'none' },
-    })),
+    ...categoryStyles,
     {
-      // KeepPreAsap (Before/After mode's After lane only) is post-ASAP-only
+      // 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
@@ -258,17 +225,12 @@ function buildCyStyle() {
         'background-color': panelColor,
         'border-color': borderColor,
         'border-style': 'dashed',
-        'background-image': 'none',
       },
     },
     {
       selector: 'node.root',
       style: { 'border-width': 2.5 },
     },
-    {
-      selector: 'node.hasNotes',
-      style: { 'border-style': 'double', 'border-width': 3 },
-    },
     {
       selector: 'node.shared',
       style: {
@@ -279,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',
@@ -296,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',
@@ -338,29 +300,6 @@ function buildCyStyle() {
         'transition-timing-function': 'ease-in-out',
       },
     },
-    {
-      selector: 'edge.showSchema',
-      style: {
-        'label': 'data(schemaLabel)',
-      },
-    },
-    {
-      // 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;
@@ -393,36 +332,15 @@ 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) => {
-    // Before/After has a strict stage split: pre-ASAP is the unannotated IR,
-    // while post-ASAP carries explicit decision explanations.
-    if (n.data('isLane') || n.data('isBeforeAfter')) 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;
-    }
-    if (n.data('isBeforeAfter')) {
-      showBeforeAfterDetail(n.data());
-      return;
-    }
-    const query = queries.find((q) => q.name === n.data('queryName'));
-    showDetail(n.data('node'), query);
+    showPrePostDetail(n.data());
   });
   cy.on('tap', 'edge', (evt) => showEdgeDetail(evt.target));
   cy.on('tap', (evt) => { if (evt.target === cy) clearDetail(); });
@@ -448,240 +366,11 @@ function hideModeHint() {
   cyEl.style.display = 'block';
 }
 
-// ── Single-query view (default, unchanged behavior) ──────────────────────
-
-function renderGraph(query) {
-  hideModeHint();
-  viewTitleEl.textContent = query.name;
-  renderSourcePanel([query]);
-
-  const elements = [];
-  for (const node of query.graph.nodes) {
-    elements.push({
-      data: {
-        id: String(node.id),
-        label: node.label,
-        node,
-        category: categoryOf(node.kind),
-        root: node.id === query.graph.root,
-        queryName: query.name,
-      },
-    });
-  }
-  for (const node of query.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-${node.id}-${childId}`,
-          source: String(childId),
-          target: String(node.id),
-        },
-      });
-    }
-  }
-
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  zoom = 1;
-  applyZoom();
-}
-
-// ── 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}`,
-          },
-        });
-      }
-    }
-  });
-
-  buildCy(elements);
-  cy.add(buildSharedLinkEdges(chosen));
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
-}
-
-// 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;
-    });
-  }
-  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();
-
-  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}`);
-
-  const nodeEntries = new Map(); // key -> accumulator
-  const edgeKeys = new Set();
-  const elements = [];
-
-  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);
-    }
-  });
-
-  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 } });
-      }
-    }
-  });
-
-  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' : '',
-    });
-  }
-
-  buildCy(elements);
-  finalizeGraphInteractions();
-  applyHighlighting();
-  clearDetail();
-  fitAndSyncZoom();
-}
-
 // ── Pre/Post-ASAP: one query or two workload-union DAGs ──────────────────
 function renderPrePostAsap() {
   const chosen = getParticipants();
   const selected = chosen.map((i) => queries[i]);
-  renderBaScopeSummary(selected);
+  renderScopeSummary(selected);
   renderSourcePanel(selected);
 
   if (selected.length === 0) {
@@ -721,7 +410,7 @@ function renderPrePostAsap() {
   ).first();
   if (initial && initial.length) {
     initial.select();
-    showBeforeAfterDetail(initial.data());
+    showPrePostDetail(initial.data());
   } else {
     clearDetail();
   }
@@ -765,10 +454,13 @@ function unionStageLaneElements(stage, chosen) {
       const key = keyFor(qIdx, node);
       let entry = entries.get(key);
       if (!entry) {
-        entry = { node, query, sourceQueries: new Set(), rootFor: new Set() };
+        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));
@@ -789,10 +481,10 @@ function unionStageLaneElements(stage, chosen) {
       root: entry.rootFor.size > 0,
       rootFor: Array.from(entry.rootFor),
       sourceQueries: Array.from(entry.sourceQueries),
-      isBeforeAfter: true,
+      isPrePost: true,
       stage,
-      queryName: entry.query.name,
-      translations: translationsForNode(entry.query, entry.node, stage),
+      queryName: Array.from(entry.sourceQueries)[0],
+      translations: Array.from(entry.decisions.values()),
     },
     classes: entry.sourceQueries.size > 1 ? 'unionShared' : '',
   }));
@@ -804,13 +496,13 @@ function unionStageLaneElements(stage, chosen) {
   return elements;
 }
 
-// Builds one Compare-mode-style lane (a dashed compound parent plus its
-// nodes/edges) for Before/After mode. `nodes` is either a plain pre-ASAP
+// 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 showBeforeAfterDetail below.
+// 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]));
@@ -831,7 +523,7 @@ function laneElements(laneId, laneLabel, graph, query, stage) {
         kind: node.kind,
         category: categoryOf(node.kind),
         root: node.id === graph.root,
-        isBeforeAfter: true,
+        isPrePost: true,
         laneId,
         stage,
         queryName: query.name,
@@ -921,30 +613,32 @@ function showEdgeDetail(edge) {
   `;
 }
 
-function renderBaScopeSummary(selected) {
-  baPickerEl.classList.add('visible');
+function renderScopeSummary(selected) {
+  scopePickerEl.classList.add('visible');
   const strategies = new Set();
-  selected.forEach((q) => (q.replacements || []).filter((r) => r.rank === 0).forEach((r) => strategies.add(r.strategy)));
+  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';
-  baPickerEl.innerHTML = `<div class="baGroup"><div class="baGroupLabel">View scope</div><div class="baRow active"><span>${escapeHtml(scope)}</span><span class="baMeta">${escapeHtml(strategyText)}</span></div></div>`;
+  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>`;
 }
 
 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((r) => r.rank === 0);
+  const replacements = (query.replacements || []).filter((replacement) => replacement.rank === 0);
   if (!node.decision) return [];
-  const replacement = replacements.find((r) => r.decision_id === node.decision.id);
+  const replacement = replacements.find((entry) => entry.decision_id === node.decision.id);
   return [{
     ...node.decision,
     target_pre_id: replacement ? replacement.target_pre_id : undefined,
-    after: replacement ? replacement.after : undefined,
+    output_kind: replacement ? replacement.after?.kind : undefined,
   }];
 }
 
-function showBeforeAfterDetail(data) {
+function showPrePostDetail(data) {
   const node = data.node;
   const category = categoryOf(node.kind);
   const catColors = categoryColors(category);
@@ -966,7 +660,7 @@ function showBeforeAfterDetail(data) {
         <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.after || {}).kind || node.kind)}</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') {
@@ -1029,110 +723,36 @@ function renderTableSchemas(qs) {
 function applyHighlighting() {
   if (!cy) return;
   const selected = getParticipants().map((i) => queries[i]);
-    const ownersFor = (graphOf) => {
-      const owners = new Map();
-      selected.forEach((q) => {
-        const seen = new Set();
-        const graph = graphOf(q);
-        (graph ? graph.nodes : []).forEach((node) => {
-          if (node.hash === undefined || seen.has(node.hash)) return;
-          seen.add(node.hash);
-          if (!owners.has(node.hash)) owners.set(node.hash, new Set());
-          owners.get(node.hash).add(q.name);
-        });
+  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((q) => q.graph);
-    const postOwners = ownersFor((q) => q.post_graph);
-    cy.nodes().forEach((n) => {
-      if (n.data('isLane')) return;
-      const node = n.data('node');
-      const owners = n.data('stage') === 'post' ? postOwners : preOwners;
-      const sharedWith = node && owners.get(node.hash);
-      n.toggleClass('shared', !!(highlightOn && sharedWith && sharedWith.size > 1));
     });
+    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));
+  });
 }
 
 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]) => {
@@ -1143,14 +763,9 @@ 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>`);
-  }
   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>
@@ -1217,7 +832,7 @@ if (embeddedEl) {
 } else {
   // 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 Before/After appear broken. Users can load scratch
+  // 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())))