From 1adf6fbde0a5b73bb176407787e21dab6ac98ac6 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Sun, 13 Sep 2026 10:30:09 -0600
Subject: [PATCH 1/4] docs: replace historical commentary with current
 contracts

---
 control_plane/src/asap_tier_implement.rs      |  19 +-
 control_plane/src/backend_client.rs           |  37 +--
 control_plane/src/emit/backend_push.rs        |  49 +---
 control_plane/src/emit/mod.rs                 |  48 +---
 control_plane/src/emit/otap.rs                |  23 +-
 control_plane/src/emit/stage_config.rs        | 223 ++++--------------
 control_plane/src/emit/telegraf.rs            |  10 +-
 control_plane/src/main.rs                     | 117 ++-------
 control_plane/src/opamp/mod.rs                |   4 +-
 .../src/physical/colored_dag/allocator.rs     |   6 +-
 control_plane/src/physical/colored_dag/dag.rs |  38 +--
 .../src/physical/colored_dag/emitter.rs       |  57 ++---
 control_plane/src/physical/colored_dag/mod.rs |  41 +---
 .../src/physical/colored_dag/stage_id.rs      |  53 +----
 .../src/physical/deployment_cost/mod.rs       |   3 -
 .../deployment_cost/sketch_capability.rs      |  13 +-
 .../src/physical/deployment_cost/wire.rs      |  58 +----
 .../src/physical/post_asap/cost_model.rs      |  38 +--
 .../src/physical/post_asap/deployment_expr.rs |  41 +---
 control_plane/src/physical/post_asap/lower.rs |  44 +---
 .../src/physical/post_asap/matcher.rs         |   7 +-
 control_plane/src/physical/post_asap/tests.rs |  48 +---
 .../src/physical/runtime_capability.rs        |  67 +-----
 control_plane/src/physical/stage_split.rs     |  14 +-
 .../src/physical/workload_planner.rs          |  37 +--
 control_plane/src/query_parser/mod.rs         |  36 +--
 control_plane/src/replan.rs                   |  20 +-
 control_plane/src/types.rs                    |  15 +-
 control_plane/src/types_v2.rs                 |  18 +-
 control_plane/src/workload.rs                 |  44 +---
 crates/asap_types/src/aggregation_config.rs   |  13 +-
 crates/asap_types/src/aggregation_type.rs     |  22 +-
 crates/asap_types/src/enums.rs                |  22 +-
 crates/asap_types/src/policy_fingerprint.rs   |   9 +-
 data_plane/src/drivers/ingest/otel.rs         |  43 +---
 .../src/drivers/ingest/series_resolver.rs     |  16 +-
 data_plane/src/main.rs                        | 134 ++---------
 data_plane/src/monitor/coordinator.rs         |  35 +--
 data_plane/src/monitor/mod.rs                 |  36 +--
 .../precompute_engine/accumulator_factory.rs  |  22 +-
 data_plane/src/precompute_engine/config.rs    |   9 +-
 data_plane/src/precompute_engine/engine.rs    |  10 +-
 .../src/precompute_engine/ingest_handler.rs   |  36 +--
 .../operators/count_sketch_accumulator.rs     |  32 +--
 .../src/precompute_engine/output_sink.rs      |  17 +-
 data_plane/src/precompute_engine/worker.rs    |  17 +-
 .../query_engines/asap_query_engine/engine.rs | 114 ++-------
 .../asap_query_engine/live_serve.rs           |  36 +--
 .../query_engines/asap_query_engine/mod.rs    |  14 +-
 .../asap_query_engine/post_asap_readout.rs    |  51 +---
 .../asap_query_engine/summary_exec.rs         |  32 +--
 .../asap_query_engine/summary_executor.rs     |  40 +---
 .../routing/backend_storage_routing.rs        | 124 +---------
 .../routing/capability_matching.rs            |   4 +-
 .../routing/query_engine_routing.rs           |  20 +-
 .../thanos_query_engine/forward.rs            |   2 +-
 .../src/storage_engines/sketch_db/accuracy.rs |   9 +-
 .../storage_engines/sketch_db/backfill/mod.rs |  61 +----
 .../sketch_db/backfill/processor.rs           | 108 ++-------
 .../sketch_db/backfill/prometheus_reader.rs   |   2 +-
 .../sketch_db/backfill/service.rs             |  16 +-
 .../sketch_db/backfill/window_builder.rs      |  51 +---
 .../sketch_db/backfill/worker.rs              |  68 +-----
 .../src/storage_engines/sketch_db/data/mod.rs |  26 +-
 .../sketch_db/index/epoch_columnar.rs         |  39 +--
 .../storage_engines/sketch_db/index/mod.rs    |  65 ++---
 .../sketch_db/lifecycle/eviction.rs           |  65 +----
 .../sketch_db/lifecycle/mod.rs                |  24 +-
 .../sketch_db/lifecycle/reconcile.rs          |  35 +--
 .../src/storage_engines/sketch_db/mod.rs      |  32 +--
 .../sketch_db/query/asap_tier_result.rs       |  17 +-
 .../storage_engines/sketch_db/query/mod.rs    |  43 +---
 .../sketch_db/query/timeline.rs               |  44 +---
 data_plane/src/storage_engines/traits.rs      |   5 +-
 .../types/precomputed_output.rs               |  13 +-
 .../storage_engines/types/streaming_config.rs |   7 +-
 data_plane/src/tests/mod.rs                   |   7 -
 .../tests/test_utilities/engine_factories.rs  |  18 +-
 data_plane/src/tests/test_utilities/mod.rs    |   8 +-
 79 files changed, 490 insertions(+), 2411 deletions(-)

diff --git a/control_plane/src/asap_tier_implement.rs b/control_plane/src/asap_tier_implement.rs
index 02809866a..48853ab83 100644
--- a/control_plane/src/asap_tier_implement.rs
+++ b/control_plane/src/asap_tier_implement.rs
@@ -213,12 +213,7 @@ mod tests {
 
     #[test]
     fn bare_selector_has_no_aggregate_root_to_implement() {
-        // L1 adoption (design-target-architecture.md Part B), accepted
-        // behavior change -- see
-        // asap_tier_analysis::bare_selector_is_no_longer_asap_tier_answerable's
-        // comment: `lower_promql` doesn't implicitly wrap a bare selector
-        // in `Aggregate { Sum }` the way the retired local parser did, so
-        // there's no `Aggregate` node here at all to find a root at.
+        // A bare selector has no `Aggregate` node, so there is no ASAP-tier root.
         let roots =
             implement_promql_for_asap_tier("http_requests_total").expect("parses and implements");
         assert!(roots.is_empty(), "{roots:?}");
@@ -324,16 +319,8 @@ mod tests {
     /// behavior shift.
     #[test]
     fn implement_frequency_as_agg_test() {
-        // Per this test's own prior instructions: the gap it used to
-        // document (under-realizing to `Logical` because `asap-plan` had
-        // no `Extension`/`Frequency` opinion) is now closed -- not via an
-        // `Extension` hook, but because L1 adoption
-        // (design-target-architecture.md Part B) makes `count_over_time`
-        // lower directly to `AggIntent::Count { accuracy: Epsilon(...) }`
-        // (a real, first-class, non-exact intent) rather than needing
-        // this deployment's `Frequency` extension wrapper at all --
-        // `asap-plan` realizes a non-exact `Count` as a real CMS-backed
-        // `SummaryAgg` + `SummaryEstimate` on its own.
+        // Approximate `count_over_time` lowers to a first-class `Count` intent,
+        // which Planner realizes as CMS-backed `SummaryAgg` + `SummaryEstimate`.
         let roots = implement_promql_for_asap_tier("count_over_time(http_requests_total[5m])")
             .expect("parses and implements");
         assert_eq!(roots.len(), 1);
diff --git a/control_plane/src/backend_client.rs b/control_plane/src/backend_client.rs
index 75841913c..13e2179ca 100644
--- a/control_plane/src/backend_client.rs
+++ b/control_plane/src/backend_client.rs
@@ -167,14 +167,8 @@ impl BackendClient {
         }
     }
 
-    /// Phase C (MVP v6) variant of [`Self::push_streaming_config`]
-    /// that POSTs `application/json`. The typed L5
-    /// `emit_backend_streaming_config_json` emitter produces a `serde_json::Value`
-    /// rather than a YAML document, and the ASAPQuery-backend's
-    /// `/api/v1/streaming-config` endpoint accepts both content types
-    /// (PR #297 / Phase B documents the JSON shape). Same 2xx-or-error
-    /// contract as the YAML variant; same fire-and-forget semantics
-    /// at the call site.
+    /// Post streaming configuration as `application/json`. The backend accepts
+    /// both JSON and YAML; a non-2xx response is an error for the caller to log.
     pub async fn post_streaming_config_json(&self, json: String) -> Result<()> {
         debug!(
             endpoint = %self.endpoint,
@@ -280,22 +274,9 @@ impl BackendClient {
         }
     }
 
-    /// Phase α (MVP) sibling of [`Self::post_streaming_config_json`]:
-    /// POSTs the control-plane-emitted `BackendStorageRouting` JSON
-    /// document to the backend's `POST /api/v1/storage_routing`
-    /// endpoint. The backend hot-loads the routing table and the next
-    /// instant query consults the new table.
-    ///
-    /// Endpoint resolution: the field [`Self::endpoint`] is the
-    /// control plane's configured streaming-config endpoint (e.g.
-    /// `http://backend.svc:8088/api/v1/streaming-config`). We rewrite
-    /// the path component from `/api/v1/streaming-config` to
-    /// `/api/v1/storage_routing` so operators only configure one
-    /// `CONTROL_PLANE_BACKEND_ENDPOINT` env var and both pushes land
-    /// at the same backend host. URLs that don't end in
-    /// `/api/v1/streaming-config` are passed through unchanged
-    /// (a test-mode escape hatch — the unit test below builds a
-    /// mock URL ending in `/storage_routing` directly).
+    /// Post backend storage-routing JSON. Derive the URL by replacing the
+    /// `/api/v1/streaming-config` suffix with `/api/v1/storage_routing`; URLs
+    /// without that suffix are used verbatim.
     pub async fn post_storage_routing_json(&self, json: String) -> Result<()> {
         let url = derive_storage_routing_url(&self.endpoint);
         debug!(
@@ -533,7 +514,7 @@ mod tests {
         push_or_log(&client, "cpu_usage", "content".to_string()).await;
     }
 
-    /// Phase C: the JSON variant POSTs the body verbatim, returns
+    /// the JSON variant POSTs the body verbatim, returns
     /// `Ok(())` on a 2xx, and surfaces non-2xx as `Err`. Mock backend
     /// captures the body so we can verify it round-trips.
     #[tokio::test]
@@ -553,7 +534,7 @@ mod tests {
         assert_eq!(received[0], json);
     }
 
-    /// Phase C: non-2xx from the backend surfaces as an error so the
+    /// non-2xx from the backend surfaces as an error so the
     /// caller (handle_plan) can log + move on.
     #[tokio::test]
     async fn json_post_non_2xx_is_error() {
@@ -567,7 +548,7 @@ mod tests {
         assert!(msg.contains("400"), "error msg should mention 400: {msg}");
     }
 
-    /// Phase α: storage-routing-URL derivation rewrites the path
+    /// storage-routing-URL derivation rewrites the path
     /// component when the configured endpoint ends in
     /// `/api/v1/streaming-config`, leaving everything else untouched.
     #[test]
@@ -648,7 +629,7 @@ mod tests {
         server.abort();
     }
 
-    /// Phase α: full happy path. A mock backend hosts the storage
+    /// full happy path. A mock backend hosts the storage
     /// routing endpoint; the client POSTs the control-plane-emitted JSON
     /// and the body round-trips verbatim. Mirrors `json_post_round_trips_body`.
     async fn start_mock_routing_backend(
diff --git a/control_plane/src/emit/backend_push.rs b/control_plane/src/emit/backend_push.rs
index 9be93c761..5efc89971 100644
--- a/control_plane/src/emit/backend_push.rs
+++ b/control_plane/src/emit/backend_push.rs
@@ -1,42 +1,13 @@
-//! Typed cumulative push of `BackendStageConfig` to the ASAPQuery-backend.
+//! Cumulative backend configuration push shared by planning and replanning.
 //!
-//! Single entrypoint — [`post_typed_backend_for_role`] — invoked from
-//! every plan-emit cycle (HTTP `POST /api/v1/plan`, the replanner's
-//! plan-expiry / SLA-violation triggers, startup pre-pop tick, OpAMP
-//! on-connect tick). It:
+//! Each push updates the per-`(metric, role)` cache, concatenates all aggregations
+//! and readouts in deterministic order, then posts streaming configuration.
+//! Storage routing merges those entries by metric before posting. Both endpoints
+//! replace their configuration atomically, so a push must preserve sibling roles
+//! and metrics.
 //!
-//!   1. Updates the per-`(metric, role)` cache with the new
-//!      `BackendStageConfig`.
-//!   2. Builds a **cumulative** `BackendStageConfig` whose
-//!      `aggregations` + `readouts` concatenate every cache entry's,
-//!      ordered deterministically (`(metric, role.as_str())` ascending)
-//!      so the emitted JSON body is reproducible across runs and tests.
-//!   3. POSTs the cumulative streaming-config JSON to
-//!      `/api/v1/streaming-config` — the data plane's atomic
-//!      `handle.swap(new_config)` then installs every role's
-//!      aggregations simultaneously.
-//!   4. Groups cache entries by metric, merges each metric's
-//!      `BackendStageConfig`s, and POSTs the per-metric merged routing
-//!      table to `/api/v1/storage_routing`.
-//!
-//! **Why one helper, not two paths**: prior to Option B the control
-//! plane had two emit paths into the backend:
-//!
-//!   * the typed cumulative path from `handle_plan` (post PR #287) —
-//!     correct under the data plane's swap semantics;
-//!   * the legacy single-aggregation path from `Replanner`
-//!     (`generate_streaming_config_yaml`) — emits ONE aggregation per
-//!     POST. Under the swap, this WIPES the cumulative state on the
-//!     backend the moment plan-expiry or accuracy-violation fires it.
-//!
-//! Option B unifies both call sites through this helper so the swap
-//! semantics are honoured at every emit cycle, and the legacy YAML
-//! emitter is retired.
-//!
-//! Fire-and-forget contract: every error (emit failure, HTTP transport
-//! error, non-2xx response) logs at WARN and returns — never panics,
-//! never propagates. The next replan cycle retries with the latest
-//! plan.
+//! Emission and transport errors log at WARN and return. The next planning cycle
+//! retries with the latest configuration.
 
 use std::collections::{BTreeMap, HashMap};
 // `Future` is only referenced by the now-test-only `retry_transient`
@@ -1005,7 +976,7 @@ mod tests {
     /// re-plan, so the restarted backend recovers its config.
     #[tokio::test]
     async fn repost_after_simulated_backend_reset_re_pushes_full_config() {
-        // Phase 1: initial plan lands on the first backend instance.
+        // initial plan lands on the first backend instance.
         let (url1, mock1) =
             start_dual_mock(axum::http::StatusCode::OK, axum::http::StatusCode::OK).await;
         let client1 = StdArc::new(BackendClient::new(url1));
@@ -1022,7 +993,7 @@ mod tests {
         assert_eq!(mock1.streaming_hits.load(StdOrdering::SeqCst), 1);
         assert_eq!(mock1.routing_hits.load(StdOrdering::SeqCst), 1);
 
-        // Phase 2: the backend silently restarts — model it as a brand-new
+        // the backend silently restarts — model it as a brand-new
         // mock with zero recorded hits. NOTHING expires, NO replan fires.
         let (url2, mock2) =
             start_dual_mock(axum::http::StatusCode::OK, axum::http::StatusCode::OK).await;
diff --git a/control_plane/src/emit/mod.rs b/control_plane/src/emit/mod.rs
index 8a7e1db49..edbcf3791 100644
--- a/control_plane/src/emit/mod.rs
+++ b/control_plane/src/emit/mod.rs
@@ -1,19 +1,5 @@
-//! `emit/` — per-deployment-model plan emitters (L5 output side).
-//!
-//! Per `control_plane/docs/design.md` §5 `core::emit`. The 2026-05
-//! layered-cleanup refactor consolidated the former
-//! `controller/src/config/` directory here. Mapping:
-//!
-//! | Old path | New path |
-//! |---|---|
-//! | `config/agent.rs` | [`agent`] |
-//! | `config/backend.rs` | *retired — emitted YAML for a "backend-role" OTel merge collector tier that was never deployed; superseded by the typed L5's [`stage_config::emit_backend_streaming_config_json`] which posts to asapquery-backend's precompute engine over HTTP* |
-//! | `config/asapquery_backend.rs` | *retired — `generate_streaming_config_yaml` was the legacy single-aggregation `CollectionPlan`-shaped emitter for `POST /api/v1/streaming-config`; under the data plane's atomic `handle.swap(new_config)` it would WIPE sibling `(metric, role)` aggregations on every fire. Replaced by [`backend_push::post_typed_backend_for_role`], which posts a cumulative typed `BackendStageConfig` derived from the shared per-`(metric, role)` cache* |
-//! | *(new)* | [`backend_push`] |
-//! | `config/stage_config.rs` | [`stage_config`] (TODO: split into `opamp` + `streaming_config` + `inference_config` per design.md §5; deferred from refactor 2026-05 because the 3,020-line monolith mixes OTel-collector YAML emit, ASAPQuery-backend JSON emit, and shared internals — clean split needs ownership reorganisation, not file renames) |
-//! | `config/stage_config_otap.rs` | [`otap`] |
-//! | `config/stage_config_telegraf.rs` | [`telegraf`] |
-//! | `config/workloads.rs` | [`crate::workload`] (top-level — design.md §5 puts `workload` next to `emit`, not inside it) |
+//! Per-deployment plan emitters. Typed stage configs become collector
+//! configuration, backend streaming configuration, and storage routing.
 
 pub mod agent;
 pub mod backend_push;
@@ -50,25 +36,9 @@ use anyhow::Result;
 use planner_types::post_asap::{SketchAlgorithm, SummaryExpr, SummaryNode};
 use std::rc::Rc;
 
-/// Phase ε.1.5 — which edge runtime an agent identifies as.
-///
-/// Today every agent the controller has built for runs the OTel-collector
-/// (`AsapOtel`); Phase ε.1.5 adds the two new runtime variants the
-/// per-runtime emitters target. The runtime is reported by the agent on
-/// OpAMP `on_connect` (header `X-Agent-Runtime`); when absent (legacy
-/// agents) the controller defaults to `AsapOtel` so the existing
-/// behaviour is preserved.
-///
-/// Phase ε.1.5 commits the enum + emit-dispatch function. Threading the
-/// runtime through OpAMP `on_connect` and into the typed L5 emit path
-/// is a follow-up — the emitters can be exercised in isolation today
-/// (the Phase ε.1.5 test suite does exactly that).
-///
-/// Naming history: the variants were originally `Sketchcollector` /
-/// `Sketchotap` / `Sketchtelegraf`; the rename to `AsapOtel` /
-/// `AsapOtap` / `AsapTelegraf` (PR `refactor/rename-edge-runtimes-...`)
-/// drops the v0 `sketch*` prefix in favour of the symmetric `asap-*`
-/// namespace. `from_header` accepts both forms during transition.
+/// Edge runtime reported through the OpAMP `X-Agent-Runtime` header.
+/// Missing headers default to `AsapOtel`. `from_header` accepts both
+/// `asap-*` and `sketch*` names for compatibility.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 #[derive(Default)]
@@ -97,7 +67,7 @@ impl AgentRuntime {
     }
 }
 
-/// Phase ε.1.5 — dispatch the edge emit by agent runtime. Mirrors
+/// dispatch the edge emit by agent runtime. Mirrors
 /// `emit_edge_yaml`'s `(cfg, opamp_endpoint) -> String` shape; the OTAP
 /// and Telegraf emitters take an additional optional Prometheus URL
 /// override which we pass through `prometheus_url`.
@@ -300,11 +270,7 @@ fn extract_from_plan(plan: &PostAsapPlan) -> Option<SketchAlgorithm> {
 
 fn extract_from_node(node: &Rc<SummaryNode>) -> Option<SketchAlgorithm> {
     match &node.expr {
-        // `SummaryAgg`'s `kind`/`params` collapsed into one `family:
-        // SummaryFamilyType` field (ASAPPlanner#218 -- see
-        // control_plane/docs/design-asapplanner-pin-migration.md); the
-        // exact-vs-sketch check this used to need `is_exact_accumulator`
-        // for is now which enum variant `family` is.
+        // The `family` variant distinguishes exact accumulators from sketches.
         SummaryExpr::SummaryAgg {
             family: planner_types::post_asap::SummaryFamilyType::Sketch(kind, _),
             ..
diff --git a/control_plane/src/emit/otap.rs b/control_plane/src/emit/otap.rs
index 6d377c011..b26d14354 100644
--- a/control_plane/src/emit/otap.rs
+++ b/control_plane/src/emit/otap.rs
@@ -1,4 +1,4 @@
-//! Phase ε.1.5 — OTAP Dataflow DAG YAML emitter (per-runtime mirror of
+//! OTAP Dataflow DAG YAML emitter (per-runtime mirror of
 //! [`super::stage_config::emit_edge_yaml`]).
 //!
 //! `asap-otap` uses the otap-dataflow Rust runtime; its config surface is
@@ -9,10 +9,7 @@
 //! and registers under the URN `urn:otel:exporter:otlp_http` via
 //! `linkme`'s `distributed_slice(OTAP_EXPORTER_FACTORIES)`.
 //!
-//! Three modes (the placement decision itself is made upstream in
-//! `stage_split`; the `BindMode`-shaped selector Phase ε.1 sketched out
-//! in `physical::deployment_cost::wire` was never wired in and was removed in the
-//! 2026-07 retirement pass — see that module's doc):
+//! Placement modes selected by the upstream stage splitter:
 //!
 //! 1. `SketchAtEdge` — DAG includes a sketch processor node between the
 //!    OTLP receiver and the OTLP gRPC exporter to the gateway. (The
@@ -26,7 +23,7 @@
 //!    (`/api/v1/otlp/v1/metrics`).
 //!
 //! The function consumes the same [`EdgeStageConfig`] the OTel-collector
-//! emitter does — Phase ε.1.5 keeps the typed L5 plan as the single
+//! emitter does, keeping the typed plan as the single
 //! source of truth across all three runtimes. The emitter dispatches per
 //! `EdgeStageConfig` via the same `prometheus_archive_metrics` /
 //! `sketch_processors` signals the OTel-collector emitter uses (Mode 3
@@ -60,19 +57,11 @@ const URN_OTLP_GRPC_EXPORTER: &str = "exporter:otlp_grpc";
 /// URN of the OTLP receiver (gRPC + HTTP).
 const URN_OTLP_RECEIVER: &str = "receiver:otlp";
 
-/// URN of the asap_sketches processor registered in the otap-patch tree.
-/// Phase ε.1.5 wires the URN abstractly; the binary side lands the
-/// plugin in `otap-patch/plugins/asap_sketches/` per
-/// [`docs/design-asap-otap-rust-integration.md`].
+/// URN of the sketch processor registered by the OTAP plugin.
 const URN_ASAP_SKETCHES_PROCESSOR: &str = "processor:asap_sketches";
 
-// ── DAG YAML structural types ────────────────────────────────────────────────
-//
-// These mirror the otap-dataflow `engine`/`groups`/`pipelines`/`nodes`
-// schema in `otel-arrow/rust/otap-dataflow/configs/*.yaml`. We keep a
-// minimal set to round-trip; the full schema (channel_capacity policies,
-// engine settings, etc.) is left at struct defaults — Phase ε.1.5 only
-// commits the wiring shape, not policy.
+// Structural subset of the OTAP DAG configuration. Omitted engine and channel
+// policy fields retain their runtime defaults.
 
 #[derive(Serialize)]
 struct OtapDag {
diff --git a/control_plane/src/emit/stage_config.rs b/control_plane/src/emit/stage_config.rs
index 6d94e1643..a4ab229e8 100644
--- a/control_plane/src/emit/stage_config.rs
+++ b/control_plane/src/emit/stage_config.rs
@@ -1,50 +1,12 @@
-//! Phase B (MVP v6) — turn a typed L5 [`StageConfig`] map (produced by
-//! [`crate::physical::colored_dag::ThreeStageEmitter`]) into the **wire bytes** the
-//! three executors actually consume:
+//! Turn typed stage configs into wire configuration for edge, gateway, and backend.
 //!
-//! - [`emit_edge_yaml`] → OTel-collector YAML for the edge agent (OTLP
-//!   receiver → per-sketch processor(s) → OTLP exporter to gateway).
-//! - [`emit_gateway_yaml`] → OTel-collector YAML for the gateway
-//!   aggregator (OTLP receiver → per-family `*merge` processor(s) → OTLP
-//!   exporter to backend).
-//! - [`emit_backend_streaming_config_json`] → JSON document matching the
-//!   ASAPQuery-backend `POST /api/v1/streaming-config` API surface,
-//!   sourced from the typed [`BackendStageConfig`]. The legacy
-//!   `generate_streaming_config_yaml` `CollectionPlan`-shaped emitter
-//!   was retired in the Option B unification (see
-//!   [`crate::emit::backend_push`]).
-//! - [`emit_backend_storage_routing`] → JSON document matching the
-//!   ASAPQuery-backend `POST /api/v1/storage_routing` API surface —
-//!   per-metric query-shape → engine routing table (Phase α). Sources
-//!   the per-metric sketch families from the typed [`BackendStageConfig`]
-//!   inputs and turns them into `(metric, [target])` rows the backend's
-//!   HTTP query handler consults via `BackendStorageRouting::lookup_with_shape`.
+//! * [`emit_edge_yaml`] and [`emit_gateway_yaml`] produce collector YAML.
+//! * [`emit_backend_streaming_config_json`] produces precompute configuration.
+//! * [`emit_backend_storage_routing`] maps metrics and query shapes to engines.
 //!
-//! These four functions are deliberately **stage-shaped**, not
-//! plan-shaped: the typed L5 emitter has already split the PhysicalExpr
-//! across edge / gateway / backend, so each function only sees the slice
-//! that's relevant to its executor. The legacy `agent.rs` emitter still
-//! operates on the flat `AgentCollectorConfig`; the legacy backend
-//! emitter targeted a "backend-role" OTel merge collector tier that was
-//! never deployed and has been retired — typed L5 routes `StageId::Backend`
-//! directly to asapquery-backend's precompute engine over HTTP via
-//! `emit_backend_streaming_config_json`.
-//!
-//! All three are pure transformations: no I/O. The `opamp_endpoint`
-//! parameter is the controller's WebSocket URL the emitted YAML's
-//! `extensions.opamp` block must point at; the caller threads it
-//! through from `AppState::opamp_endpoint`. The `agent_id` parameter
-//! is the identity the agent presents in the `X-Agent-ID` WS header
-//! when it reconnects after a controller-pushed restart (Issue #2 —
-//! without this header the controller's OpAMP server can't re-identify
-//! the agent). Broadcast callers that don't have a single agent in
-//! scope pass the literal placeholder `"$AGENT_ID"` and rely on the
-//! agent container's env to expand it at boot.
-//!
-//! NOTE: the memory_limiter soft threshold the 5-sketch routing path
-//! emits can be tuned via the controller's `ASAP_AGENT_MEMORY_LIMIT_MIB`
-//! env var (default 1280 MiB). Operators bumping the agent container's
-//! cgroup limit raise both together. See `emit_edge_yaml_5sketch_routing`.
+//! These are pure transformations. Callers supply the OpAMP endpoint and agent
+//! identity; broadcast configs use `$AGENT_ID` for expansion by each collector.
+//! Backend pushes go through the cumulative helper in `backend_push`.
 
 use anyhow::{Context, Result};
 use serde::Serialize;
@@ -179,26 +141,9 @@ pub fn clamp_window_secs(w: Option<u64>) -> Option<u64> {
     w.map(|s| s.clamp(MIN_WINDOW_SECS, MAX_WINDOW_SECS))
 }
 
-/// Process-level gate selecting the FUSED single-pipeline `asap_edge`
-/// edge wire shape (issue #46) over the legacy `routing`-connector
-/// per-family fan-out.
-///
-/// **Default OFF** so the established 5-sketch routing emit (and its
-/// large unit-test surface) is unchanged for callers who haven't
-/// migrated the agent build yet. Set `ASAP_EDGE_FUSED=1` (or
-/// `true` / `yes`) on the controller process to switch every
-/// `metric_to_family`-populated edge config to the fused
-/// `[memory_limiter, cumulativetodelta, asap_edge]` pipeline that the
-/// new fused agent processor consumes.
-///
-/// We gate on an env var (mirroring `typed_stage_split_enabled()` /
-/// `ASAP_AGENT_MEMORY_LIMIT_MIB`) rather than a new `EdgeStageConfig`
-/// field so the change is additive: no struct-literal churn across the
-/// ~17 construction sites, no serde wire-shape bump, and the two emit
-/// paths read the IDENTICAL `cfg` fields. The flag is the canonical
-/// migration switch — once the fused agent build is the default
-/// deployment the gate's default flips to ON (and the routing path is
-/// retired).
+/// Process-level switch for the fused `asap_edge` pipeline. Set
+/// `ASAP_EDGE_FUSED=1` (or `true` / `yes`) to enable it. Default is off.
+/// Both fused and per-family routing consume the same `EdgeStageConfig`.
 pub fn fused_asap_edge_enabled() -> bool {
     matches!(
         std::env::var("ASAP_EDGE_FUSED").as_deref(),
@@ -208,18 +153,9 @@ pub fn fused_asap_edge_enabled() -> bool {
 
 // ── Public API ────────────────────────────────────────────────────────────────
 
-/// Build the OTel-collector YAML for an edge agent from the typed L5
-/// [`EdgeStageConfig`] payload.
-///
-/// The `opamp_endpoint` is embedded under `extensions.opamp.server.ws.endpoint`
-/// so the agent can receive runtime config updates without restart.
-///
-/// The emitter does NOT resolve `ExportTarget::Stage(_)` to a concrete
-/// network address; Phase C plumbs a `DeploymentConstraints` resolver
-/// that maps the symbolic stage role to e.g. `gateway:4317`. Until
-/// then, we emit a documented placeholder (`gateway:4317`) so the YAML
-/// is syntactically valid and round-trips through Otel's loader for
-/// integration tests.
+/// Build collector YAML from a typed [`EdgeStageConfig`]. The OpAMP endpoint
+/// lets the agent receive configuration updates. Symbolic export targets use
+/// default hostnames unless an explicit endpoint is supplied.
 pub fn emit_edge_yaml(
     cfg: &EdgeStageConfig,
     opamp_endpoint: &str,
@@ -388,7 +324,7 @@ pub fn emit_edge_yaml(
     // ── Phase ε.1 Mode 3 / Phase 3.2.5 Bug (b) — per-pipeline routing ─────
     // Two routing axes can fire from a single edge agent:
     //
-    //   * Phase ε.1: Mode-3 metrics carry `asap.mode = prometheus_archive`
+    //   * Mode-3 metrics carry `asap.mode = prometheus_archive`
     //     as a data-point attribute and dispatch to the Prometheus OTLP
     //     receiver via a separate `otlphttp/prometheus` exporter.
     //   * Phase 3.2.5 Bug (b): warm-passthrough metrics (the freshness
@@ -650,25 +586,10 @@ pub fn emit_gateway_yaml(
     serde_yaml::to_string(&doc).context("serialize gateway stage config")
 }
 
-/// Build the JSON document the ASAPQuery-backend's
-/// `POST /api/v1/streaming-config` endpoint accepts, sourced from the
-/// typed L5 [`BackendStageConfig`].
+/// Build backend streaming-config JSON from [`BackendStageConfig`].
 ///
-/// Output shape: a top-level `aggregations` array of
-/// `{ aggregationType, aggregationSubType, metric, labels, parameters,
-/// windowSize, windowType, spatialFilter, aggregationInput }` rows.
-/// (The legacy `generate_streaming_config_yaml` YAML emitter that
-/// shipped the same shape from a `CollectionPlan` was retired in the
-/// Option B unification — see [`crate::emit::backend_push`].)
-/// `aggregationId` is **not** emitted — identity is content-addressed in
-/// the backend via `PolicyFingerprint(u64)`.
-/// We additionally surface a parallel `readouts` array so the backend's
-/// query engine can prepare per-readout dispatch entries up-front (the
-/// existing YAML form has no readouts list because the legacy planner
-/// materialises one aggregation per metric and infers readouts from the
-/// PromQL query at execution time; Phase B's typed `BackendStageConfig`
-/// carries the readouts explicitly, so we ship them too — backends that
-/// don't recognise the field will ignore it without erroring).
+/// Emit aggregation rows and explicit readouts. Omit `aggregationId`: the backend
+/// derives policy identity from configuration content.
 pub fn emit_backend_streaming_config_json(
     cfg: &BackendStageConfig,
     monitors: &[crate::emit::monitor::MonitorIntent],
@@ -704,7 +625,7 @@ pub fn emit_backend_streaming_config_json(
     Ok(doc)
 }
 
-/// Phase α (MVP): build the JSON document the ASAPQuery-backend's
+/// build the JSON document the ASAPQuery-backend's
 /// `POST /api/v1/storage_routing` endpoint accepts, sourced from the
 /// typed L5 [`BackendStageConfig`] payloads emitted by [`crate::planner::stage_split`].
 ///
@@ -736,7 +657,7 @@ pub fn emit_backend_streaming_config_json(
 /// }
 /// ```
 ///
-/// ## Classification rules (Phase α)
+/// ## Classification rules
 ///
 /// For each `(metric, BackendStageConfig)` we derive a target list by
 /// inspecting the L4 sketch families landed at the backend:
@@ -805,7 +726,7 @@ pub fn emit_backend_storage_routing_for_tenant(
     }))
 }
 
-/// Phase ε.1 — same as [`emit_backend_storage_routing`] but also
+/// same as [`emit_backend_storage_routing`] but also
 /// emits `thanos_query` engine entries for Mode 3 metrics.
 ///
 /// Mode-3 metrics have NO `BackendStageConfig` entry (the backend doesn't
@@ -902,10 +823,7 @@ fn build_routing_entry(metric_name: &str, cfg: &BackendStageConfig) -> JsonValue
     if has_hll {
         warm_shapes.push("count");
     }
-    // Heap-bearing kinds count too — `SummaryKind` (unlike the retired
-    // `physical::post_asap::SummaryKind`) promotes `with_heap` to a distinct
-    // identity variant, but a topk-bound Count-Sketch/CMS aggregation
-    // still needs to register here exactly as it did before the split.
+    // Heap-bearing frequency sketches also contribute their routing capability.
     let has_count_sketch = algorithms.iter().any(|k| {
         matches!(
             k,
@@ -1330,38 +1248,13 @@ fn emit_edge_yaml_5sketch_routing(
         }
     }
 
-    // ── ASAPCollector#403: edge-aggregate Sum-role counters ────────────────
+    // Sum-role counters with grouping labels and no sketch-family assignment
+    // use a per-metric sum pipeline. This ships one series per grouping tuple.
+    // Ungrouped counters remain raw passthrough; sketched counters keep their
+    // sketch pipeline.
     //
-    // A Sum-role metric (in `cumulative_counter_metrics`) whose marquee
-    // queries are `sum by (<labels>) (...)` previously fell through the
-    // routing connector's `default_pipelines` into `raw_passthrough` (no
-    // aggregation): every counter datapoint across the full wire-attr
-    // cardinality (e.g. ~10k zone×rack×node×pod series) streamed
-    // continuously to the backend, which did the Sum-by-grouping fan-in
-    // centrally. That inverts the edge-aggregation value prop and was the
-    // dominant driver of the asap arm's backend-ingress blowup
-    // (~12 Mbps of ~12.5 Mbps measured).
-    //
-    // Fix (mirrors the static agent config's `metrics/sum_aggregate`
-    // pipeline): for each Sum-role metric that (a) has grouping_labels
-    // declared and (b) is NOT routed to any sketch family, register a
-    // dedicated `metricstransform/sumby_<metric>` processor +
-    // `metrics/sum_aggregate_<metric>` pipeline and route the metric
-    // there instead of letting it default to raw_passthrough. The agent
-    // then ships one summed series per grouping-label tuple per flush
-    // window. The backend's `evaluate_exact_agg` produces the identical
-    // `sum by (<labels>)` and per-group `rate` answers at reduced
-    // cardinality.
-    //
-    // gorillas3 (cold-tier archive) still writes RAW full-cardinality
-    // samples on this pipeline BEFORE the metricstransform collapses the
-    // stream, preserving cold-fallback drill-down (e.g.
-    // `count(metric{<label>="..."})`).
-    //
-    // A metric already mapped to a sketch family is left on its
-    // sketch path (it isn't a plain Sum-role passthrough). A Sum-role
-    // metric with NO grouping labels keeps the raw_passthrough default
-    // (no grouping to aggregate by).
+    // Archive processing precedes grouping so cold queries retain full-cardinality
+    // raw samples for drill-down.
     let mut sum_aggregate_pipelines: Vec<(String, String)> = Vec::new();
     {
         let mut sum_metrics: Vec<&String> = cfg
@@ -1423,7 +1316,7 @@ fn emit_edge_yaml_5sketch_routing(
         ));
     }
 
-    // Phase ε.1 — Mode 3 prometheus-archive routing folds in via the
+    // Mode 3 prometheus-archive routing folds in via the
     // `asap.mode` attribute axis. The dedicated
     // `metrics/prometheus_archive` pipeline ships the metric to
     // Prometheus's native OTLP receiver via `otlphttp/prometheus`.
@@ -1586,7 +1479,7 @@ fn emit_edge_yaml_5sketch_routing(
         );
     }
 
-    // Phase ε.1 — Mode 3 prometheus-archive pipeline (raw passthrough
+    // Mode 3 prometheus-archive pipeline (raw passthrough
     // to the Prometheus OTLP exporter). No sketch processors; only the
     // Prometheus exporter target is referenced.
     if has_prometheus_archive {
@@ -2431,17 +2324,8 @@ fn build_gorillas3_yaml(window_secs: u64) -> String {
     let secret_key = env_or("ASAP_MINIO_SECRET_KEY", "asap-local-only");
     let tenant = env_or("ASAP_TENANT", "default");
     let tsdb_bucket = env_or("ASAP_GORILLA_TSDB_BUCKET", "asap-gorilla-tsdb");
-    // Note: `prefix_template` placeholders (`{tenant}`, `{metric}`,
-    // `{YYYY}`, …) are resolved by the gorillas3 processor at write
-    // time, not by the YAML loader — they stay as literal `{...}`
-    // tokens in the emitted YAML.
-    //
-    // Phase 2 (post-ASAPCollector#387): the legacy `bucket:` field is
-    // no longer read at runtime — only `tsdb_bucket:` (the TSDB block
-    // destination) drives the gorillas3 writer. We therefore stop
-    // emitting `bucket:` here. The agent's gorillas3 Config struct
-    // still carries a `Bucket` field for mapstructure compatibility,
-    // but it stays at its zero value, which is fine post-#387.
+    // The gorillas3 processor resolves prefix placeholders at write time; keep
+    // them literal in YAML. `tsdb_bucket` is the write destination.
     format!(
         "window_interval: {window_secs}s\n\
 drop_original: false\n\
@@ -2675,11 +2559,8 @@ fn build_default_edge_processor_block(
     build_edge_processor_block(&synthetic, window_secs, &[], metric_name_hint, sample_p)
 }
 
-/// Resolve an `ExportTarget` to a concrete `endpoint:port` string. Phase
-/// B uses documented placeholder hostnames (`data-plane:4317` for the
-/// edge→backend default; `gateway:4317` is reachable when a caller
-/// explicitly opts in via `default_host`) for symbolic stages — Phase C
-/// plumbs a real `DeploymentConstraints::executors()` resolver.
+/// Resolve an export target to `endpoint:port`. Symbolic stages use the
+/// caller's default host; explicit targets supply their own endpoint.
 fn resolve_export_endpoint(default_host: &str, target: &ExportTarget) -> String {
     // The backend/gateway OTLP ingest port is normally 4317. Single-host
     // deployments (e.g. the single-node MVP collapse) run the agent's OTLP
@@ -3077,14 +2958,8 @@ fn build_backend_readout_json(r: &BackendReadout) -> JsonValue {
     }
 }
 
-/// The wire-string key for a `SketchQuery::PointCount` readout.
-///
-/// `SampleValue` and `Wildcard` both wire to the legacy `"*"` sentinel
-/// (`physical::post_asap::rules::bind_cms_count`, retired by Step B, used the
-/// literal string `"*"` to mean "all rows / no specific key"; the L5
-/// emitter's per-group resolution already special-cases that string) —
-/// there's no real queryable column for a plain `Count`/`Frequency`
-/// readout in either case, so both collapse to the same sentinel.
+/// Wire key for a point-count readout. `SampleValue` and `Wildcard` map to
+/// `"*"`, the all-rows sentinel, because neither names a queryable column.
 fn column_ref_to_wire_key(col: &ColumnRef) -> String {
     match col {
         ColumnRef::Named(name) => name.clone(),
@@ -3093,19 +2968,9 @@ fn column_ref_to_wire_key(col: &ColumnRef) -> String {
     }
 }
 
-/// Collapse a heap-bearing `SketchAlgorithm` to its bare counterpart.
-/// Identity for every other kind.
-///
-/// The 5-sketch routing-connector edge YAML path (`emit_edge_yaml`'s
-/// `USE_5SKETCH_ROUTING` branch and its `metric_to_family` sibling)
-/// keys its fixed `FAMILY_ORDER` list and lookup maps on the 5 bare
-/// families only — matching the retired `physical::post_asap::SketchAlgorithm`,
-/// which had no heap-bearing variant at all (`with_heap` was a
-/// `SketchParams` field, invisible to anything keying on kind alone).
-/// A committed heap-bearing kind (`CmsWithHeap`/`CountSketchWithHeap`,
-/// from a topk binding) needs to normalize through this before it's
-/// used as a key or set member in that path, or it silently fails to
-/// match its bare `FAMILY_ORDER` entry.
+/// Normalize heap-bearing families to their bare counterpart for edge routing.
+/// The fixed family-order list and lookup maps use bare-family keys; a TopK
+/// binding must normalize before lookup so it reaches the correct processor.
 fn base_family(kind: &SketchAlgorithm) -> SketchAlgorithm {
     match kind {
         SketchAlgorithm::CmsWithHeap => SketchAlgorithm::Cms,
@@ -3682,7 +3547,7 @@ mod tests {
         assert!(yaml.contains("custom-gw:5317"), "{yaml}");
     }
 
-    // ── Phase α: BackendStorageRouting emitter tests ──────────────────────
+    // ── BackendStorageRouting emitter tests ──────────────────────
 
     /// Helper: build a single-aggregation BackendStageConfig of the
     /// requested kind. `aggregation_id` is hard-coded — the routing
@@ -4027,7 +3892,7 @@ mod tests {
         assert_eq!(targets[1]["engine"], "thanos_query");
     }
 
-    // ── Phase β: emit_backend_streaming_config_json snapshot for new pattern coverage ──
+    // ── emit_backend_streaming_config_json snapshot for new pattern coverage ──
     //
     // The archive-only L3 intents (Absent, Present, Delta, Deriv, …)
     // bind to `PhysicalExpr::Logical` rather than producing a `BackendAggregation`,
@@ -4205,7 +4070,7 @@ mod tests {
         assert_eq!(v["readouts"][0]["q"], 0.99);
     }
 
-    // ── Phase ε.1: three-mode wire shape tests ────────────────────────────
+    // ── three-mode wire shape tests ────────────────────────────
 
     /// Mode 1 (sketch at edge) keeps the existing aggregation_input
     /// default — `sketch_envelope` — so legacy plans round-trip
@@ -4309,7 +4174,7 @@ mod tests {
                 label_proj: vec!["service.name".to_string()],
             }],
             // RawAtEdgePrometheusArchive auto-populates the archive
-            // tier list as well (Phase 3.2.5): the Mode-3 metric also
+            // tier list as well: the Mode-3 metric also
             // lands in the Gorilla-S3 archive so the ASAP-tier engine
             // can serve last_over_time(...) queries.
             archive_tier_metrics: vec![ArchiveTierMetric {
@@ -4396,7 +4261,7 @@ mod tests {
             !yaml.contains("metrics/asap_tier"),
             "no Mode 3 → main pipeline keeps the legacy `metrics:` name\n{yaml}"
         );
-        // Phase 3.2.5 — without archive_tier_metrics no gorillas3 block.
+        // without archive_tier_metrics no gorillas3 block.
         assert!(
             !yaml.contains("gorillas3"),
             "no archive tier → no gorillas3 processor\n{yaml}"
@@ -5821,7 +5686,7 @@ mod tests {
         );
     }
 
-    // ── B1-downstream gorillas3 bucket Phase 2: drop `bucket:` ────────────
+    // ── B1-downstream gorillas3 bucket drop `bucket:` ────────────
 
     /// ASAPCollector#387 retired the gorillas3 `Bucket` field's
     /// runtime use — only `TSDBBucket` drives writes. The controller
diff --git a/control_plane/src/emit/telegraf.rs b/control_plane/src/emit/telegraf.rs
index 619dc7195..4c61fbecb 100644
--- a/control_plane/src/emit/telegraf.rs
+++ b/control_plane/src/emit/telegraf.rs
@@ -1,4 +1,4 @@
-//! Phase ε.1.5 — Telegraf TOML emitter (per-runtime mirror of
+//! Telegraf TOML emitter (per-runtime mirror of
 //! [`super::stage_config::emit_edge_yaml`]).
 //!
 //! `asap-telegraf` is the Telegraf-runtime variant of the ASAP edge
@@ -16,18 +16,14 @@
 //! * `outputs.http` — generic HTTP POST output. For Mode 3 we use this
 //!   with the `prometheusremotewrite` serializer so the agent can ship
 //!   raw samples to Prometheus's remote-write endpoint
-//!   (`/api/v1/write`). This is a documented Phase ε.1.5 deviation
-//!   from the OTel-collector path's `otlphttp/prometheus` exporter:
+//!   (`/api/v1/write`). This differs from the OTel-collector path's `otlphttp/prometheus` exporter:
 //!   Telegraf has no OTLP-HTTP serializer, but Prometheus's
 //!   remote-write endpoint accepts the same physical archive that the
 //!   OTLP receiver writes to, so the **archive contents end up
 //!   identical**. The wire framing differs; the storage outcome does
 //!   not.
 //!
-//! Three modes (the placement decision itself is made upstream in
-//! `stage_split`; the `BindMode`-shaped selector Phase ε.1 sketched out
-//! in `physical::deployment_cost::wire` was never wired in and was removed in the
-//! 2026-07 retirement pass — see that module's doc):
+//! Placement modes selected by the upstream stage splitter:
 //!
 //! 1. `SketchAtEdge` — `[[processors.allsketches]]` between
 //!    `[[inputs.opentelemetry]]` and `[[outputs.opentelemetry]]`.
diff --git a/control_plane/src/main.rs b/control_plane/src/main.rs
index 0ad1a2f8a..08790ef8d 100644
--- a/control_plane/src/main.rs
+++ b/control_plane/src/main.rs
@@ -73,57 +73,18 @@ struct AppState {
     /// input identity; incoming telemetry cannot supply its own descriptors.
     active_summary_catalog:
         Arc<tokio::sync::Mutex<Option<Arc<asap_types::summary_catalog::SummaryCatalog>>>>,
-    /// Phase C (MVP v6): shared `BackendClient` for posting
-    /// `StreamingConfig` JSON / YAML to the ASAPQuery-backend's
-    /// `POST /api/v1/streaming-config` endpoint. Phase B had this
-    /// only on the `Replanner`, so the typed L5 stage_split path in
-    /// `handle_plan` could only `info!`-log the backend JSON it
-    /// emitted. Sharing via `Arc` lets `AppState` and `Replanner`
-    /// both push without owning a duplicate client. `None` when
-    /// `CONTROLLER_BACKEND_ENDPOINT` is unset, matching the
-    /// pre-existing fire-and-forget contract.
+    /// Shared client for posting streaming configs from HTTP planning and replanning.
+    /// `None` when `CONTROLLER_BACKEND_ENDPOINT` is unset; pushes are then skipped.
     backend_client: Option<Arc<backend_client::BackendClient>>,
-    /// Per-`(metric, role)` `BackendStageConfig` cache used to emit
-    /// **cumulative** `StreamingConfig` AND `BackendStorageRouting`
-    /// JSON documents on every plan-emit cycle.
+    /// Per-`(metric, role)` cache for cumulative streaming configs and storage routing.
     ///
-    /// **Why this is (metric, role)-keyed** (B2 cumulative-emit follow-up
-    /// to PR #283): a single metric can carry MULTIPLE [`AggRole`]
-    /// entries (e.g. post-B2 the workload-registry pre-pop loop registers
-    /// `http_requests_total` against BOTH a DDSketch-Quantile role from
-    /// `quantile_over_time(...)` AND an ExactAgg-Sum role from
-    /// `sum by (zone) (http_requests_total)`). Pre-fix the cache was
-    /// keyed by metric name alone, so the second role's
-    /// `BackendStageConfig` overwrote the first. The data plane's
-    /// `POST /api/v1/streaming-config` handler is an atomic full
-    /// `handle.swap(new_config)` (see
-    /// `data_plane/src/drivers/query/servers/http.rs`), so the second
-    /// per-role POST destroys the first role's aggregations on the
-    /// backend → `sum by (zone) (http_requests_total)` returns
-    /// `ExactAgg(Sum) capability not satisfied`.
+    /// Both backend endpoints replace their whole configuration atomically, so each
+    /// push must include every planned metric and role. A metric may have several
+    /// roles: keying only by metric would discard sibling aggregations.
     ///
-    /// **Why this also matters for storage-routing**: `POST
-    /// /api/v1/storage_routing` is similarly an atomic per-tenant SWAP
-    /// — every push replaces the whole tenant's routing table. Pre-fix
-    /// the per-metric cache emitted a single-element `metrics:[…]`
-    /// document per `handle_plan` call, so when N metrics replanned in
-    /// sequence only the last metric's entry survived → archive-shape
-    /// queries fell to `default_engine: sketch_store` → `archive_miss`
-    /// for the other N-1 metrics.
-    ///
-    /// **Cumulative emit semantics** (post-fix): on every plan-emit
-    /// cycle the cache entry for the `(metric, role)` being planned is
-    /// updated, then:
-    ///   * Concatenate `aggregations` + `readouts` across ALL cache
-    ///     entries into a single cumulative `BackendStageConfig`, and
-    ///     post that one config to `/api/v1/streaming-config` so the
-    ///     data plane's swap installs every role's aggregations
-    ///     simultaneously.
-    ///   * Group cache entries by metric name and merge each metric's
-    ///     `BackendStageConfig`s (concat aggregations + readouts) into
-    ///     one entry per metric. Pass that per-metric list to
-    ///     `emit_backend_storage_routing` so a metric carrying both
-    ///     DDSketch + ExactAgg routes both shape families correctly.
+    /// Streaming-config emission concatenates all aggregations and readouts.
+    /// Storage-routing emission first merges roles by metric, so every sketch
+    /// family for that metric contributes to its routing entry.
     backend_routing_cache: Arc<Mutex<HashMap<(String, AggRole), BackendStageConfig>>>,
 }
 
@@ -136,15 +97,8 @@ async fn main() {
     let api_addr = std::env::var("CONTROLLER_ADDR").unwrap_or_else(|_| "0.0.0.0:8080".into());
     let opamp_addr =
         std::env::var("CONTROLLER_OPAMP_ADDR").unwrap_or_else(|_| "0.0.0.0:4320".into());
-    // The default tracks the compose service name in
-    // `ASAPCollector/deploy/mvp-singlenode/docker-compose/base.yml`,
-    // which is still `controller:` post Phase-9 single-binary
-    // refactor (both controller and backend ship from
-    // `asap/query-backend:dev`, but they bind separate listeners
-    // under separate compose service names). Using the post-reorg
-    // crate name `control_plane` here doesn't resolve under the
-    // canonical compose stack and bakes a broken endpoint into every
-    // agent yaml the controller emits.
+    // The default must match the compose service name `controller`; the crate
+    // name `control_plane` is not a resolvable hostname in the canonical stack.
     let opamp_ep = std::env::var("CONTROLLER_OPAMP_ENDPOINT")
         .unwrap_or_else(|_| "ws://controller:4320/v1/opamp".into());
     let scrape_interval = Duration::from_secs(
@@ -346,13 +300,8 @@ async fn main() {
         }
     }
 
-    // ── Phase C: shared BackendClient ─────────────────────────────────────────
-    // Built once at startup; shared between Replanner (existing path —
-    // pushes the StreamingConfig YAML on every successful replan) and
-    // AppState (Phase C — pushes the typed L5 backend JSON emitted by
-    // `emit_backend_streaming_config_json` from `handle_plan`). `None` when
-    // `CONTROLLER_BACKEND_ENDPOINT` is unset preserves the
-    // fire-and-forget "skip silently" contract from Phase B.
+    // Share one client between HTTP planning and replanning. An unset
+    // `CONTROLLER_BACKEND_ENDPOINT` disables backend pushes.
     let backend_client_shared: Option<Arc<backend_client::BackendClient>> =
         backend_endpoint.as_ref().map(|endpoint| {
             info!(
@@ -1191,17 +1140,9 @@ async fn handle_plan(State(st): State<AppState>, Json(spec): Json<QuerySpec>) ->
             .await;
     }
 
-    // ── Phase B (MVP v6): typed L5 stage_split → per-stage emitter ────────────
-    // Behind the `USE_TYPED_STAGE_SPLIT` env-var gate so existing
-    // control plane behaviour is unchanged unless explicitly opted in.
-    //
-    // The typed L5 stage-split is now fed by the real **L4 output**: when
-    // the spec carries a `query_string`, `bound_physical` holds the
-    // optimised L3 tree run through `physical::post_asap::bind_query_expr`.
-    // For specs that supply only explicit fields (no `query_string` to
-    // parse), there is no L3 tree to bind, so we fall back to
-    // `bind_workload_typed`, which lowers the flat `QueryWorkload`
-    // summary to a `PhysicalExpr` directly.
+    // The typed stage-split path is gated by `USE_TYPED_STAGE_SPLIT`.
+    // Queries with a parsed expression use the bound physical plan; explicit-field
+    // workloads without a query string use `bind_workload_typed`.
     if let Some(configs) = stage_configs {
         for (stage_id, stage_cfg) in configs {
             match stage_cfg {
@@ -1247,12 +1188,8 @@ async fn handle_plan(State(st): State<AppState>, Json(spec): Json<QuerySpec>) ->
                     }
                 }
                 crate::physical::colored_dag::StageConfig::Gateway(gw) => {
-                    // Phase C: AgentRole::Gateway is now wired
-                    // through the OpAMP role-routing path, so
-                    // the gateway YAML is pushed to gateway-role
-                    // collectors the same way the edge YAML is
-                    // pushed to agent-role collectors above.
-                    // Issue #2: gateway broadcast — `$AGENT_ID` placeholder.
+                    // Gateway-role collectors receive gateway YAML. Broadcast configs retain
+                    // the `$AGENT_ID` placeholder for expansion by each collector.
                     match emit::emit_gateway_yaml(&gw, &st.opamp_endpoint, "$AGENT_ID") {
                         Ok(yaml) => {
                             let hash = short_hash(&yaml);
@@ -1774,7 +1711,7 @@ async fn handle_bootstrap_agent_config(
     State(st): State<AppState>,
     headers: HeaderMap,
 ) -> impl IntoResponse {
-    // Phase ε.1.5 — runtime dispatch from the X-Agent-Runtime header.
+    // runtime dispatch from the X-Agent-Runtime header.
     // Defaults to `AsapOtel` for legacy agents that don't send
     // the header so the existing OTel-collector contrib build keeps
     // working with no client-side changes.
@@ -2193,11 +2130,8 @@ fn test_app() -> (AppState, axum::Router) {
     test_app_with_backend(None)
 }
 
-/// Phase C test helper: build an `AppState` whose `backend_client` is
-/// optionally set to a real `BackendClient` pointed at a mock URL. The
-/// `None` arm is the legacy path used by every existing test;
-/// `Some(url)` is the new entry point for Phase C tests that exercise
-/// the typed L5 backend-JSON push.
+/// Build a test server with an optional mock backend URL. `None` disables
+/// backend pushes; `Some(url)` exercises typed backend JSON delivery.
 #[cfg(test)]
 fn test_app_with_backend(backend_url: Option<String>) -> (AppState, axum::Router) {
     let online_store = init_online_store();
@@ -2400,7 +2334,7 @@ mod api_tests {
         })
     }
 
-    // ── Phase C: AppState.backend_client wiring ───────────────────────────────
+    // ── AppState.backend_client wiring ───────────────────────────────
 
     /// Default-constructed AppState (no `CONTROLLER_BACKEND_ENDPOINT`)
     /// must leave `backend_client` as `None` so the typed L5 backend
@@ -3165,12 +3099,7 @@ mod api_tests {
         assert!(body["monthly_savings_dollars"].as_f64().unwrap() > 0.0);
     }
 
-    // ── Phase ε.1.5+ — handle_bootstrap_agent_config typed path ────────────────
-    //
-    // These tests verify the deep fix that ports the bootstrap handler
-    // off `generate_agent_collector_config` and onto the typed-stage-split emit
-    // pipeline that `handle_plan` already uses. See the handler's
-    // doc-comment for the legacy ↔ typed behaviour matrix.
+    // Bootstrap and plan-push must use the same typed emission pipeline.
 
     /// Serialises tests that mutate the `USE_TYPED_STAGE_SPLIT` env var
     /// — `cargo test` runs tests in parallel by default and
diff --git a/control_plane/src/opamp/mod.rs b/control_plane/src/opamp/mod.rs
index 1e2db151a..91e99d7f6 100644
--- a/control_plane/src/opamp/mod.rs
+++ b/control_plane/src/opamp/mod.rs
@@ -773,7 +773,7 @@ mod tests {
         assert_eq!(AgentRole::from_header("BACKEND"), AgentRole::Backend);
     }
 
-    /// Phase C: `Gateway` is a recognised role and round-trips through
+    /// `Gateway` is a recognised role and round-trips through
     /// the OpAMP `X-Agent-Role` header parser. This locks in the wire
     /// vocabulary that the typed L5 stage_split path relies on when it
     /// calls `push_to_role(AgentRole::Gateway, ...)` and expects to
@@ -793,7 +793,7 @@ mod tests {
         assert_ne!(AgentRole::Gateway, AgentRole::Backend);
     }
 
-    /// Phase C: a gateway-role client connecting via WebSocket appears
+    /// a gateway-role client connecting via WebSocket appears
     /// in `connected_agents_with_roles` tagged as `Gateway`. Together
     /// with the from_header test above this proves the role plumbs
     /// through the connect path that `push_to_role` selects on.
diff --git a/control_plane/src/physical/colored_dag/allocator.rs b/control_plane/src/physical/colored_dag/allocator.rs
index 5cbf74a21..7574aa227 100644
--- a/control_plane/src/physical/colored_dag/allocator.rs
+++ b/control_plane/src/physical/colored_dag/allocator.rs
@@ -209,11 +209,7 @@ impl ThreeStageWalker {
                 StageId::Backend
             }
 
-            // ── SummaryAgg: always edge per design.md §6 batched-queries
-            // table — true for both approximate sketches (the old
-            // `SketchAgg`) and exact accumulators (the old `ExactAgg`);
-            // `SummaryKind` unifies both into the same node shape, and
-            // both landed on Edge before this migration too.
+            // Summary aggregation runs at the edge for both sketches and exact accumulators.
             SummaryExpr::SummaryAgg { child, .. } => {
                 let (cid, _) = self.visit_l4node(child)?;
                 self.dag.edges.push((id, cid));
diff --git a/control_plane/src/physical/colored_dag/dag.rs b/control_plane/src/physical/colored_dag/dag.rs
index f0e3eda44..7a04017db 100644
--- a/control_plane/src/physical/colored_dag/dag.rs
+++ b/control_plane/src/physical/colored_dag/dag.rs
@@ -1,22 +1,6 @@
-//! L5 colored DAG — `PhysicalExpr` nodes painted with `StageId`.
-//!
-//! Per `control_plane/docs/design.md` §3 (line ~123): "A 'stage assignment'
-//! is a colouring of the L4-bound `PhysicalExpr` DAG by `StageId`, with
-//! sketch-merge / data-shipping nodes inserted on the cut edges."
-//!
-//! [`ColoredDag`] is the IR the [`crate::physical::colored_dag::Emitter`]
-//! consumes. It carries:
-//!
-//! - the `nodes` vector (every visited `PhysicalExpr` node keyed by
-//!   [`NodeId`], with its assigned `StageId`),
-//! - the `edges` vector (parent → child references from the DAG walk),
-//!   carried so future Phase G+ work can detect cross-stage cut edges
-//!   for explicit data-shipping op insertion.
-//!
-//! Today the emitter consumes the per-stage *bucket* of nodes (`nodes
-//! filtered by stage`) plus the root sketch-state metadata; cut-edge
-//! reasoning is left as a Phase G hook (the `edges` vector is the data
-//! it needs).
+//! Physical DAG nodes assigned to stages. [`ColoredDag`] retains parent-child
+//! edges, including cross-stage edges, alongside the per-stage node buckets
+//! consumed by the emitter.
 
 #![allow(dead_code)]
 
@@ -57,15 +41,8 @@ pub struct ColoredNode {
     pub stage: StageId,
 }
 
-/// L5 colored DAG. The output of [`crate::physical::colored_dag::StageAllocator::allocate`].
-///
-/// Per design.md §6: "L5 colors the DAG by `StageId` and emits
-/// per-executor configs. Same `PhysicalExpr` input; topology and emitter
-/// differ per deployment model."
-///
-/// `Default::default()` returns the empty `Topology::ThreeStage` shape —
-/// that's the only topology Phase E ships, so the default is safe and
-/// useful for the allocator's incremental-build path.
+/// Output of [`crate::physical::colored_dag::StageAllocator::allocate`].
+/// The default is an empty three-stage DAG for incremental construction.
 #[derive(Debug, Clone)]
 pub struct ColoredDag {
     /// Topology this colouring was produced under.
@@ -119,10 +96,7 @@ impl ColoredDag {
         seen
     }
 
-    /// Cut edges — edges where parent and child end up on different
-    /// stages. These are the wire-format hops (OpAMP push / OTLP /
-    /// `StreamingConfig`) the emitter must materialize. Phase E reports
-    /// them; Phase G+ inserts explicit data-shipping ops on them.
+    /// Edges crossing stage boundaries. They describe the required transport hops.
     pub fn cut_edges(&self) -> Vec<(NodeId, NodeId)> {
         self.edges
             .iter()
diff --git a/control_plane/src/physical/colored_dag/emitter.rs b/control_plane/src/physical/colored_dag/emitter.rs
index aa609da0b..9d0de45b7 100644
--- a/control_plane/src/physical/colored_dag/emitter.rs
+++ b/control_plane/src/physical/colored_dag/emitter.rs
@@ -1,29 +1,8 @@
-//! L5 emitter — turns a [`ColoredDag`] into per-stage configs.
+//! Build per-stage configuration from a [`ColoredDag`].
 //!
-//! Per `control_plane/docs/design.md` §1219: "L4 chose the sketch family +
-//! params. L5 colors the DAG by `StageId` and emits per-executor
-//! configs. Same `PhysicalExpr` input; topology and emitter differ per
-//! deployment model."
-//!
-//! Phase E ships [`ThreeStageEmitter`] for the DC topology (edge →
-//! gateway → backend). Each per-stage [`StageConfig`] is a structured
-//! description that the OpAMP push (Phase G+) and the backend client
-//! (Phase G+) materialise into wire bytes:
-//!
-//! - [`StageConfig::Edge`] — the agent OpAMP YAML's logical content:
-//!   scrape source, optional window, the chosen sketch processor, and
-//!   the OTLP exporter pointer to gateway.
-//! - [`StageConfig::Gateway`] — the gateway OpAMP YAML's logical
-//!   content: an OTLP receiver, the sketch-merge processor list, and
-//!   the OTLP exporter pointer to backend.
-//! - [`StageConfig::Backend`] — the backend `StreamingConfig`'s logical
-//!   content: a list of `(aggregation_id → (sketch_kind, params))`
-//!   tuples plus the readout query catalog.
-//!
-//! Emitters do NOT push to executors here — they produce the structured
-//! output. The actual push (`crate::opamp::OpampServer::push_to_role`,
-//! `crate::backend_client::StreamingConfigClient::post`) is wired in
-//! Phase G+.
+//! [`ThreeStageEmitter`] handles edge → gateway → backend. Configs describe
+//! sketch processors, merge processors, backend aggregations, and readouts.
+//! Wire serialization and delivery are handled by the deployment emitters.
 
 #![allow(dead_code)]
 
@@ -89,12 +68,7 @@ fn classify(expr: &PhysicalExpr) -> NodeKind<'_> {
     match expr {
         PhysicalExpr::Committed(PostAsapPlan::Summary(node)) => match &node.expr {
             SummaryExpr::KeepPreAsap(qe) => NodeKind::Logical(qe),
-            // `SummaryAgg`'s `kind`/`params` fields collapsed into one
-            // `family: SummaryFamilyType` field (ASAPPlanner#218 --
-            // see control_plane/docs/design-asapplanner-pin-migration.md);
-            // the exact-vs-sketch classification this used to need
-            // `is_exact_accumulator` for is now which enum variant
-            // `family` is, not a value-level check on `kind`.
+            // The `family` variant distinguishes exact accumulators from sketches.
             SummaryExpr::SummaryAgg {
                 family: planner_types::post_asap::SummaryFamilyType::ExactAggregate(..),
                 ..
@@ -153,7 +127,7 @@ pub enum EmitError {
     UnsupportedTopology(Topology, Topology),
     /// A sketch processor name could not be derived for the supplied
     /// `SketchAlgorithm`. Should not occur with the catalog ranges shipped
-    /// in Phase C — kept as a defensive error for future kinds.
+    /// in kept as a defensive error for future kinds.
     #[error("no edge processor known for sketch kind {0:?}")]
     NoEdgeProcessor(SketchAlgorithm),
     /// Backend would emit an empty StreamingConfig because no sketch
@@ -166,10 +140,7 @@ pub enum EmitError {
     UnsupportedHeapUpdate,
 }
 
-/// Generic emitter trait — Phase E ships only [`ThreeStageEmitter`]; future
-/// phases add `SingleStageEmitter` (asap-query), `ZeroStageEmitter`
-/// (asap-fusion), and friends. The trait keeps the dispatch surface
-/// uniform so `planner::stage_split` can pick at runtime.
+/// Produce per-stage configuration from a colored DAG.
 pub trait Emitter {
     /// Lower a colored DAG into one [`StageConfig`] per occupied stage.
     /// Returns a map keyed by `StageId` for stable consumer access; any
@@ -233,7 +204,7 @@ pub struct EdgeStageConfig {
     /// in); emitters produce the abstract `Self` and downstream code
     /// fills in `gateway:4317` / similar.
     pub exporter_target: ExportTarget,
-    /// Phase ε.1 — Mode 3 routing destinations, when one or more
+    /// Mode 3 routing destinations, when one or more
     /// `RawAtEdgePrometheusArchive` nodes coloured to this edge stage.
     /// Each entry produces a separate `otlphttp/prometheus` exporter +
     /// pipeline tagged `asap.mode=prometheus_archive` so the agent's
@@ -242,7 +213,7 @@ pub struct EdgeStageConfig {
     /// Empty list = no Mode 3 metrics → no `otlphttp/prometheus`
     /// exporter is emitted (the YAML is identical to Phase β).
     pub prometheus_archive_metrics: Vec<PrometheusArchiveMetric>,
-    /// Phase 3.2.5 — archive-tier metrics that should flow through the
+    /// archive-tier metrics that should flow through the
     /// `gorillas3` processor at the edge agent (write a Gorilla-S3
     /// chunk + Prometheus TSDB block to MinIO so the ASAP-tier query
     /// engine and the Thanos store-gateway can both serve them).
@@ -260,7 +231,7 @@ pub struct EdgeStageConfig {
     /// counter samples in MinIO so the Gorilla-S3 / Thanos archive
     /// can answer `last_over_time(...)`).
     pub archive_tier_metrics: Vec<ArchiveTierMetric>,
-    /// Phase 3.2.5 — metrics that must be carried through the
+    /// metrics that must be carried through the
     /// ASAP-tier pipeline WITHOUT the family-specific sketch processor
     /// renaming them. The freshness probes are timestamp counters by
     /// design (the wire value `unix_ts_ms_of_emission` IS the freshness
@@ -531,7 +502,7 @@ pub fn default_cold_external_labels() -> Vec<(String, String)> {
     vec![("cluster".to_string(), cluster)]
 }
 
-/// Phase 3.2.5 — one archive-tier metric the agent should land in
+/// one archive-tier metric the agent should land in
 /// MinIO via the `gorillas3` processor (Gorilla-S3 chunks + Prometheus
 /// TSDB blocks for the Thanos store-gateway). The `metric` field is
 /// used both for the control-plane-side bookkeeping and (downstream) for
@@ -550,7 +521,7 @@ pub struct ArchiveTierMetric {
     pub window_secs: Option<u64>,
 }
 
-/// Phase ε.1 — one Mode-3 metric the agent forwards to Prometheus's
+/// one Mode-3 metric the agent forwards to Prometheus's
 /// native OTLP receiver. The agent's `routing` processor matches on
 /// `attributes["asap.mode"] == "prometheus_archive"` and dispatches to
 /// the `otlphttp/prometheus` exporter.
@@ -713,7 +684,7 @@ pub struct BackendAggregation {
     /// Runtime accumulator mode derived from SummaryAgg.input.weight, never
     /// from the TopK readout. None retains the legacy value-update default.
     pub heap_update_mode: Option<&'static str>,
-    /// Phase ε.1 — what shape the backend ingests for this
+    /// what shape the backend ingests for this
     /// aggregation. Mode 1 (sketch at edge) / sketch_envelope is the
     /// default (the wire payload is a sketch state already). Mode 2
     /// (raw at edge → sketch at backend) sets this to `raw` so the
@@ -723,7 +694,7 @@ pub struct BackendAggregation {
     pub aggregation_input: AggregationInput,
 }
 
-/// Phase ε.1 — what wire shape the backend ingests for an aggregation.
+/// what wire shape the backend ingests for an aggregation.
 /// Determines whether the backend builds the sketch from raw samples
 /// (Mode 2) or accepts pre-built sketch state from upstream (Mode 1).
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/control_plane/src/physical/colored_dag/mod.rs b/control_plane/src/physical/colored_dag/mod.rs
index ed51d564b..28f6a4720 100644
--- a/control_plane/src/physical/colored_dag/mod.rs
+++ b/control_plane/src/physical/colored_dag/mod.rs
@@ -1,37 +1,11 @@
-//! Layer 5 — `stage_split` (StageAllocator + Emitter framework).
+//! Assign physical nodes to stages and emit structured executor configurations.
 //!
-//! Per `control_plane/docs/design.md` §6 (line ~765 `core::physical`) and
-//! the §6 batched-queries example (line ~1376) — Phase E lands the
-//! typed L5 colouring + emitter for the DC three-stage topology
-//! (edge → gateway → backend).
+//! * [`StageId`] and [`Topology`] describe roles and topology.
+//! * [`ColoredDag`] records node assignments and edges.
+//! * [`StageAllocator`] assigns the three-stage edge → gateway → backend topology.
+//! * [`ThreeStageEmitter`] builds per-stage configs for wire emission.
 //!
-//! Pipeline position. L4 [`crate::physical::post_asap::PhysicalExpr`] is the
-//! input — sketch-bound, language-orthogonal, deployment-independent.
-//! L5 paints each `PhysicalExpr` node with a [`StageId`] and emits one
-//! [`emitter::StageConfig`] per occupied stage. The configs become the
-//! OpAMP `RemoteConfig` payload (edge / gateway) and the backend
-//! `StreamingConfig` (backend) — Phase G+ wires the actual push.
-//!
-//! Module layout:
-//!
-//! - [`stage_id`] — [`StageId`] enum + [`Topology`] enum.
-//! - [`colored_dag`] — [`ColoredDag`] IR (the allocator's output).
-//! - [`allocator`] — [`StageAllocator`] + [`AllocateError`].
-//! - [`emitter`] — [`Emitter`] trait + [`ThreeStageEmitter`].
-//!
-//! Scope reduction (per orchestrator spec): Phase E ships only the DC
-//! lifecycle topology. `Topology::SingleStage` /
-//! `Topology::ZeroStage` are surfaced as variants but
-//! [`StageAllocator::allocate`] returns
-//! [`AllocateError::UnsupportedTopology`] for them — the
-//! single-stage / zero-stage allocators land with their respective
-//! deployment-model crates (asap-query / asap-fusion) in later phases.
-//!
-//! Wire-up state. The typed L5 path is opt-in via the
-//! `USE_TYPED_STAGE_SPLIT` env var consulted by the existing
-//! `planner::stage_split` module — see [`crate::planner::stage_split`]
-//! for the additive call path. Existing untyped callers keep working
-//! unchanged.
+//! Single-stage and zero-stage allocation return [`AllocateError::UnsupportedTopology`].
 
 #![allow(dead_code, unused_imports)]
 
@@ -43,9 +17,6 @@ pub mod stage_id;
 #[cfg(test)]
 mod tests;
 
-// Re-exports — `crate::physical::colored_dag::*` for downstream callers.
-// The historical `crate::physical::colored_dag::*` path is preserved via a
-// re-export in `lib.rs` so existing callers see no source-level break.
 pub use allocator::{AllocateError, StageAllocator};
 pub use dag::{ColoredDag, ColoredNode, NodeId};
 pub use emitter::{
diff --git a/control_plane/src/physical/colored_dag/stage_id.rs b/control_plane/src/physical/colored_dag/stage_id.rs
index 3cb8a22f3..8444919ce 100644
--- a/control_plane/src/physical/colored_dag/stage_id.rs
+++ b/control_plane/src/physical/colored_dag/stage_id.rs
@@ -1,37 +1,12 @@
-//! L5 stage identifiers + topology descriptors.
-//!
-//! Per `control_plane/docs/design.md` §6 `core::physical` (around line ~765):
-//!
-//! - [`StageId`] — the categorical *tier* in the data lifecycle. Topology
-//!   declares which stages exist; allocator paints `PhysicalExpr` nodes
-//!   with one of these.
-//! - [`Topology`] — the deployment-model topology shape. Phase E surfaces
-//!   only [`Topology::ThreeStage`] (DC lifecycle: edge → gateway →
-//!   backend) per the orchestrator's scope reduction. Single-stage and
-//!   zero-stage are reserved for asap-query / asap-fusion deployments
-//!   not in this phase.
-//!
-//! `StageId` is intentionally an enum (not the `pub struct StageId(pub
-//! String)` shape from design.md line 787): Phase E ships only the
-//! 3-stage DC topology, so the variants are closed and exhaustive
-//! `match`es catch typos at compile time. The string-shaped form from
-//! design.md is the right surface once a deployment model registers a
-//! custom stage role; until that happens, the enum is the safer choice.
+//! Stage roles and deployment topologies. Roles are closed enum variants so
+//! allocation matches are exhaustive. Only three-stage allocation is supported.
 
 #![allow(dead_code)]
 
 use serde::{Deserialize, Serialize};
 
-/// L5 stage role — a categorical tier in the data lifecycle.
-///
-/// Per design.md §3 (line ~120): "Stage (`StageId`) — a categorical tier
-/// in the data lifecycle (edge / gateway / backend / in-process). The
-/// topology declares which stages exist (3-stage / 1-stage / 0-stage).
-/// Stages are roles, not instances."
-///
-/// Multiple `Executor`s may share a `StageId` (e.g. a 50-host edge fleet
-/// has 50 executors all carrying `StageId::Edge`). Phase E operates at
-/// stage granularity; per-executor fan-out is downstream (Phase G+).
+/// A categorical tier, not an executor instance. Multiple executors may share
+/// one role; per-executor fan-out happens downstream of stage allocation.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum StageId {
@@ -66,24 +41,8 @@ impl std::fmt::Display for StageId {
     }
 }
 
-/// Deployment-model topology descriptor.
-///
-/// Per design.md §6 `core::physical::topology` (line ~779):
-/// ```ignore
-/// pub mod topology {
-///     pub struct ThreeStage { /* edge → gateway → backend */ }
-///     pub struct SingleStage { /* backend-only */ }
-///     pub struct ZeroStage;   /* in-process */
-/// }
-/// ```
-///
-/// Phase E surfaces only `ThreeStage` (DC lifecycle scope-reduction);
-/// the other variants are reserved as future-proofing — adding them is
-/// purely additive.
-///
-/// (`clippy::enum_variant_names` is silenced — the `*Stage` suffix is
-/// part of the design.md naming, not a typo carrying redundant
-/// prefix.)
+/// Deployment topology. Single-stage and zero-stage variants are reserved;
+/// the allocator currently supports only `ThreeStage`.
 #[allow(clippy::enum_variant_names)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
diff --git a/control_plane/src/physical/deployment_cost/mod.rs b/control_plane/src/physical/deployment_cost/mod.rs
index 85b0e5cf0..564c430f5 100644
--- a/control_plane/src/physical/deployment_cost/mod.rs
+++ b/control_plane/src/physical/deployment_cost/mod.rs
@@ -2,9 +2,6 @@
 
 use std::collections::HashMap;
 
-// Sub-modules — formerly siblings of `planner/cost_model.rs` (now
-// `optimizer/cost/mod.rs`); the 2026-05 refactor pulled each into a
-// dedicated `optimizer/cost/<name>.rs`.
 pub mod delta;
 pub mod online;
 pub mod pareto;
diff --git a/control_plane/src/physical/deployment_cost/sketch_capability.rs b/control_plane/src/physical/deployment_cost/sketch_capability.rs
index 66022ba64..28decc917 100644
--- a/control_plane/src/physical/deployment_cost/sketch_capability.rs
+++ b/control_plane/src/physical/deployment_cost/sketch_capability.rs
@@ -91,11 +91,7 @@ struct SketchCapabilitiesFile {
     count_min_sketch: SketchCapabilityYaml,
 }
 
-/// Compiled-in capability defaults — one entry per [`SketchAlgorithm`].
-/// Replaces the per-variant `sketch_capability(SketchType)` function
-/// that previously lived in `algebra/optimizer.rs`. Numerical values
-/// are mirrored from the YAML so the in-process defaults match the
-/// reference deployment file.
+/// Compiled-in capability defaults, mirrored from the reference deployment YAML.
 pub fn default_capability_table() -> HashMap<SketchAlgorithm, SketchCapability> {
     let mut map = HashMap::new();
     map.insert(
@@ -166,11 +162,8 @@ pub fn default_capability_table() -> HashMap<SketchAlgorithm, SketchCapability>
     map
 }
 
-/// Load sketch capability overrides from a YAML file. Falls back to
-/// [`default_capability_table`] if the file is missing or malformed.
-/// Physical replacement for the retired logical capability loader.
-///
-/// Env var: `CONTROLLER_SKETCH_CAPABILITIES=path/to/this/file.yml`.
+/// Load overrides from `CONTROLLER_SKETCH_CAPABILITIES`. Missing or malformed
+/// files fall back to [`default_capability_table`].
 pub fn load_capability_overrides(path: &str) -> HashMap<SketchAlgorithm, SketchCapability> {
     if let Ok(contents) = std::fs::read_to_string(path) {
         if let Ok(file) = serde_yaml::from_str::<SketchCapabilitiesFile>(&contents) {
diff --git a/control_plane/src/physical/deployment_cost/wire.rs b/control_plane/src/physical/deployment_cost/wire.rs
index 0edb5d0f9..7eb7bf3f3 100644
--- a/control_plane/src/physical/deployment_cost/wire.rs
+++ b/control_plane/src/physical/deployment_cost/wire.rs
@@ -1,35 +1,8 @@
-//! Physical sketch wire-cost table — per-family OTLP wire footprint.
+//! Per-family OTLP wire footprints used to rank candidate sketch families.
 //!
-//! Retirement note (2026-07): this file originally also carried a
-//! Phase ε.1 three-mode bind-placement selector (`BindMode` +
-//! `select_bind_mode` + `WireWorkload` + `break_even_samples` +
-//! `est_wire_bytes_per_window_per_series`) that decided whether a
-//! sketch runs at the edge, ships raw for backend-side sketching, or
-//! falls back to a Prometheus archive, based on per-workload wire-cost
-//! break-even math. It was fully designed and unit-tested but never
-//! wired into `physical::post_asap::lower::bind_query_expr` (which always
-//! produces `PhysicalExpr::Committed` — see that function's doc) or
-//! anywhere else; `PhysicalExpr::RawAtEdgeSketchAtBackend` /
-//! `RawAtEdgePrometheusArchive` remain structurally unreachable in
-//! production as a result. Removed as dead code rather than kept as
-//! speculative scaffolding. Recoverable from git history
-//! (`chore/retire-tier2-scaffolding`, 2026-07) if bind-mode placement
-//! becomes active work.
-//!
-//! What's left is the cost table alone — genuinely load-bearing today
-//! via [`WireCostTable::for_kind`], consumed by
-//! `physical::post_asap::cost_model::ControlPlaneCostModel` to rank
-//! candidate sketch families by wire cost.
-//!
-//! ## Cost table source
-//!
-//! Sketch wire-state sizes are delta-encoded where the sketch family
-//! supports it. KLL has no delta variant per `Implementation.tex`
-//! (randomised compaction is not additively mergeable; the wire payload
-//! is always full state). Numbers are conservative for typical
-//! observability workloads — a future iteration will refine via observed
-//! agent telemetry once the OnlineMetricsStore feeds back into the
-//! planner.
+//! Sizes assume delta encoding where supported. KLL uses full state because its
+//! randomized compaction is not additively mergeable. Defaults are conservative
+//! estimates for observability workloads, rather than measured telemetry.
 
 use planner_types::post_asap::SketchAlgorithm;
 
@@ -103,26 +76,9 @@ impl WireCostTable {
         }
     }
 
-    /// Lookup the per-flush cost for a sketch family.
-    ///
-    /// `SketchAlgorithm` (unlike the retired `physical::post_asap::SketchAlgorithm`)
-    /// distinguishes heap-bearing from bare frequency sketches at the
-    /// kind level rather than via a `with_heap` param flag. This table
-    /// never modeled the heap's extra bytes separately (the old
-    /// `for_kind` took a bare `SketchAlgorithm` with no visibility into
-    /// `with_heap` at all) — `CmsWithHeap`/`CountSketchWithHeap` reuse
-    /// their bare counterpart's cost to preserve that exact behavior.
-    /// `Kmv`/`Theta` have no established cost number (nothing in this
-    /// repo binds a cardinality intent to either today — the candidate
-    /// list stays `Hll`-only, see `capability.rs`); they reuse `hll_delta`
-    /// as a same-order-of-magnitude placeholder pending real numbers if
-    /// this repo ever adopts them.
-    // Exhaustive over `SketchAlgorithm` alone now (ASAPPlanner#218 split the
-    // old flat `SummaryKind` into `SketchAlgorithm`/`ExactKind` -- the exact-
-    // accumulator arm this match used to need, and its
-    // "exact accumulators have no sketch wire-state cost" panic, are
-    // unreachable by construction now instead of at runtime; see
-    // control_plane/docs/design-asapplanner-pin-migration.md).
+    /// Look up per-flush wire cost. Heap-bearing sketches reuse their bare family
+    /// cost; heap bytes are not priced separately. KMV and Theta reuse the HLL
+    /// estimate because no independent measurement is available.
     pub const fn for_algorithm(&self, algorithm: &SketchAlgorithm) -> SketchWireCost {
         match algorithm {
             // No collector wire implementation is available for this family.
diff --git a/control_plane/src/physical/post_asap/cost_model.rs b/control_plane/src/physical/post_asap/cost_model.rs
index 9fc8e9230..2fab24367 100644
--- a/control_plane/src/physical/post_asap/cost_model.rs
+++ b/control_plane/src/physical/post_asap/cost_model.rs
@@ -1,37 +1,9 @@
-//! `ControlPlaneCostModel` — plugs control_plane's own sketch-family
-//! selection + parameter-sizing policy into
-//! `asap_aware_mapping::bind::implement_tree_in_with` via the two `CostModel`
-//! extension points (`rank_candidates` for family choice, `size_params`
-//! for parameter sizing — the latter added by ASAPController PR #146
-//! specifically to support this migration).
+//! Deployment family selection and parameter sizing for ASAPPlanner binding.
 //!
-//! Ports the decisions previously made by the `bind_kll_quantile` /
-//! `bind_ddsketch_quantile` / `bind_hll_cardinality` / `bind_cms_count` /
-//! `bind_cms_topk` `Rule`s verbatim — same accuracy-bound citations, same
-//! priority order, same recall-tier logic — just re-homed behind the
-//! `CostModel` trait instead of a bespoke `Rule` dispatcher, so the L3→L4
-//! walk itself (schema derivation, `col`/`by` computation, DAG
-//! construction) can be `asap_aware_mapping::bind`'s rather than a forked copy.
-//!
-//! `AggIntent::Extension` (control_plane's `Frequency` point-query) used
-//! to be one of two shapes `implement_tree_in_with` couldn't realize even
-//! with this `CostModel` plugged in — `boundary::implementation_for_with`
-//! now consults [`ControlPlaneCostModel::realize_extension`]/
-//! [`readout_extension`](CostModel::readout_extension) for it instead of
-//! hardcoding `PassThrough` (ASAPController#150).
-//!
-//! One shape remains genuinely unreachable via this `CostModel`, because
-//! the decision of *whether* to call into `rank_candidates`/`size_params`
-//! at all is made upstream, before the `CostModel` is ever consulted:
-//!
-//! - `AggIntent::TopK { accuracy: AccuracyTarget::Exact, .. }` — routes to
-//!   `exact_realization`, which has no accumulator form for `TopK` and
-//!   returns `PassThrough`, so `implement_tree_in_with` falls through to
-//!   its own `Logical` fallback for this shape unchanged. There is no
-//!   local pre-pass binding it: the `BindCountSketchOnTopK` rule that
-//!   once did was deleted (see `lower.rs`'s module doc) — this is a
-//!   genuine, still-open `asap-plan` coverage gap (ASAPController#151),
-//!   not something this deployment routes around locally.
+//! `rank_candidates` chooses a family; `size_params` sets its parameters.
+//! Frequency extensions use `realize_extension` and `readout_extension`.
+//! Exact TopK falls back to logical execution upstream because it has no
+//! exact accumulator realization; these cost-model hooks cannot bind it.
 
 #![allow(dead_code)]
 
diff --git a/control_plane/src/physical/post_asap/deployment_expr.rs b/control_plane/src/physical/post_asap/deployment_expr.rs
index 52a0a648a..c55174e2f 100644
--- a/control_plane/src/physical/post_asap/deployment_expr.rs
+++ b/control_plane/src/physical/post_asap/deployment_expr.rs
@@ -1,40 +1,9 @@
-//! Backend deployment wrappers around the canonical post-ASAP plan.
+//! Deployment wrappers around ASAPPlanner's canonical post-ASAP summary IR.
 //!
-//! Step B of the plan-shaped-serving migration retires this crate's own
-//! `PhysicalExpr`-as-L4-algebra (the old `Logical` / `SketchAgg` /
-//! `SketchEstimate` / `SketchMerge` / `ExactAgg` variants) in favor of
-//! ASAPPlanner's canonical post-ASAP IR, `planner_types::post_asap::{SummaryExpr, SummaryNode}`
-//! — the same move Step 3 of the enum-unification made for
-//! `SketchAlgorithm → SketchAlgorithm`, one layer up. `implement_promql_for_asap_tier`
-//! (`asap_tier_implement.rs`, Step A) already builds `Rc<SummaryNode>` trees via
-//! `asap_aware_mapping::bind::implement_tree_in_with`; this module gives the rest of
-//! the crate (optimizer, physical, emit) the same IR shape.
-//!
-//! Two things `planner_types::post_asap::SummaryNode` genuinely doesn't have, kept here:
-//!
-//! - **`LetBinding` / `Ref`** — named fan-in sharing (SQL
-//!   `WITH name AS (expr) ...` / a `SketchAgg` shared by two `SketchEstimate`
-//!   readouts). `SummaryNode`'s own DAG sharing is structural (multiple `Rc`
-//!   references to the same node), not named — but the rule-firing walk in
-//!   this crate discovers sharing incrementally, per-node, so it still needs
-//!   a name to thread a bound value across sibling calls. This is a
-//!   deployment-specific mechanism, not a fact about the sketch algebra
-//!   itself, hence the backend-local [`PostAsapPlan`] wrapper.
-//! - **`RawAtEdgeSketchAtBackend` / `RawAtEdgePrometheusArchive`** — Phase
-//!   ε.1's placement decisions (where the sketch gets built, not what it
-//!   is). Genuinely L5. `physical::deployment_cost::wire` once named the same three
-//!   modes as `BindMode` with a `select_bind_mode` chooser, but that
-//!   selector was never wired to a caller (`bind_query_expr` always
-//!   produces `Committed`) and was removed in the 2026-07 retirement
-//!   pass — these two variants remain structurally unreachable in
-//!   production today, kept only because `physical/colored_dag/{allocator,emitter}.rs`
-//!   already pattern-match on them.
-//!
-//! `SketchAgg` / `SketchEstimate` / `SketchMerge` / `Logical` / `ExactAgg`
-//! don't get their own variants anymore — `planner_types::post_asap::SummaryExpr`
-//! already unifies all of them (including "exact accumulator" and "sketch"
-//! as the same `SummaryAgg` node, with or without a wrapping
-//! `SummaryEstimate`) inside a single `PostAsapPlan::Summary(Rc<SummaryNode>)`.
+//! [`PostAsapPlan`] adds named `LetBinding` / `Ref` sharing for sibling walks.
+//! [`PhysicalExpr`] adds edge/backend/archive placement. The lowerer produces
+//! `Committed`; the stage allocator and emitter also handle explicit raw
+//! placements supplied by callers.
 
 #![allow(dead_code)]
 
diff --git a/control_plane/src/physical/post_asap/lower.rs b/control_plane/src/physical/post_asap/lower.rs
index db1a74f26..632641d40 100644
--- a/control_plane/src/physical/post_asap/lower.rs
+++ b/control_plane/src/physical/post_asap/lower.rs
@@ -50,12 +50,9 @@ pub enum BindingError {
     Implement(#[from] crate::planner_selection::SelectionError),
 }
 
-/// Lower an L3 `QueryExpr` to L4/L5 under the supplied workload-level
-/// accuracy target, via [`ControlPlaneCostModel`] (this deployment's
-/// planning-time family/sizing preferences). The result is always
-/// [`PhysicalExpr::Committed`] — this walk never picks a Phase ε.1
-/// backend/archive placement; that's a separate, later L5 decision
-/// (`physical::deployment_cost::wire`).
+/// Lower an L3 query under the supplied accuracy target using
+/// [`ControlPlaneCostModel`]. Returns [`PhysicalExpr::Committed`]; placement
+/// is separate from summary selection.
 pub fn bind_query_expr(
     expr: &QueryExpr,
     accuracy: AccuracyTarget,
@@ -99,12 +96,6 @@ fn bind_recursive(
         } => Ok(PostAsapPlan::Summary(
             crate::planner_selection::keep_pre_asap(expr)?,
         )),
-        // `QueryExpr::LetBinding`/`::Ref` don't exist in the canonical IR
-        // anymore (ASAPPlanner#181/#192 -- see
-        // control_plane/docs/design-asapplanner-pin-migration.md), so
-        // this walk can never actually receive that shape; the arms that
-        // used to produce `PostAsapPlan::LetBinding`/`PostAsapPlan::Ref` here are
-        // gone with it.
 
         // The canonical L3 IR places `TimeRange` *above* a single-statistic
         // sketchable `Aggregate` (`lower_promql`'s window-swap; was
@@ -141,17 +132,8 @@ fn bind_recursive(
             bind_recursive(&pushed, cost_model)
         }
 
-        // `AggIntent::Count { accuracy: Exact }` — `boundary::implementation_for`'s
-        // `exact_realization` actively binds this to `ExactKind::Count`,
-        // but this deployment's data plane has no count accumulator: its
-        // `SumAccumulator` only tracks `sum: f64`, so a `Count`
-        // accumulator would silently return the sum of sample VALUES, not
-        // the sample count (PR #200/#201, reverted — see the retired
-        // `bind_exact_agg.rs`). Force the same fallback `implement_tree_with`
-        // uses for unbound shapes, via the public `bind::logical`
-        // ASAPController exposes for exactly this "deployment knows
-        // better" case — no local schema-lift duplication needed. Stays
-        // on archive, matching today's behavior.
+        // Exact Count cannot use this deployment's Sum accumulator: it counts
+        // values rather than samples. Keep it logical for archive execution.
         QueryExpr::Aggregate {
             measures: aggs,
             having: None,
@@ -176,19 +158,9 @@ fn bind_recursive(
     }
 }
 
-/// Rewrite every `AggIntent::Rate` reachable via the `Aggregate` spine
-/// (nested `Aggregate.child` chains — the only shape `implement_tree_in_with`
-/// itself recurses through; see its "conservative fallbacks" docs) to
-/// `AggIntent::Increase`.
-///
-/// `boundary::implementation_for` gives `Rate` its own `SummaryKind::Rate`;
-/// this deployment's data plane has no accumulator family for it — rate is
-/// computed as `increase / window_seconds`, a scalar division on the
-/// `Increase` accumulator's output applied at readout, not a separate
-/// accumulator (see the retired `bind_exact_agg.rs`, which bound both to
-/// the same accumulator for the same reason). Representing `Rate` as
-/// `Increase` up through L4 preserves that — the L5 emitter is still the
-/// one that knows to apply the division.
+/// Rewrite Rate to Increase along the aggregate spine traversed by Planner.
+/// This deployment computes rate by dividing the Increase readout by window
+/// seconds, rather than storing a separate Rate accumulator.
 fn rewrite_rate_to_increase(expr: &QueryExpr) -> QueryExpr {
     match expr {
         QueryExpr::Aggregate {
diff --git a/control_plane/src/physical/post_asap/matcher.rs b/control_plane/src/physical/post_asap/matcher.rs
index f5a671e8d..89e11e5cf 100644
--- a/control_plane/src/physical/post_asap/matcher.rs
+++ b/control_plane/src/physical/post_asap/matcher.rs
@@ -103,11 +103,8 @@ pub fn sketch_family_satisfied(required: &SketchAlgorithm, available: &SketchAlg
     req_family.satisfied_by(have_family)
 }
 
-/// The family a [`SketchAlgorithm`] belongs to, for [`SummaryFamilyMatcher`].
-/// Total now (every `SketchAlgorithm` variant is an approximate-sketch family
-/// by construction, post ASAPPlanner#218's split — the exact-accumulator
-/// kinds this used to also cover live in `ExactKind` now, a distinct type
-/// this function never sees).
+/// Return the family of a [`SketchAlgorithm`] for [`SummaryFamilyMatcher`].
+/// Every variant is a sketch; exact accumulators use a separate type.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum SummaryFamily {
     Universal,
diff --git a/control_plane/src/physical/post_asap/tests.rs b/control_plane/src/physical/post_asap/tests.rs
index 3735861c5..f23eafbdf 100644
--- a/control_plane/src/physical/post_asap/tests.rs
+++ b/control_plane/src/physical/post_asap/tests.rs
@@ -134,11 +134,7 @@ fn node_is_archive(node: &Rc<SummaryNode>) -> bool {
 
 #[test]
 fn bind_kll_quantile_basic() {
-    // The retired `BindKllOnQuantile` rule struct's direct `.apply()`
-    // call is replaced by forcing the Kll family via
-    // `ForcedFamilyCostModel` — bypassing the DDSketch/KLL dispatcher
-    // tie-break exercised separately by
-    // `bind_picks_ddsketch_over_kll_when_eps_explicit` below.
+    // Force KLL to test its binding independently of family ranking.
     let expr = agg_quantile(0.99, AccuracyTarget::Epsilon(0.01));
     let cost_model =
         ForcedFamilyCostModel::new(AccuracyTarget::Epsilon(0.01), SketchAlgorithm::Kll);
@@ -167,8 +163,7 @@ fn bind_kll_quantile_basic() {
 
 #[test]
 fn bind_ddsketch_quantile_basic() {
-    // Same shape as `bind_kll_quantile_basic`, forcing DDSketch instead
-    // of the retired `BindDDSketchOnQuantile` rule struct.
+    // Force DDSketch to test its quantile binding.
     let expr = agg_quantile(0.99, AccuracyTarget::Epsilon(0.01));
     let cost_model =
         ForcedFamilyCostModel::new(AccuracyTarget::Epsilon(0.01), SketchAlgorithm::DDSketch);
@@ -446,12 +441,7 @@ fn bind_exact_accuracy_disables_quantile_binding() {
     }
 }
 
-// ── Phase β: pattern-migration coverage ───────────────────────────────────────
-//
-// The five PromQL pattern shapes defined in `asap-planner-rs/src/planner/
-// patterns.rs` each have a control plane L3/L4 equivalent. These tests are the
-// per-shape cross-reference asserting the L1→L3→L4 path produces a
-// matching binding without going back through asap-planner-rs.
+// PromQL pattern coverage through canonical parsing and physical binding.
 
 /// `ONLY_TEMPORAL` — `quantile_over_time(0.99, m[5m])`.
 /// asap-planner-rs path: ONLY_TEMPORAL pattern 1 → KLL/DDSketch summary.
@@ -599,17 +589,7 @@ fn phase_b_pattern_temporal_and_spatial_combined_binds_to_multiple_increase() {
     }
 }
 
-/// Phase β archive-only intent: any of the no-ASAP-tier-family entries
-/// (`Absent`, `Present`, `Delta`, …) binds to a `Logical` pass-through,
-/// and the L5 emitter / Phase α routing reads `AggIntent::archive_only()
-/// == true` to flag the StreamingConfig entry for the archive tier.
-///
-/// `histogram_quantile(...)` was previously an L3 intent here but is no
-/// longer — it's a PromQL/MetricsQL language-level operator that the
-/// parser substitutes (Step γ5) into a plain `Aggregate { Quantile(φ) }`,
-/// NOT a semantic intent. The L1→L3 lowerer's documented contract is
-/// `histogram_quantile(q, bucket_metric) → AggIntent::Quantile { q, .. }`;
-/// bucket-aware reduction is a physical-planner concern.
+/// Archive-only intents produce logical pass-through plans.
 #[test]
 fn phase_b_pattern_archive_only_routes_to_archive() {
     let intent = AggIntent::Absent;
@@ -641,19 +621,7 @@ fn phase_b_pattern_archive_only_routes_to_archive() {
     }
 }
 
-// ── Phase β: end-to-end pattern equivalence with asap-planner-rs ─────────────
-//
-// The asap-planner-rs test suite drives a set of canonical PromQL workloads
-// (`tests/comparison/test_data/configs/*.yaml`). For each, the legacy
-// planner produces a StreamingConfig with one or more `aggregation_id`
-// entries keyed on (sketch_kind, sketch_params).
-//
-// Phase β asserts the CONTROL PLANE's L1→L3→L4 path produces a functionally
-// equivalent set of bound aggregations for the same input strings. We
-// don't load the YAML files — that would couple the control plane to the
-// asap-planner-rs test fixture layout. Instead each test embeds the
-// representative query string from the corresponding fixture YAML and
-// pins the expected (sketch_kind | archive-only) outcome.
+// Representative PromQL workloads pin the expected sketch or archive binding.
 
 /// Helper: parse a PromQL string to the canonical L3 `QueryExpr`, bind to
 /// L4. Returns the produced `PhysicalExpr` for assertion.
@@ -811,11 +779,7 @@ fn phase_b_e2e_archive_only_e2e_binding() {
     assert!(crate::emit::extract_root_sketch_algorithm(&bound).is_none());
 }
 
-/// Cross-cutting: every Phase β archive-only intent reaches
-/// `bind_query_expr` and lands as a `Logical` pass-through whose contents
-/// the L5 emitter can route via `archive_only()`. Mirrors Phase γ's
-/// "delete asap-planner-rs without losing coverage" goal — none of these
-/// raise an error or panic; all produce a valid L4 expression.
+/// Archive-only intents must produce valid logical expressions without errors.
 #[test]
 fn phase_b_archive_only_intents_round_trip_through_binder() {
     let intents = vec![
diff --git a/control_plane/src/physical/runtime_capability.rs b/control_plane/src/physical/runtime_capability.rs
index 67f6caf67..92b68e300 100644
--- a/control_plane/src/physical/runtime_capability.rs
+++ b/control_plane/src/physical/runtime_capability.rs
@@ -89,54 +89,18 @@ pub enum Capability {
     ExactAgg(AggregationType),
 }
 
-/// PromQL outer-function flavour carried on each `ASAPTierCandidate` so
-/// the engine can distinguish `rate(metric[r])` / `irate(...)` from
-/// `sum_over_time(metric[r])` / `sum(metric)` / bare selector WITHOUT
-/// re-parsing the raw PromQL string.
+/// PromQL counter-function shape carried to execution without reparsing.
+/// The inner counter function wins for composed expressions.
 ///
-/// Background: until the Phase 2 semantic retarget (ASAPController
-/// alignment), the lowerer collapsed every `AggFunc` in
-/// `{Sum, Rate, Increase, Delta}` onto a single `AggIntent::Sum`, which
-/// `capability_for` then mapped to `Capability::ExactAgg(Sum)` for all
-/// of them — erasing the rate-vs-plain distinction the engine needs to
-/// decide between the plain ExactAgg reducer and the rate-divisor
-/// reducer (`evaluate_exact_agg_rate`). `OuterFn` was introduced to
-/// carry that distinction back (replacing an earlier raw-string
-/// `query_contains_rate_call` re-parse). `rate`/`increase` now bind
-/// their own `AggIntent::Rate`/`AggIntent::Increase` (matching
-/// `asap_aware_mapping::boundary::implementation_for`'s `SummaryKind::Rate`/
-/// `Increase` — ASAPController models Rate as a distinct summary
-/// family), both mapping to `Capability::ExactAgg(AggregationType::Increase)`;
-/// only `sum`/`sum by (...)`/bare selectors and `sum_over_time` still
-/// bind `AggIntent::Sum` → `ExactAgg(Sum)`. `OuterFn` still carries the
-/// PromQL-function-shape distinction `Capability` doesn't encode (e.g.
-/// which divisor/accumulation strategy `evaluate_exact_agg_rate` uses),
-/// but the sid-matching predicate is no longer purely `ExactAgg(Sum)`
-/// -- see `Capability::is_satisfied_by`'s `sum_satisfies_increase` for
-/// how a Sum-registered sid still answers an `ExactAgg(Increase)`
-/// required capability.
+/// Counter state contains per-window deltas:
 ///
-/// The walker that populates this lives in `asap_tier_analysis.rs`
-/// (`trace_from_promql`) — it picks the most-specific counter-function
-/// flavour found anywhere in the expression tree (inner-function wins
-/// for composed shapes like `sum by (...) (rate(...))`).
+/// * Plain sum accumulates stored deltas.
+/// * Rate sums deltas over the range and divides by covered seconds.
+/// * Increase sums deltas over the range.
+/// * Sum-over-time requires archive execution because cumulative samples
+///   cannot be reconstructed from delta state alone.
 ///
-/// ## Counter-function taxonomy (issue #301)
-///
-/// Post-#299 the agent streams per-window DELTAS for counters. The four
-/// PromQL counter idioms have genuinely different semantics over those
-/// deltas. Before #301 the engine only distinguished `Rate` from
-/// everything else, so `sum`, `sum_over_time`, `increase`, and
-/// instant-sum all hit the same reducer path and returned the same
-/// (wrong) number. This enum carries the function distinction the
-/// engine needs to dispatch correctly:
-///
-/// | Variant       | PromQL                       | `required_capability`  | Engine dispatch                                   |
-/// |---------------|------------------------------|-------------------------|----------------------------------------------------|
-/// | `Plain`       | `sum(c)` / `sum by (..) (c)` | `ExactAgg(Sum)`         | accumulate ALL windows → cumulative-since-storage |
-/// | `Rate`        | `rate(c[r])` / `irate(c[r])` | `ExactAgg(Increase)`    | Σ deltas in `[t-r,t]` ÷ min(r, coverage)          |
-/// | `Increase`    | `increase(c[r])`             | `ExactAgg(Increase)`    | Σ deltas in `[t-r,t]` (one cumulative number)     |
-/// | `SumOverTime` | `sum_over_time(c[r])`        | `ExactAgg(Sum)`         | capability-miss → archive (can't reconstruct)     |
+/// Rate and Increase require the Increase capability; plain sum requires Sum.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum OuterFn {
     /// No range-style counter function in the expression — bare selector,
@@ -686,17 +650,8 @@ mod tests {
 
     #[test]
     fn is_satisfied_by_concrete_kind_matches_same_family() {
-        // Intentional broadening vs. this module's pre-`sketch_family_satisfied`
-        // behavior: a concrete required handle used to need an EXACT
-        // available match (only `Any` unlocked family-level matching).
-        // Delegating to `sketch_family_satisfied` makes family membership
-        // the only thing that matters, matching enum-unification-plan.md §5's
-        // table ("Kll or DDSketch | the other one | yes ... either
-        // answers a quantile requirement not pinned to a concrete kind") —
-        // that rule isn't conditioned on whether the requirement happened
-        // to spell out `Any` or a concrete kind. Harmless in practice:
-        // `capability_for` never emits a concrete `QuantileApprox` handle
-        // (always `Any`), so this path is exercised only defensively.
+        // Quantile capability matching accepts either KLL or DDSketch, including
+        // when the required handle names a concrete family.
         let required = Capability::QuantileApprox(Some(SketchAlgorithm::DDSketch));
         let indexed_dd = Capability::QuantileApprox(Some(SketchAlgorithm::DDSketch));
         let indexed_kll = Capability::QuantileApprox(Some(SketchAlgorithm::Kll));
diff --git a/control_plane/src/physical/stage_split.rs b/control_plane/src/physical/stage_split.rs
index 34660c3b3..3a182821a 100644
--- a/control_plane/src/physical/stage_split.rs
+++ b/control_plane/src/physical/stage_split.rs
@@ -1,15 +1,5 @@
-//! L5 stage split — assign the L4 `PhysicalExpr` DAG across pipeline stages.
-//!
-//! The control plane's L5: take the sketch-bound `PhysicalExpr` produced
-//! by `physical::post_asap::bind_query_expr`, colour its DAG by `StageId`
-//! across the DC three-stage topology (`crate::physical::colored_dag::
-//! StageAllocator` + `ThreeStageEmitter`), and return one
-//! `StageConfig` per stage for the per-stage emitters in
-//! `crate::emit::stage_config` to materialise into wire bytes.
-//!
-//! An earlier `QueryExpr`-consuming, `StagedPlan`-producing path
-//! (`split_expr_by_stage`) was the redundant second L5 — it has been
-//! retired; `split_typed_three_stage` below is the sole L5.
+//! Assign the bound physical DAG to edge, gateway, and backend stages.
+//! [`split_typed_three_stage`] returns structured stage configs for wire emission.
 
 /// Env-var that opts *out* of the typed L5 stage_split path. The typed
 /// path — `physical::post_asap::PhysicalExpr` (L4) → `split_typed_three_stage`
diff --git a/control_plane/src/physical/workload_planner.rs b/control_plane/src/physical/workload_planner.rs
index 1675b8d3a..d0b1ec147 100644
--- a/control_plane/src/physical/workload_planner.rs
+++ b/control_plane/src/physical/workload_planner.rs
@@ -36,39 +36,12 @@ fn mvp_deployment_policy(
     })
 }
 
-/// Bind a `QueryWorkload` into the typed L4 [`crate::physical::post_asap::PhysicalExpr`]
-/// IR, when callers want to inspect the typed binding alongside the
-/// legacy `CollectionPlan` output.
+/// Bind a flat workload to a typed physical expression for stage emission.
 ///
-/// **Family-per-metric picker** (issue #46, MVP demo). The contract pins
-/// six metric→family rows (`http_latency_ms` → DDSketch, `request_size_bytes`
-/// → KLL, `unique_users_per_min` → HLL, `top_endpoint_qps` → CountSketch,
-/// `endpoint_request_freq` → CMS, `http_requests_total` → raw). The
-/// deployment policy below handles the contract rows and falls back to the
-/// `AggType`-driven default (Quantile→DDSketch, Cardinality→HLL,
-/// Frequency→CMS) for any other metric name.
-///
-/// **`sketch_type_override` wins.** When the workload-spec carries a
-/// `sketch_type_override`, that field bypasses the capability-matched
-/// default and pins the family directly (modulo `(sketch, statistic)`
-/// validity — an override that violates the catalog is rejected and the
-/// fallback path runs). This is the spec's `sketch_family_override`
-/// behaviour.
-///
-/// **`SumRateCount` declines.** Metrics whose contract row is "raw
-/// passthrough" (`http_requests_total`) return `None` — the typed path
-/// has no sketch to bind, and the legacy `plan()` path produces the
-/// raw-passthrough `CollectionPlan`.
-///
-/// Returns `None` when the workload shape is not yet supported by the
-/// typed path (multi-intent, exact-required, raw-passthrough metric, or
-/// no aggregations) — the caller should then fall back to the legacy
-/// `plan()` output.
-///
-/// Phase B (MVP v6) wires `main::handle_plan` to call this whenever
-/// the parallel `USE_TYPED_STAGE_SPLIT` gate is enabled — the bound
-/// `PhysicalExpr` is then fed into `planner::stage_split::split_typed_three_stage`
-/// + the per-stage emitters in `config::stage_config`.
+/// An explicit sketch override takes precedence when valid for the statistic.
+/// Otherwise deployment contract rows select the family, with aggregation-type
+/// defaults for other metrics. Unsupported and raw-passthrough workloads
+/// return `None`.
 pub fn bind_workload_typed(w: &QueryWorkload) -> Option<crate::physical::post_asap::PhysicalExpr> {
     bind_workload_typed_with_evidence(w, None, None)
 }
diff --git a/control_plane/src/query_parser/mod.rs b/control_plane/src/query_parser/mod.rs
index 96ec586ee..c7b9b2f6e 100644
--- a/control_plane/src/query_parser/mod.rs
+++ b/control_plane/src/query_parser/mod.rs
@@ -1,29 +1,10 @@
-//! SP-1 query workload extraction — PromQL parser.
+//! PromQL workload extraction through `asap_frontend_promql::lower_promql`.
 //!
-//! L1 adoption (`control_plane/docs/design-target-architecture.md` Part
-//! B): the PromQL parsing + L1→L2→L3 lowering previously done by this
-//! crate's own `promql.rs` (retired) is now `asap_frontend_promql::lower_promql`
-//! directly — no local parser, no local L2 relational tree. This crate's
-//! own `intent_algebra::lower.rs` two heuristics (multi-agg fusion, the
-//! windowed-Count-as-Frequency trigger) do **not** run anymore; per
-//! explicit direction, this adopts whatever `AggIntent` classification
-//! ASAPController's `asap_l2::lower` produces as-is (e.g. a classic
-//! `by (le)` `histogram_quantile(...)` now correctly classifies as the
-//! exact `AggIntent::HistogramQuantile`, not the sketchable `Quantile`
-//! this deployment previously forced; grouped/windowed `count_over_time`
-//! becomes plain exact `Count`, not the `Frequency` extension) rather
-//! than reconciling it back to the old local behavior.
+//! ASAPPlanner owns parsing and intent classification. Both entry points require
+//! an explicit `AccuracyTarget` because lowering can size summaries.
 //!
-//! # Entry points
-//!
-//! | Function | Returns | Use |
-//! |---|---|---|
-//! | [`parse_query_expr_canonical`] | canonical `query_expr::QueryExpr` | Full algebra IR |
-//! | [`parse_query`] | `ParsedQuery` | Backward compat with existing analyzer |
-//!
-//! Both now take an explicit [`AccuracyTarget`] — `lower_promql` requires
-//! one (accuracy-driven parameter sizing happens as early as L1/L2 for
-//! some intents), where the old local pipeline took none.
+//! * [`parse_query_expr_canonical`] returns the canonical query expression.
+//! * [`parse_query`] projects it into `ParsedQuery` for workload analysis.
 
 use std::collections::HashMap;
 use std::time::Duration;
@@ -477,11 +458,8 @@ mod tests {
     #[test]
     fn canonical_query_quantile_yields_aggregate_over_time_range() {
         use planner_types::pre_asap::QueryExpr as CQueryExpr;
-        // `asap_l2::lower` models a range-vector selector (`m[5m]`) as
-        // `TimeRange`, not `Window` -- `Window` is reserved for real
-        // streaming/tumbling windows. `Aggregate` sits directly on top,
-        // no `Window` wrapper (see this module's own doc for why this
-        // differs from the retired local parser's shape).
+        // Range-vector selectors lower to `TimeRange`; `Window` represents streaming
+        // windows. The aggregate sits directly above the range selector.
         let expr = parse_query_expr_canonical(
             "quantile_over_time(0.99, http_request_duration{env=\"prod\"}[5m])",
             ACC,
diff --git a/control_plane/src/replan.rs b/control_plane/src/replan.rs
index 4ee23c58a..cfc184e51 100644
--- a/control_plane/src/replan.rs
+++ b/control_plane/src/replan.rs
@@ -508,23 +508,9 @@ impl Replanner {
                 self.opamp.push(&agent_id, cfg).await;
             }
         }
-        // Option B: post the typed cumulative `StreamingConfig` +
-        // `BackendStorageRouting` JSON to the backend through the
-        // SAME helper `main::handle_plan` uses. The shared
-        // `backend_routing_cache` (when wired via
-        // `with_backend_routing_cache`) is updated under the helper's
-        // lock and the cumulative POST surfaces every `(metric, role)`
-        // pair the controller has planned — so the data plane's
-        // atomic `handle.swap(new_config)` never wipes sibling
-        // aggregations the way the retired
-        // `generate_streaming_config_yaml` single-aggregation YAML
-        // path did.
-        //
-        // The cache is shared with `AppState`; if the Replanner was
-        // built without one (test fixture), we fall back to a
-        // throwaway local cache so the helper still emits — the
-        // cumulative semantics degrade gracefully (the Replanner is
-        // the sole writer in that scenario).
+        // Push cumulative typed configuration through the same helper as HTTP planning.
+        // The shared cache preserves every metric and role under atomic backend swaps.
+        // Tests without a shared cache use a local cache with this replanner as sole writer.
         if stage_split::typed_stage_split_enabled() {
             if let Some(be) = self.build_backend_stage_config(&workload, role) {
                 let fallback_cache = self.backend_routing_cache.clone();
diff --git a/control_plane/src/types.rs b/control_plane/src/types.rs
index 93763b678..079f61f10 100644
--- a/control_plane/src/types.rs
+++ b/control_plane/src/types.rs
@@ -194,19 +194,8 @@ impl std::fmt::Display for SketchType {
     }
 }
 
-// Moved from the retired `physical::post_asap::sketch_params` (Stage 3 of the
-// sketch-identity unification — see
-// scratchpad/artifacts/enum-unification-plan.md) when `physical::post_asap::SketchAlgorithm`
-// was replaced by `planner_types::post_asap::SummaryKind` (later `planner_types::post_asap::
-// SketchAlgorithm` once ASAPPlanner split the old flat `SummaryKind` per-family —
-// see control_plane/docs/design-asapplanner-pin-migration.md). `SketchType::
-// from(SketchAlgorithm)` only covers the 5 canonical families this legacy type has
-// room for — physical deployment callers only
-// ever feed it kinds sourced from `default_capability_table`/
-// `load_capability_overrides`, which are exhaustively those 5, all
-// approximate-sketch families (no exact-accumulator kind is ever passed
-// here, so the post-split `SketchAlgorithm` — never `ExactKind` — is the right
-// upstream type to convert from/to).
+// Only the five sketch families in the deployment capability table can be
+// converted to this deployment vocabulary; exact accumulators are not inputs.
 impl From<planner_types::post_asap::SketchAlgorithm> for SketchType {
     fn from(k: planner_types::post_asap::SketchAlgorithm) -> Self {
         use planner_types::post_asap::SketchAlgorithm;
diff --git a/control_plane/src/types_v2.rs b/control_plane/src/types_v2.rs
index b28b97dab..24547544c 100644
--- a/control_plane/src/types_v2.rs
+++ b/control_plane/src/types_v2.rs
@@ -32,21 +32,9 @@ pub use asap_types::QueryLanguage;
 
 // ── AccuracyTarget ────────────────────────────────────────────────────────────
 
-/// Per-target accuracy SLA, in the typed form `design.md` §6 calls for.
-///
-/// Re-exported from `planner_types::types` (formerly `asap_ir::types` -- ASAPPlanner
-/// consolidated `asap-ir` into `asap-types`, see
-/// control_plane/docs/design-asapplanner-pin-migration.md) rather than
-/// defined locally -- `AggIntent`'s `accuracy` fields are typed against
-/// ASAPPlanner's `AccuracyTarget`, so keeping a separate local type here
-/// would force a conversion at every one of the ~400 `AggIntent` call
-/// sites. Two real differences from the pre-merge local type, both
-/// confirmed safe to fold on (no external YAML/JSON persists the old wire
-/// shape -- only one in-Rust test fixture, `pipeline.rs`, needed updating):
-/// - Wire shape: was `#[serde(tag = "kind", content = "value")]`
-///   (`{"kind": "epsilon", "value": 0.02}`); now serde's default
-///   externally-tagged representation (`{"Epsilon": 0.02}`).
-/// - `EpsilonDelta`'s second field is `epsilon`, not `eps`.
+/// Per-target accuracy SLA, shared with ASAPPlanner's `AggIntent` fields.
+/// Uses Planner's externally tagged serde representation, e.g.
+/// `{"Epsilon": 0.02}`; `EpsilonDelta` names its bound `epsilon`.
 pub use planner_types::types::AccuracyTarget;
 
 /// Translate the legacy `accuracy_sla: f64` field -- a fractional
diff --git a/control_plane/src/workload.rs b/control_plane/src/workload.rs
index 1c76f0181..91c9269d5 100644
--- a/control_plane/src/workload.rs
+++ b/control_plane/src/workload.rs
@@ -371,34 +371,12 @@ pub struct WorkloadEntry {
     pub repeat_every: Option<String>,
 }
 
-/// Build the planning [`crate::pipeline::QuerySpec`] a declarative registry
-/// entry describes.
+/// Build the planning spec from a declarative registry entry.
 ///
-/// **Why this exists**: the YAML → planner conversion used to be an inline
-/// struct literal, hand-copied into the controller's startup pre-population
-/// loop and into the test helpers that claim to mimic it. Every field added to
-/// [`WorkloadEntry`] then had to be re-threaded in each copy, and
-/// `repeat_every` is the field that proves the cost: the HTTP
-/// `POST /api/v1/plan` path carried the declared cadence into
-/// [`crate::types::QueryWorkload::repeat_every`] while the startup path pinned
-/// `None`, so the same declaration was costed with two different batch-mode
-/// flush periods depending on which entry point registered it.
-///
-/// Field notes preserved from the original loop:
-/// * MVP blocker B4 — `time_window` is left EMPTY when the entry carries a
-///   `query_string` so the analyzer parses the matrix-selector `[range]`
-///   instead of a hardcoded `5m` overriding what the operator wrote. Entries
-///   without a query string keep the historical `5m` default, because the
-///   parser has nothing to read and the analyzer errors out without one.
-/// * MVP blocker B3 — `grouping_labels` is threaded into `group_by_labels`.
-///   The analyzer merges it with any `by (...)` keys the PromQL parser
-///   surfaces, which `collect_metric_to_grouping_labels` drops into
-///   `EdgeStageConfig::metric_to_grouping_labels` so the agent's
-///   `keep_keys(datapoint.attributes, [...])` OTTL processor strips wire attrs
-///   down to this list BEFORE sketching.
-/// * `sketch_family_override` is threaded into `QuerySpec::sketch_type`, which
-///   populates `QueryWorkload::sketch_type_override` — what `bind_workload_typed`
-///   reads to honour the MVP §46 HLL / CountSketch / CountMinSketch pins.
+/// Use one conversion for startup and HTTP planning so cadence and sizing agree.
+/// Leave `time_window` empty for query strings: the parser must read the declared
+/// range. Explicit-field entries default to `5m`. Grouping labels and sketch
+/// overrides must reach the planner and the edge configuration.
 pub fn query_spec_for_entry(entry: &WorkloadEntry) -> crate::pipeline::QuerySpec {
     crate::pipeline::QuerySpec {
         query_string: entry.query_string.clone(),
@@ -1067,16 +1045,8 @@ mod tests {
 
     #[test]
     fn agg_role_classic_bucket_histogram_quantile_is_other() {
-        // L1 adoption (design-target-architecture.md Part B), accepted
-        // behavior change: the retired local parser unconditionally
-        // substituted `histogram_quantile(...)` with a sketchable
-        // `Quantile` intent. `lower_promql` instead detects the classic
-        // `_bucket` + `rate(...)` shape and produces the real,
-        // exact-only `AggIntent::HistogramQuantile`, which `capability_for`
-        // has no sketch-family mapping for (see
-        // `asap_tier_analysis::analyze_histogram_quantile_partially_answerable_via_inner_composition`).
-        // `derive_agg_role`'s wildcard arm correctly routes it to `Other`
-        // rather than misclassifying it as a sketch-routable `Quantile`.
+        // Classic `_bucket` + `rate(...)` histogram quantiles lower to the
+        // exact-only `HistogramQuantile` intent, classified here as `Other`.
         assert_eq!(
             derive_agg_role(&entry(
                 "m",
diff --git a/crates/asap_types/src/aggregation_config.rs b/crates/asap_types/src/aggregation_config.rs
index c18fb4822..52f27b24d 100644
--- a/crates/asap_types/src/aggregation_config.rs
+++ b/crates/asap_types/src/aggregation_config.rs
@@ -89,17 +89,8 @@ impl WindowMaterializationLayout {
     }
 }
 
-/// Per-aggregation policy carried in the streaming config.
-///
-/// **PR 5 (merged-sid-identity refactor)** retired the
-/// controller-allocated `aggregation_id: u64` field. Identity is now
-/// content-addressed via [`PolicyFingerprint`] — derive on demand with
-/// [`PolicyFingerprint::from_config(&cfg)`].
-///
-/// The YAML wire shape no longer carries `aggregationId` (the
-/// controller stopped emitting it in M2.2; this PR makes the backend
-/// stop reading it). Existing fixtures that still spell out
-/// `aggregationId: N` parse cleanly — the field is silently dropped.
+/// Per-aggregation policy with content-derived [`PolicyFingerprint`] identity.
+/// An `aggregationId` field in input YAML is ignored for compatibility.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PrecomputeMaterialization {
     pub aggregation_type: AggregationType,
diff --git a/crates/asap_types/src/aggregation_type.rs b/crates/asap_types/src/aggregation_type.rs
index f1e4f0f97..2e03ef5ce 100644
--- a/crates/asap_types/src/aggregation_type.rs
+++ b/crates/asap_types/src/aggregation_type.rs
@@ -1,22 +1,6 @@
-//! Formerly `promql_utilities::query_logics::enums::AggregationType` — moved
-//! here as the final step of retiring the `promql_utilities` crate (see
-//! `scratchpad/artifacts/retirement-plan.html` / the earlier Stage 1-3 work
-//! that already moved `Statistic`/`KeyByLabelNames`/`QueryResultType` out of
-//! it for the same reason). By the time this moved, `promql_utilities` held
-//! nothing but this one type — `asap_types` is its real center of gravity
-//! (`compatible_agg_types`, `AggregationConfig`, `PolicyFingerprint`,
-//! `capability_matching`), and is the shared foundation both
-//! `control_plane`'s ecosystem and `data_plane` can depend on without a
-//! cycle, so there was no longer a reason for a separate crate.
-//!
-//! Note: this is representation **D** in
-//! `scratchpad/artifacts/enum-unification-plan.md` — the data-plane's own
-//! `AggregationType` + `String` sub-type + untyped params bag, conflating
-//! sketch/accumulator identity with a keyed/unkeyed axis. Step 5 of that
-//! plan introduced `AccumulatorSpec` as a typed, unconflated replacement
-//! (additive so far, not yet fully replacing this type) — this move is
-//! purely about which crate `AggregationType` lives in, not a change to
-//! its shape or semantics.
+//! Shared aggregation vocabulary for configuration and accumulator dispatch.
+//! The wire shape combines aggregation type, subtype, and parameters.
+//! `AccumulatorSpec` provides a typed representation at conversion boundaries.
 
 use serde::{Deserialize, Serialize};
 use std::fmt;
diff --git a/crates/asap_types/src/enums.rs b/crates/asap_types/src/enums.rs
index 9e65753c7..96cf0a0c0 100644
--- a/crates/asap_types/src/enums.rs
+++ b/crates/asap_types/src/enums.rs
@@ -136,26 +136,8 @@ impl FromStr for CleanupPolicy {
     }
 }
 
-/// Window lifecycle/flush semantics for streaming aggregations.
-///
-/// Formerly a local `WindowType` (`Tumbling`/`Sliding`) enum, retired in
-/// favor of a re-export of `asap_ir::intent_algebra::query_expr::WindowKind`
-/// (ASAPController PR #143 added `Copy`/`Default`/`Hash`/`Display`/
-/// `FromStr` and `#[serde(rename_all = "snake_case")]` upstream
-/// specifically so that re-export could replace the old local type
-/// without touching any call site's behavior).
-///
-/// **Vendored back as a local type** (ASAPPlanner pin migration, see
-/// `control_plane/docs/design-asapplanner-pin-migration.md`): ASAPPlanner
-/// deleted `QueryExpr::Window` outright ("no producer exists" — issue
-/// #181/#192) and with it every trace of a window-lifecycle `WindowKind`
-/// concept; ASAPPlanner's own scope (a batch query-workload planner, not
-/// a streaming execution engine) has no use for tumbling/sliding/session
-/// flush semantics. This workspace's streaming aggregation config still
-/// does, so the type moves back to being owned here — same shape as the
-/// old re-export (`Tumbling` default, lowercase `Display`/`FromStr`
-/// round-trip, same wire format), so none of this repo's ~145 call sites
-/// needed to change.
+/// Window lifecycle and flush semantics owned by streaming configuration.
+/// Tumbling is the default; wire names are lowercase.
 #[derive(
     Debug, Clone, Copy, Default, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
 )]
diff --git a/crates/asap_types/src/policy_fingerprint.rs b/crates/asap_types/src/policy_fingerprint.rs
index 765e3172b..ca7353aa1 100644
--- a/crates/asap_types/src/policy_fingerprint.rs
+++ b/crates/asap_types/src/policy_fingerprint.rs
@@ -64,13 +64,8 @@ use crate::aggregation_config::AggregationConfig;
 pub struct PolicyFingerprint(pub u64);
 
 impl PolicyFingerprint {
-    /// Sentinel "unset / legacy" fingerprint produced by
-    /// `PolicyFingerprint::default()`. PR 5 retired the
-    /// `aggregation_id` field on `AggregationConfig`, so there's no
-    /// legacy id to fall back to anymore — production sinks now treat
-    /// `UNSET` as a control-plane bug worth surfacing. Callers should
-    /// always populate `policy_fp` via [`Self::from_config`] at
-    /// construction.
+    /// Unset sentinel returned by `Default`. Sinks cannot resolve an unset policy;
+    /// construct valid fingerprints with [`Self::from_config`].
     pub const UNSET: PolicyFingerprint = PolicyFingerprint(0);
 
     /// True when this fingerprint is the [`Self::UNSET`] sentinel.
diff --git a/data_plane/src/drivers/ingest/otel.rs b/data_plane/src/drivers/ingest/otel.rs
index df3396763..c3ebfaffc 100644
--- a/data_plane/src/drivers/ingest/otel.rs
+++ b/data_plane/src/drivers/ingest/otel.rs
@@ -229,7 +229,7 @@ impl MetricsService for MetricsServiceImpl {
             // refresh stale entries and pick up brand-new ones from this
             // field without a separate `ResolveSeriesIDs` round-trip.
             series_assignments: outcome.series_assignments,
-            // Phase 4 — backend signals senders to evict cached sids here
+            // backend signals senders to evict cached sids here
             // when this Export carried a sid the resolver does not
             // recognize (sid-cache divergence — e.g. after a backend
             // restart without persistence, or when the sender's sid
@@ -666,17 +666,9 @@ async fn route_otlp_to_precompute(
         .map(|plan| plan.runtime_config.clone())
         .unwrap_or_else(|| ingest_state.config_snapshot());
     let agg_configs = snap.get_all_aggregation_configs();
-    // Schema retirement #5 — the agg_id-keyed `SchemaRegistry` is
-    // gone; sid-level lifecycle now lives on `SketchStore`. Reconcile
-    // against the current streaming config so newly-added /
-    // newly-retired sids transition immediately. The §6.3 ingest
-    // barrier is enforced at the sid level inside
-    // `SketchStore::ingest_precompute_for_agg_config`.
-    //
-    // Gated on the config `Arc` identity: the streaming config only
-    // changes on a (rare) control-plane swap, so in steady state this
-    // collapses to a single relaxed atomic load and skips the full
-    // catalog scan — the dominant ingest-path CPU cost in profiling.
+    // Reconcile sid lifecycle using the current streaming-config snapshot.
+    // The store enforces the write barrier for retired and expired instances.
+    // A config-Arc identity check skips catalog scans while the config is unchanged.
     let _ = crate::storage_engines::sketch_db::lifecycle::reconcile_if_config_changed(
         ingest_state.sketch_index.as_ref(),
         &snap,
@@ -700,14 +692,8 @@ async fn route_otlp_to_precompute(
     let mut by_bucket: HashMap<u64, (BucketTuple, Vec<SampleTuple>)> = HashMap::new();
     let mut raw_matched = 0usize;
     let mut raw_unmatched = 0usize;
-    // Schema retirement #3 (plan step #3) dropped the agg_id-keyed
-    // `schemas.is_writable` ingest barrier. The §6.3 contract still
-    // holds: `SketchStore::ingest_precompute_for_agg_config` rejects
-    // writes targeting retired/expired sids at the sid-level
-    // (per-sid `is_writable`). The retained empty map below feeds
-    // `flush_barrier_drops` so the counter / log shape doesn't
-    // change for /metrics consumers; once schema/ is fully retired
-    // the counter moves to sid-level wiring.
+    // The store enforces the sid-level write barrier. This empty map preserves
+    // the barrier-log interface without duplicating that check.
     let raw_barrier_drops: HashMap<u64, u64> = HashMap::new();
 
     for point in points {
@@ -946,10 +932,7 @@ async fn route_modified_otlp_sketches_to_precompute(
         preflight_summary_frames(request, ingest_state, active)?;
     }
     let agg_configs = snap.get_all_aggregation_configs();
-    // Schema retirement #5 — agg_id-keyed registry retired; sid-level
-    // reconcile is the only path going forward. See the raw-OTLP
-    // routine above for the full rationale (incl. the config-Arc gate
-    // that skips the catalog scan when the config is unchanged).
+    // Reconcile sid lifecycle only when the configuration snapshot changes.
     let _ = crate::storage_engines::sketch_db::lifecycle::reconcile_if_config_changed(
         ingest_state.sketch_index.as_ref(),
         &snap,
@@ -976,7 +959,7 @@ async fn route_modified_otlp_sketches_to_precompute(
     // Schema-keyed barrier dropped (see `raw_barrier_drops` above);
     // sid-level barrier in `SketchStore` carries §6.3 going forward.
     let barrier_drops: HashMap<u64, u64> = HashMap::new();
-    // Phase 4 — sids the receiver did not recognize this Export. Returned
+    // sids the receiver did not recognize this Export. Returned
     // to the caller so the gRPC / HTTP handler can stamp them into
     // `ExportMetricsServiceResponse.unknown_series_ids`. Senders evict
     // these sids and re-emit with attributes; backend re-resolves and
@@ -1366,7 +1349,7 @@ async fn route_modified_otlp_sketches_to_precompute(
                         }
                     }
 
-                    // Phase 5 — register a `SketchInstanceMetadata` on
+                    // register a `SketchInstanceMetadata` on
                     // first sight of `sid` and append this DP's sketch
                     // state to the per-sid columnar storage. The instance
                     // is keyed by sid, so subsequent DPs on the same sid
@@ -2228,16 +2211,16 @@ struct ModifiedOtlpSketchDp {
     time_unix_nano: u64,
     sketch: Vec<u8>,
     encoding: i32,
-    /// Phase 4 — sender-supplied series_id, 0 when unset / first emit.
+    /// sender-supplied series_id, 0 when unset / first emit.
     /// Backend's resolver mints a fresh sid when this is 0 with attrs
     /// populated; pushes the sid into `unknown_series_ids` when this is
     /// non-zero with empty attrs and the resolver doesn't recognize it.
     series_id: u64,
-    /// Phase 5 — DataPoint-level start of the sketch window. Combined
+    /// DataPoint-level start of the sketch window. Combined
     /// with `time_unix_nano` to form the `(start_ms, end_ms)` window
     /// the SketchStore's columnar storage keys on.
     start_time_unix_nano: u64,
-    /// Phase 5 — sketch-instance configuration lifted off the parent
+    /// sketch-instance configuration lifted off the parent
     /// container. Drives `SketchInstanceMetadata.sketch_config` and the
     /// derived `AccuracyBound`.
     container_config: crate::storage_engines::sketch_db::index::SketchConfig,
@@ -3631,7 +3614,7 @@ mod dispatcher_tests {
     }
 }
 
-/// Phase 4 — sid-resolution gate tests. Construct an OTLP DDSketch
+/// sid-resolution gate tests. Construct an OTLP DDSketch
 /// Export with one DataPoint per scenario, run it through
 /// `route_modified_otlp_sketches_to_precompute`, and assert on the
 /// returned `unknown_series_ids` plus the SeriesIdResolver / SketchStore
diff --git a/data_plane/src/drivers/ingest/series_resolver.rs b/data_plane/src/drivers/ingest/series_resolver.rs
index 5bfb68d28..d037fad61 100644
--- a/data_plane/src/drivers/ingest/series_resolver.rs
+++ b/data_plane/src/drivers/ingest/series_resolver.rs
@@ -33,19 +33,11 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use tracing::{info, warn};
 
-/// Canonical sid identity — `(metric_name, attrs_fingerprint, agg_kind_canonical)`.
+/// Canonical sid identity: `(metric_name, attrs_fingerprint, agg_kind_canonical)`.
 ///
-/// This is the same 3-tuple that the retired `compute_sketch_sid` /
-/// `compute_sid` functions hashed over, just held as a string key
-/// for the registry-allocated mint path.
-///
-/// - `attrs_fingerprint` — keys sorted lexicographically, then
-///   `key=value;`-joined. Matches the patched OTel-Go exporter so
-///   sender and receiver agree bit-exactly.
-/// - `agg_kind_canonical` — the stable string form of `AggKind` (see
-///   `sketch_db::data::AggKind::canonical_string`). Distinguishes
-///   different aggregations over the same series — e.g. a DDSketch
-///   and a Sum on the same `(metric, attrs)` get separate sids.
+/// Sort attribute keys and join `key=value;` pairs exactly as the patched
+/// OTel-Go exporter does. The aggregation kind separates different summaries
+/// over the same metric and attributes.
 type CacheKey = (String, String, String);
 
 /// Idempotent compute-or-mint resolver. Atomic per-key — concurrent
diff --git a/data_plane/src/main.rs b/data_plane/src/main.rs
index eb19b6dd1..da59d7f17 100644
--- a/data_plane/src/main.rs
+++ b/data_plane/src/main.rs
@@ -1,15 +1,3 @@
-// Phase 9 (controller-into-backend refactor):
-// The `controller` crate is now a path-dep of this binary
-// (`../controller` in `asap-query-engine/Cargo.toml`). It is NOT yet
-// started in-process here; the in-process OpAMP server + capability-map
-// exposure are a follow-up that will land after Phase 4 (centralized
-// series_id resolver). For now we only verify that the crate compiles
-// inside this workspace and is importable from `main.rs`.
-//
-// When that follow-up lands, the OpAMP WS endpoint (port 4320) and the
-// RuntimeSamples gRPC endpoint (port 4321) will be served from inside
-// this same backend process — there is no longer a separate
-// `asap-controller` container in `mvp-multinode/run_demo.sh`.
 use clap::{Parser, ValueEnum};
 use std::fs;
 use std::sync::Arc;
@@ -288,11 +276,8 @@ struct Args {
     #[arg(long, default_value = "10000")]
     precompute_channel_buffer_size: usize,
 
-    /// Optional path where the schema registry persists per-`agg_id`
-    /// lifecycle state (created_at / retired_at / expires_at) across
-    /// restarts (sketch DB Phase 2c). When unset, the registry is
-    /// memory-only and the §7 schema timeline loses all pre-restart
-    /// history.
+    /// Compatibility option for schema persistence. Sid lifecycle persistence is
+    /// managed by the sketch store.
     #[arg(long)]
     schema_persist_path: Option<std::path::PathBuf>,
 
@@ -629,19 +614,8 @@ async fn main() -> Result<()> {
     );
     info!("Streaming config: {:?}", streaming_config);
 
-    // Wrap the streaming config in a hot-reload handle so the HTTP
-    // server's `/api/v1/streaming-config` endpoints can swap it at
-    // runtime (PR E phase 1). Existing consumers downstream
-    // (ASAPQueryEngine, PrecomputeEngine, Store) still take their
-    // startup snapshot; hot-reload currently only affects the
-    // control-plane GET/POST endpoint. Phase 2 will extend the swap
-    // to query execution and ingest routing.
-
-    // M2.3.6g — the legacy `SketchStore` construction is gone.
-    // Production data lives in `SketchStore` (allocated below); the
-    // single persistence flusher behind it is set up in the
-    // `--persistence-enabled` block lower in main.rs via
-    // `SketchStore::start_persistence`.
+    // Share a hot-reload handle with HTTP configuration endpoints and consumers.
+
     let cleanup_policy = args.cleanup_policy;
     info!("Using cleanup policy: {:?}", cleanup_policy);
     let _ = (cleanup_policy, args.lock_strategy); // Both still parsed for backwards-compat CLI; no runtime effect.
@@ -684,14 +658,8 @@ async fn main() -> Result<()> {
             .map_err(std::io::Error::other)?;
     }
 
-    // M2.3.6c — also start a persistence layer behind the SketchStore
-    // when --persistence-enabled. SketchStore is now where all
-    // precompute + sketch writes land (M2.3.6a), so flushing it to
-    // disk is what makes Phase 5 ASAP-tier state survive restarts.
-    // The legacy `SketchStore::with_persistence_per_key` flusher
-    // constructed above is now a no-op (its source has no writes) —
-    // it stays in place until subsequent M2.3.6 sub-PRs delete the
-    // legacy SketchStore wholesale.
+    // Enable persistence for the shared sketch store so precompute and sketch
+    // state survive restarts.
     let _sketch_index_persistence = if args.persistence_enabled {
         use data_plane::storage_engines::sketch_db::index::persistence::SketchStorePersistenceConfig;
         let disk_path = args
@@ -895,9 +863,7 @@ async fn main() -> Result<()> {
         let ingest_state = engine.ingest_state();
         info!("Starting precompute engine (ingest adapters share its bounded worker queues)");
 
-        // Spawn periodic memory diagnostics logger — M2.3.6g routes
-        // through SketchStore now that SketchStore no longer holds
-        // production data.
+        // Log memory diagnostics for the shared sketch store.
         let diag_index = sketch_index.clone();
         tokio::spawn(async move {
             spawn_memory_diagnostics(diag_index, Some(worker_diagnostics)).await;
@@ -911,9 +877,7 @@ async fn main() -> Result<()> {
         (Some(handle), Some(ingest_state))
     };
 
-    // Schema retirement #5 — agg_id-keyed `SchemaRegistry` is gone.
-    // Both ingest and query observe the §7 timeline at the sid level
-    // via the shared `SketchStore` (already passed in above).
+    // Sid lifecycle is owned by the shared sketch store.
     let engine = Arc::new(engine);
 
     // Idle-sid eviction sweep (memory reclaim) — opt-in via
@@ -1099,17 +1063,10 @@ async fn main() -> Result<()> {
         adapter_config,
     };
 
-    // The legacy in-backend query tracker / LocalPlannerClient was
-    // removed in Phase γ (deletion of `asap-planner-rs`). The
-    // ASAPCollector controller is now the sole emitter of streaming
-    // configs / `BackendStorageRouting`; the backend is a pure
-    // executor that consumes plans pushed via
-    // `POST /api/v1/streaming-config` and `POST /api/v1/storage_routing`.
-
-    // Schema retirement #5 — the HTTP server no longer takes a
-    // `SchemaRegistry`. `POST /api/v1/streaming-config` drives
-    // lifecycle transitions at the sid level via the shared
-    // `SketchStore` (already passed in below).
+    // The backend consumes streaming configuration and storage routing pushed
+    // by the control plane through their HTTP endpoints.
+
+    // HTTP endpoints inspect lifecycle metadata in the shared sketch store.
     let mut server = HttpServer::new(http_config, engine, sketch_index.clone())
         .with_active_physical_plan(active_physical_plan.clone())
         .with_probe_cache(probe_cache.clone());
@@ -1145,7 +1102,7 @@ async fn main() -> Result<()> {
     // every PromQL query instead of bypassing the EngineRouter when
     // the streaming-config single axis defaults to `SketchStore`.
     //
-    // Phase α (MVP): even when no static YAML is loaded, install an
+    // even when no static YAML is loaded, install an
     // empty hot-reload handle so the control plane's first
     // `POST /api/v1/storage_routing` push lands without first-call 503
     // lossage. Operators can still hand-author the YAML for
@@ -1196,26 +1153,9 @@ async fn main() -> Result<()> {
         ),
     );
 
-    // Phase-5/6 + Step-2.3: register the Thanos query engine on the
-    // capability router. Path A2 is the only archive path now: when
-    // `ASAP_THANOS_QUERY_URL` is set, the backend forwards
-    // archive-tier PromQL queries to a `thanos-query` sidecar via the
-    // [`ThanosQueryEngine`], registered under the single public id
-    // `thanos_query`.
-    //
-    // The superseded legacy in-process `GorillaQueryEngine` /
-    // `GorillaS3Store` leg (which read the custom GORILLA1 container
-    // format from per-hour chunks on S3 / MinIO) has been deleted now
-    // that Path A2 is verified end-to-end (agents emit XOR-chunk
-    // fragments → backend gorilla-merger → TSDB blocks → S3 →
-    // thanos-query).
-    //
-    // When `ASAP_THANOS_QUERY_URL` is not configured the binary
-    // registers a `NoDataArchiveEngine` stub under `thanos_query`
-    // so cold queries succeed with an empty result instead of
-    // surfacing as `503 NoEngineRegistered`. Operators that want the
-    // original fail-loud behaviour can opt back in by setting
-    // `ASAP_REQUIRE_ARCHIVE_ENGINE=1`.
+    // Register the Thanos forwarder when `ASAP_THANOS_QUERY_URL` is configured.
+    // Otherwise use an empty-result archive stub unless
+    // `ASAP_REQUIRE_ARCHIVE_ENGINE=1` requests fail-loud behavior.
     let mut archive_registered = false;
     match data_plane::query_engines::thanos_query_engine::thanos_engine_from_env() {
         Ok(Some(thanos)) => {
@@ -1266,16 +1206,9 @@ async fn main() -> Result<()> {
     if args.persistence_delete_older_than_secs > 0 {
         server = server.with_data_retention_ms(args.persistence_delete_older_than_secs * 1000);
     }
-    // Backfill registry (sketch DB §10). A single `Arc` lives in
-    // `main` so the HTTP endpoints (Phase 5d) can inspect / cancel
-    // jobs and the upcoming worker pool (Phase 5e) can drain them.
-    // Jobs stay `Queued` until 5e wires the worker — intentional
-    // shadow-mode behaviour that lets operators validate the
-    // control plane's REFRESH dispatch logic before workers exist.
-    // Phase 5g: when `--backfill-persist-path` is set, the registry
-    // loads prior job records from disk and rewrites the file on
-    // every state transition. When unset, the registry is
-    // memory-only and restart wipes job history.
+    // Share the backfill registry between HTTP endpoints and the worker.
+    // `--backfill-persist-path` enables recovery and atomic persistence of job
+    // transitions; without it, job history is memory-only.
     let backfill_registry = Arc::new(match args.backfill_persist_path.as_ref() {
         Some(path) => {
             data_plane::storage_engines::sketch_db::BackfillRegistry::load_or_new(path.clone())
@@ -1284,22 +1217,13 @@ async fn main() -> Result<()> {
     });
     server = server.with_backfill_registry(backfill_registry.clone());
 
-    // Phase 5e: spawn the backfill drain service if requested. When
-    // enabled with `--enable-backfill-worker`, the service picks
-    // up queued jobs and runs them through a
-    // `BackfillWindowProcessor` (real sketch rebuild + store
-    // writes). Without a reader factory configured (Phase 5h), all
-    // production `BackfillSource` variants fail fast with a clear
-    // "no reader" error — still a step up from the old shadow
-    // mode, since the control plane now gets signal that its REFRESH
-    // dispatch was received but not executable.
+    // Start the backfill worker when enabled. Each source needs a reader factory;
+    // unsupported sources fail the job with a missing-reader error.
     let backfill_service_handle = if let (true, Some(_ingest_state)) = (
         args.enable_backfill_worker,
         precompute_ingest_state.as_ref(),
     ) {
-        // Schema retirement #5 — `BackfillService::new` no longer
-        // takes a `SchemaRegistry`; it consults sid-level lifecycle on
-        // `SketchStore` instead.
+        // Backfill uses the shared streaming-config snapshot and sketch store.
         let reader_factory = match args.clickhouse_backfill_table.as_ref() {
             Some(table) => data_plane::storage_engines::sketch_db::clickhouse_reader_factory(
                 data_plane::storage_engines::sketch_db::ClickHouseReaderConfig {
@@ -1322,10 +1246,7 @@ async fn main() -> Result<()> {
             reader_factory,
             data_plane::storage_engines::sketch_db::BackfillServiceConfig::default(),
         )
-        // M2.3.6e — replayed batches land in SketchStore (the only
-        // destination after the M2.3.6g store retirement). Resolver
-        // is the same shared mint authority as live ingest, so
-        // backfilled precompute sids share the OTel namespace.
+        // Backfill and live ingest share the same sid resolver and sketch store.
         .with_sketch_index(sketch_index.clone())
         .with_series_resolver(series_resolver.clone());
         info!(
@@ -1341,7 +1262,7 @@ async fn main() -> Result<()> {
         None
     };
 
-    // Phase 5: schema eviction service. On every poll interval,
+    // schema eviction service. On every poll interval,
     // scans the schema registry for `Expired` schemas, cancels any
     // in-flight backfills targeting them, and drops the agg_id's
     // data from the store. Complements the age-based data retention
@@ -1358,9 +1279,7 @@ async fn main() -> Result<()> {
                 args.persistence_delete_older_than_secs,
             ))
         };
-        // Schema retirement #5 — retention check now uses the
-        // package-level default; per-registry retention overrides are
-        // gone with the agg_id-keyed `SchemaRegistry`.
+        // Compare data retention against the configured retirement retention.
         data_plane::storage_engines::sketch_db::warn_if_retention_inverted(
             data_retention_opt,
             data_plane::storage_engines::sketch_db::DEFAULT_RETIREMENT_RETENTION,
@@ -1511,8 +1430,7 @@ async fn spawn_memory_diagnostics(
     loop {
         interval.tick().await;
 
-        // 1. SketchStore diagnostics (M2.3.6g — replaces the
-        //    pre-M2.3 per-agg_id SketchStore::diagnostic_info).
+        // Per-sid sketch-store diagnostics.
         let instance_count = sketch_index.instance_count();
         let series_count = sketch_index.series_len();
         // `approx_memory_bytes` is the flusher's EVICTABLE-payload gauge:
diff --git a/data_plane/src/monitor/coordinator.rs b/data_plane/src/monitor/coordinator.rs
index f41520d5c..8142dcaa9 100644
--- a/data_plane/src/monitor/coordinator.rs
+++ b/data_plane/src/monitor/coordinator.rs
@@ -47,7 +47,7 @@ pub use asap_types::MonitorFunctional as Functional;
 pub struct MonitorConfig {
     pub agg_id: u64,
     pub key: Vec<u8>,
-    /// No longer consulted (alerting retired) — see the module doc comment.
+    /// Accepted for wire compatibility; unused by sampling.
     pub tau: f64,
     /// The ε-floor tolerance feeding [`epsilon_sample_floor`].
     pub epsilon: f64,
@@ -72,13 +72,8 @@ impl Default for MonitorConfig {
 /// this coordinator no longer makes alerting decisions (see module docs).
 #[derive(Clone, Debug, PartialEq)]
 pub enum Action {
-    /// Send this ONE edge its freshly-computed coordinated-sampling grant, in
-    /// direct response to its rate report. `sample_p` is the whole-sketch
-    /// ε-floor for the edge's own just-reported rate — independent of every
-    /// other edge, so (unlike the retired countdown) this never needs to
-    /// re-grant the rest of the edge set. `local_slack` is always 0: kept on
-    /// the wire message for `SlackGrant` compatibility, but carries no
-    /// meaning post-retirement — the edge no longer gates anything on it.
+    /// Grant the reporting edge its ε-floor sample probability, independently of
+    /// other edges. `local_slack` remains zero for wire compatibility.
     Grant {
         edge_id: String,
         round: u64,
@@ -157,11 +152,9 @@ impl Monitor {
         false // stale epoch
     }
 
-    /// Register (or refresh) an edge for the epoch it reports as
-    /// `window_start_ms`. Adds the edge to the membership set. No grant is
-    /// returned here — an edge is safely unsampled (p=1) until its first rate
-    /// report, and unlike the retired countdown, a new registration doesn't
-    /// need to perturb any other edge's already-granted `p`.
+    /// Register or refresh an edge in its reported epoch. Registration returns no
+    /// grant: the edge remains unsampled (p=1) until its first rate report and
+    /// does not affect other edges' grants.
     pub fn on_register(
         &mut self,
         edge_id: &str,
@@ -255,9 +248,8 @@ mod tests {
 
     #[test]
     fn registration_grants_nothing() {
-        // Unlike the retired countdown, registering does not perturb any
-        // edge's grant — an edge stays unsampled (p=1, the edge-side default)
-        // until it actually reports a rate.
+        // Registration leaves grants unchanged; the new edge remains unsampled
+        // until its first rate report.
         let mut m = Monitor::new(cfg(0.05));
         let a = m.on_register("e1", 60_000, 0);
         assert!(a.is_empty());
@@ -275,9 +267,7 @@ mod tests {
 
     #[test]
     fn report_grants_only_the_reporting_edge() {
-        // Unlike the retired countdown (which re-broadcast to every edge on
-        // any report, since slack depended on the full edge set), a report
-        // now answers ONLY the reporting edge — the sampling law is per-edge.
+        // A rate report grants only the reporting edge; sampling is per-edge.
         let mut m = Monitor::new(cfg(0.05));
         m.on_register("e1", 60_000, 0);
         m.on_register("e2", 60_000, 0);
@@ -298,11 +288,8 @@ mod tests {
 
     #[test]
     fn single_edge_is_sampled_like_any_other() {
-        // The retired countdown special-cased "<2 edges ⇒ p=1" purely to keep
-        // its alert-fire safety proof correct under sampling noise. With
-        // alerting gone, a lone high-rate edge is sampled exactly like it
-        // would be in a larger edge set — the ε-floor law never depended on
-        // edge count.
+        // A lone high-rate edge is sampled by the same law as a larger edge set;
+        // the ε-floor is independent of edge count.
         let mut m = Monitor::new(cfg(0.05));
         m.on_register("e1", 60_000, 0);
         let a = m.on_report("e1", 0, 100_000.0);
diff --git a/data_plane/src/monitor/mod.rs b/data_plane/src/monitor/mod.rs
index 6a15d6dd4..2e7263d92 100644
--- a/data_plane/src/monitor/mod.rs
+++ b/data_plane/src/monitor/mod.rs
@@ -1,33 +1,13 @@
-//! Coordinated update-sampling — the backend side of what used to be called
-//! "Discipline B" in ASAPCollector
-//! docs/continuous-monitoring-tumbling-cost-analysis.md.
+//! Backend coordination of per-edge update sampling.
 //!
-//! Global-threshold ALERTING (the CMY slack-countdown: register → grant
-//! `(slack, sample_p)` → countdown → report → alert) is RETIRED as of the
-//! 2026-07 insert-time-GOS redesign — see the `coordinator` module doc
-//! comment for the full rationale. An edge/collector must never be the thing
-//! that fires an alert; that decision belongs entirely to query-time reads of
-//! the backend's synced sketch state.
+//! Edges periodically report observation rates and receive a whole-sketch
+//! ε-floor grant, `p_i = 1/(1+ε²·rate_i)`. Each grant depends only on that
+//! edge's rate. Alert decisions belong to query-time reads of backend state.
 //!
-//! What's left: edges report their per-window observation RATE on their own
-//! periodic cadence (decoupled from any value/slack threshold), and this
-//! module answers each one with its coordinated-sampling grant — the
-//! whole-sketch ε-floor `p_i = 1/(1+ε²·rate_i)`, a pure per-edge function with
-//! no cross-edge coordination or global state involved.
-//!
-//! Layout:
-//!   - [`coordinator`] — the pure, unit-tested per-edge sampling state machine.
-//!   - [`epoch`]       — tumbling-epoch alignment (matches the edge formula).
-//!   - [`server`]      — the tonic bidi-streaming `MonitorService` server.
-//!   - [`sampling_alloc`] — the coordinated update-sampling law (ε-floor).
-//!
-//! **How hard to sample** (the per-edge `p_i`): a SINGLE law, the whole-sketch
-//! **ε-floor** `p_i = 1/(1+ε²·rate_i)` (see [`sampling_alloc`]). It depends
-//! ONLY on each edge's rate, NEVER on any monitored functional/key — because
-//! the sampling protects a SKETCH, whose accuracy is bounded by the stream
-//! norm (rate/L2), not by any single key. Applies to additive sketches —
-//! Count-Min, Count-Sketch, DDSketch, KLL, Sum — but NOT HLL (sampling biases
-//! cardinality).
+//! * [`coordinator`] maintains edge sampling state.
+//! * [`epoch`] aligns tumbling epochs.
+//! * [`server`] implements the bidirectional monitor service.
+//! * [`sampling_alloc`] defines the sampling law and eligible sketch families.
 
 pub mod coordinator;
 pub mod epoch;
diff --git a/data_plane/src/precompute_engine/accumulator_factory.rs b/data_plane/src/precompute_engine/accumulator_factory.rs
index 81ae8fb92..c033ada4e 100644
--- a/data_plane/src/precompute_engine/accumulator_factory.rs
+++ b/data_plane/src/precompute_engine/accumulator_factory.rs
@@ -920,17 +920,10 @@ pub fn config_is_keyed(config: &AggregationConfig) -> bool {
     )
 }
 
-/// Top-k ranking quantity for the `*WithHeap` configs.
+/// Top-k ranking quantity, selected by `weight_mode` or its alias `topk_weight`.
 ///
-/// Selected by `parameters["weight_mode"]` (or alias `topk_weight`):
-///   * `"value"` / `"sum"` → [`TopkWeight::Value`] (Σ value per key).
-///   * `"count"` / `"frequency"` / `"freq"` → [`TopkWeight::Count`].
-///
-/// DEFAULT is `Value` (value-weighted). The heap variants previously
-/// routed to the heap-LESS `CmsAccumulatorUpdater` (top-k unanswerable —
-/// recall 0), so there is no count-weighted heap caller to regress;
-/// value-weighting is the semantics `topk(sum_by_key(value))` needs, and
-/// genuine frequency-top-k callers opt in with `weight_mode: count`.
+/// * `value` / `sum`: sum values per key (default).
+/// * `count` / `frequency` / `freq`: count occurrences per key.
 fn topk_weight_param(config: &AggregationConfig) -> TopkWeight {
     match config.sample_update_rule() {
         asap_types::SampleUpdateRule::Count => TopkWeight::Count,
@@ -1110,10 +1103,7 @@ pub fn create_accumulator_updater(config: &AggregationConfig) -> Box<dyn Accumul
             Box::new(CmsAccumulatorUpdater::new(row_num, col_num))
         }
 
-        // Bare CountSketch: real median-of-signed-rows estimator, via the
-        // dedicated `CountSketchAccumulatorUpdater` (previously conflated
-        // with `CmsAccumulatorUpdater`'s CMS min-math — see that struct's
-        // doc).
+        // CountSketch uses the median-of-signed-rows estimator.
         (SummaryFamilyType::Sketch(kind, _), _)
             if kind.algorithm() == &SketchAlgorithm::CountSketch =>
         {
@@ -1142,9 +1132,7 @@ pub fn create_accumulator_updater(config: &AggregationConfig) -> Box<dyn Accumul
             ))
         }
 
-        // Heap-bearing top-k variant, real CountSketch math (previously
-        // conflated with `CmsHeapAccumulatorUpdater`'s CMS-with-heap — see
-        // `CountSketchWithHeapAccumulatorUpdater`'s doc).
+        // Heap-bearing CountSketch retains CountSketch estimation semantics.
         (SummaryFamilyType::Sketch(kind, _), _)
             if kind.algorithm() == &SketchAlgorithm::CountSketchWithHeap =>
         {
diff --git a/data_plane/src/precompute_engine/config.rs b/data_plane/src/precompute_engine/config.rs
index 4a18e5441..df6612be9 100644
--- a/data_plane/src/precompute_engine/config.rs
+++ b/data_plane/src/precompute_engine/config.rs
@@ -45,13 +45,8 @@ pub struct PrecomputeEngineConfig {
     /// emitted as mergeable corrections. Default: 5000 ms.
     #[serde(default = "default_wall_clock_max_open_grace_period_ms")]
     pub wall_clock_max_open_grace_period_ms: i64,
-    /// Optional path where the `SchemaRegistry` persists per-`agg_id`
-    /// lifecycle state across restarts (sketch DB Phase 2c). When
-    /// set, the registry loads prior `created_at_ms` / `retired_at_ms`
-    /// timestamps from the file on startup and atomically rewrites
-    /// the file after every config-driven reconcile. When `None`,
-    /// the registry is memory-only and the §7 timeline reflects only
-    /// post-restart history.
+    /// Compatibility option for schema persistence. Sid lifecycle persistence is
+    /// managed by the sketch store.
     #[serde(default)]
     pub schema_persist_path: Option<std::path::PathBuf>,
 }
diff --git a/data_plane/src/precompute_engine/engine.rs b/data_plane/src/precompute_engine/engine.rs
index 8d59efe94..a49bad0e7 100644
--- a/data_plane/src/precompute_engine/engine.rs
+++ b/data_plane/src/precompute_engine/engine.rs
@@ -66,13 +66,9 @@ impl PrecomputeEngine {
         // Build the router that owns the senders; it will be shared via IngestState.
         let router = SeriesRouter::new(senders);
 
-        // Ingest state holds the hot-reload handle — it re-snapshots
-        // agg_configs on each ingest batch, so new aggregations from
-        // a config swap are visible immediately.
-        //
-        // The agg_id-keyed `SchemaRegistry` has been retired — sid-level
-        // lifecycle status now lives on `SketchStore` and reconcile
-        // runs against the same snapshot the ingest path consults.
+        // Snapshot the hot-reload configuration on each ingest batch so policy
+        // changes are visible immediately. Sid lifecycle reconciliation uses
+        // the same snapshot as ingestion.
         let ingest_state = Arc::new(IngestState {
             router,
             samples_ingested: std::sync::atomic::AtomicU64::new(0),
diff --git a/data_plane/src/precompute_engine/ingest_handler.rs b/data_plane/src/precompute_engine/ingest_handler.rs
index e50323b37..e264dcbf5 100644
--- a/data_plane/src/precompute_engine/ingest_handler.rs
+++ b/data_plane/src/precompute_engine/ingest_handler.rs
@@ -124,42 +124,20 @@ pub struct IngestState {
     pub hot_reload_config: HotReloadStreamingConfig,
     /// When true, skip group-key extraction and pass raw samples through.
     pub pass_raw_samples: bool,
-    /// Per-series snapshot cache for delta-sketch reconstitution
-    /// (paper §6.2 B3 / B4). On arrival of a full `ENCODING_PROTO`
-    /// / `ENCODING_MSGPACK` frame the ingest path stores a clone of
-    /// the decoded accumulator keyed by the metric's series_key. On
-    /// arrival of a subsequent `ENCODING_PROTO_DELTA` frame it looks
-    /// up the cached base, clones it, applies the delta via
-    /// `apply_modified_otlp_delta_bytes`, and updates the cache so
-    /// the next delta composes correctly.
+    /// Per-series reconstructed sketch bases, keyed by series identity. Full frames
+    /// replace the base; delta frames update it. Window boundaries reset the base.
+    /// DashMap allows independent series to update concurrently.
     ///
-    /// DashMap chosen over `Mutex<HashMap>` so concurrent OTLP
-    /// receiver tasks don't serialize on cache access — each
-    /// series_key is an independent shard.
-    ///
-    /// Growth is bounded by the active series set in the running
-    /// streaming config; no explicit eviction yet. A cold-store
-    /// follow-up will add TTL-based eviction keyed by last-seen
-    /// timestamp so long-running deployments don't leak memory
-    /// on retired series.
-    ///
-    /// The value is a [`SnapshotCacheEntry`] — the reconstructed base
-    /// plus the window start it belongs to — so the delta-apply path can
-    /// rotate (reset) the base at a per-series window boundary.
-    ///
-    /// RES-1 — growth is now bounded by [`IngestState::note_window_and_sweep`],
-    /// which opportunistically evicts entries whose `window_start` lags
-    /// more than `IngestObservability::snapshot_max_window_lag_nanos`
-    /// behind the newest observed window. Called on every cached-base
-    /// insert from the OTLP ingest path.
+    /// [`IngestState::note_window_and_sweep`] bounds growth by evicting bases whose
+    /// window start falls behind the newest observed window by the configured lag.
     pub sketch_snapshots: dashmap::DashMap<String, SnapshotCacheEntry>,
-    /// Phase 4 — centralized series_id resolver. Shared across the OTLP
+    /// centralized series_id resolver. Shared across the OTLP
     /// receive path (sid resolution + `unknown_series_ids` population) and
     /// the `ResolveSeriesIDs` RPC (eager batch resolution from the agent's
     /// exporter). Holding it on `IngestState` lets every ingest source
     /// reach the same idempotent compute-or-mint cache.
     pub series_resolver: Arc<crate::drivers::ingest::series_resolver::SeriesIdResolver>,
-    /// Phase 5 — two-level sketch ASAP tier (instance metadata +
+    /// two-level sketch ASAP tier (instance metadata +
     /// per-sid columnar state). Populated by the OTLP ingest path on
     /// every modified-OTLP first-class sketch DataPoint; queried by
     /// the `ASAPQueryEngine` query path (ASAP-tier hit / ghost / unknown
diff --git a/data_plane/src/precompute_engine/operators/count_sketch_accumulator.rs b/data_plane/src/precompute_engine/operators/count_sketch_accumulator.rs
index 885c01143..9a353a33e 100644
--- a/data_plane/src/precompute_engine/operators/count_sketch_accumulator.rs
+++ b/data_plane/src/precompute_engine/operators/count_sketch_accumulator.rs
@@ -1,25 +1,9 @@
-//! Count Sketch accumulator — wraps `asap_sketchlib::CountSketch`.
+//! CountSketch accumulator backed by `asap_sketchlib::CountSketch`.
 //!
-//! This is the concrete accumulator reached from the modified-OTLP
-//! `Metric.data = CountSketch{…}` hot path (PR C-CountSketch). Its
-//! inner matrix is the same shape as `CountMinSketchAccumulator`'s
-//! but with signed counts and no per-row heap tracking.
-//!
-//! Minimum viable surface:
-//!   - `AggregateCore` impl for precompute-engine worker merge
-//!   - `SerializableToSink` impl for store write-out
-//!   - `from_sketchlib_proto_bytes(buf)` — decoder for the modified
-//!     OTLP `CountSketchDataPoint.sketch` bytes (prost-encoded
-//!     `asap_sketchlib::proto::sketchlib::CountSketchState`). Mirrors
-//!     the CountMin decoder in PR B.
-//!
-//! Per-key point queries go through `query_key`/`MultipleSubpopulationAggregate`,
-//! which delegate to `asap_sketchlib::CountSketch::estimate` (the real,
-//! hash-spec-compatible median-of-signed-rows estimator) — this used to
-//! be a hand-rolled, non-compatible hash (fixed alongside the raw-metric
-//! ingest dispatch bug, see `accumulator_factory.rs`). Top-k heap
-//! tracking (a distinct capability from a bare median estimate) is a
-//! separate concern — see `count_sketch_with_heap_accumulator.rs`.
+//! Supports worker merge, persistence serialization, and modified-OTLP proto
+//! decoding. Per-key queries delegate to sketchlib's median-of-signed-rows
+//! estimator so query and ingest use the same hash specification. Top-k
+//! requires the separate heap-bearing accumulator.
 
 use crate::storage_engines::types::{
     AggregateCore, AggregationType, KeyByLabelValues, MergeableAccumulator,
@@ -379,11 +363,7 @@ mod tests {
 
     #[test]
     fn test_query_key_uses_real_sketchlib_estimator() {
-        // Regression: query_key/MultipleSubpopulationAggregate used to go
-        // through a hand-rolled DefaultHasher-based estimator that did NOT
-        // use the sketchlib hash spec (its own doc admitted this). Fixed
-        // to delegate to `asap_sketchlib::CountSketch::estimate` directly
-        // -- prove `query_key` and `.inner.estimate(..)` now agree exactly.
+        // `query_key` must match sketchlib's estimator and hash specification.
         let mut cs = CountSketchAccumulator::new(4, 1000);
         let key = KeyByLabelValues::new_with_labels(vec!["web".to_string()]);
         cs.inner.update(&key.to_semicolon_str(), 10.0);
diff --git a/data_plane/src/precompute_engine/output_sink.rs b/data_plane/src/precompute_engine/output_sink.rs
index c2e4ffc4c..a26876eb2 100644
--- a/data_plane/src/precompute_engine/output_sink.rs
+++ b/data_plane/src/precompute_engine/output_sink.rs
@@ -52,20 +52,11 @@ fn consume_in_order<T>(items: Vec<T>, mut persist: impl FnMut(&T) -> bool) -> us
     failed
 }
 
-/// Phase 5 M2.3.6 — successor to the M2.3.4 `DualWriteSink`. Writes
-/// precomputes to `SketchStore` only; the legacy `SketchStore`
-/// agg_id-keyed write path is retired.
+/// Write completed precompute windows to the sid-keyed sketch store.
 ///
-/// Reads already prefer `SketchStore` (M2.3.5b's engine cut-over),
-/// so the legacy store no longer receives traffic from either side.
-/// Once the data-plane crate's `Store` trait and `stores/sketch_db/store/*`
-/// modules are deleted (subsequent M2.3.6 sub-PRs), `SketchStore`
-/// will be renamed to `SketchStore` and this type can collapse into
-/// the previously-existing `StoreOutputSink` shape.
-///
-/// Per-batch overhead: one streaming-config snapshot read + per-row
-/// agg-id lookup and sid hash. Completed accumulators are consumed in order,
-/// so a catch-up batch releases each pane as soon as it is serialized.
+/// Read one streaming-config snapshot per batch and resolve each policy through
+/// its fingerprint. Consume accumulators in order so catch-up batches release
+/// each pane as soon as it is serialized.
 pub struct SketchStoreSink {
     sketch_index: Arc<SketchStore>,
     hot_reload: HotReloadStreamingConfig,
diff --git a/data_plane/src/precompute_engine/worker.rs b/data_plane/src/precompute_engine/worker.rs
index fcc73edaf..b7a819ab7 100644
--- a/data_plane/src/precompute_engine/worker.rs
+++ b/data_plane/src/precompute_engine/worker.rs
@@ -929,15 +929,8 @@ impl Worker {
             Vec::with_capacity(samples.len());
 
         for (ts, val) in samples {
-            // Raw-mode path does not carry an `AggregationConfig` for
-            // the source aggregation (synthetic agg_id, no source
-            // config). After the PR-6 follow-up retired
-            // `PrecomputedOutput.aggregation_id`, the sink's fallback
-            // branch is gone — outputs carrying `PolicyFingerprint::UNSET`
-            // are dropped at the sink with a warn. Raw-mode is
-            // dev/test-only today (default `raw_mode_aggregation_id=0`),
-            // so this path effectively writes nothing in production;
-            // wiring raw mode to a real policy is a separate concern.
+            // Raw-mode outputs have no source policy. The sink drops
+            // `PolicyFingerprint::UNSET` outputs with a warning.
             let output =
                 PrecomputedOutput::new(ts as u64, ts as u64, None, PolicyFingerprint::UNSET);
             let _ = self.raw_mode_aggregation_id;
@@ -3281,12 +3274,6 @@ aggregations:
         );
     }
 
-    // M2.3.6g — `test_sketch_ingest_persists_and_query_returns_non_empty`
-    // deleted: it exercised the retired SketchStore + StoreOutputSink
-    // pair end-to-end. The SketchStoreSink path (M2.3.4+) is covered
-    // by its own dedicated tests in `output_sink::tests` and by
-    // `engine::e2e_feedback_loop_tests`.
-
     /// Pin the agent-emit-shape vs. backend-grouping-config invariant from
     /// hypothesis (A) of the sweep diagnostic. The agent emits one sketch
     /// per `(zone, rack, node, pod)` tuple; backend's `grouping_labels =
diff --git a/data_plane/src/query_engines/asap_query_engine/engine.rs b/data_plane/src/query_engines/asap_query_engine/engine.rs
index 516b518d7..e3ad29440 100644
--- a/data_plane/src/query_engines/asap_query_engine/engine.rs
+++ b/data_plane/src/query_engines/asap_query_engine/engine.rs
@@ -74,9 +74,6 @@ use std::collections::HashMap;
 
 /// Simple query engine for processing PromQL-like queries against precomputed data
 pub struct ASAPQueryEngine {
-    // Phase 5 M2.3.6g — `store: Arc<dyn Store>` field retired. The
-    // engine reads precomputes exclusively from `SketchStore` after
-    // M2.3.6f. Constructor signatures no longer take a `store` arg.
     #[allow(dead_code)]
     prometheus_scrape_interval: u64,
     /// Optional `ControlPlaneClient` used to notify the control plane
@@ -85,11 +82,11 @@ pub struct ASAPQueryEngine {
     /// misses fall through to the §5.2 fallback silently, matching
     /// pre-PR-G behavior. Set via `with_control_plane_client`.
     control_plane_client: Option<Arc<dyn crate::drivers::control_plane_client::ControlPlaneClient>>,
-    /// Phase 5 — ASAP-tier sketch index. When `Some`, the trait's
+    /// ASAP-tier sketch index. When `Some`, the trait's
     /// `execute` adapter classifies the query's metric/group-by against
     /// the index and short-circuits to `EngineError::CapabilityMiss` when
     /// no ASAP-tier identity covers the request — driving the
-    /// EngineRouter's archive failover (Phase 6). When `None`, the
+    /// EngineRouter's archive failover. When `None`, the
     /// engine behaves as it did before Phase 5 wire-in (every query
     /// goes through `handle_query`'s legacy path).
     sketch_index: Option<Arc<crate::storage_engines::sketch_db::index::SketchStore>>,
@@ -505,7 +502,7 @@ impl ASAPQueryEngine {
         self
     }
 
-    /// Phase 5 — attach the shared `SketchStore` so the `QueryEngine`
+    /// attach the shared `SketchStore` so the `QueryEngine`
     /// trait adapter's classify+failover logic is active. Without this
     /// call, the engine keeps the pre-Phase-5 behavior (route every
     /// query through `handle_query`).
@@ -808,7 +805,7 @@ impl ASAPQueryEngine {
 }
 
 // ---------------------------------------------------------------------------
-// Phase-5: `QueryEngine` trait impl.
+// `QueryEngine` trait impl.
 //
 // Adapter only — does NOT change `handle_query` or any other existing
 // surface. The trait's `execute(&str)` walks the same `handle_query` code
@@ -1134,15 +1131,8 @@ impl crate::query_engines::routing::query_engine_routing::QueryEngine for ASAPQu
             return Ok(warm_qr);
         }
 
-        // No-sketch-index fallback. The legacy
-        // `handle_query` path used to live here and provide the
-        // capability-miss notify side-effect through
-        // `find_compatible_aggregation_with_miss_notify`. With legacy
-        // retired (B7.5), this branch fires the notify directly so the
-        // control-plane feedback loop still closes — required by
-        // `capability_miss_http_e2e_tests::http_capability_miss_feedback_loop_closes_over_http`,
-        // which wires the engine WITHOUT `.with_sketch_index(...)` and
-        // therefore lands here on every miss.
+        // Without a sketch index, notify the control plane directly on a capability
+        // miss so the feedback loop also works for this configuration.
         if let Some(req) = Self::requirements_from_query_str(query) {
             crate::drivers::control_plane_client::spawn_capability_miss_notify(
                 &self.control_plane_client,
@@ -1430,23 +1420,8 @@ mod sketch_query_tests {
     // }
 }
 
-// ============================================================
-// Phase 1b tests: AuxStats pushdown on `query_precompute_for_statistic`
-// ============================================================
-//
-// Proves that when a statistic is covered by typed aux columns, the
-// query path returns the aux value without ever calling the
-// accumulator's `query_statistic` method. When the statistic is NOT
-// covered, the code falls through to `query_statistic`.
-//
-// B7.5 retirement note: the in-process `capability_miss_feedback_loop_closes`
-// + `capability_miss_idempotent_on_repeat` tests that previously lived
-// adjacent to this module were retired alongside their probe surface
-// (`find_compatible_aggregation_with_miss_notify`). The
-// capability-miss feedback loop is now exercised end-to-end via
-// `crate::tests::capability_miss_http_e2e_tests::http_capability_miss_feedback_loop_closes_over_http`,
-// which round-trips a real HTTP capability-miss through the modern
-// `execute()` path's `spawn_capability_miss_notify` calls.
+// Typed auxiliary statistics must answer covered queries without invoking
+// the accumulator query method; uncovered statistics use that method.
 #[cfg(test)]
 mod aux_pushdown_tests {
     use super::*;
@@ -1649,12 +1624,12 @@ mod aux_pushdown_tests {
 // `compatible_agg_types`, `rate(<metric>[<range>])` against a CMS-only
 // agg config now matches.
 // ===========================================================================
-/// Phase 5 — `QueryEngine::execute` ASAP-tier classification tests.
+/// `QueryEngine::execute` ASAP-tier classification tests.
 /// Pre-Phase-5 the trait adapter unconditionally delegated to
 /// `handle_query`. After Phase 5 wire-in, when a `SketchStore` is
 /// attached, the adapter classifies first and surfaces
 /// `EngineError::CapabilityMiss(SketchStore, ...)` on Ghost / Unknown
-/// / no-instance outcomes so the EngineRouter (Phase 6) can fall
+/// / no-instance outcomes so the EngineRouter can fall
 /// through to the archive engine.
 #[cfg(test)]
 mod asap_tier_classify_tests {
@@ -1752,19 +1727,8 @@ mod asap_tier_classify_tests {
 
     #[tokio::test]
     async fn execute_bare_selector_falls_over_to_archive() {
-        // L1 adoption (design-target-architecture.md Part B), accepted
-        // behavior change: `lower_promql` doesn't implicitly wrap a bare
-        // selector in `Aggregate { Sum }` the way the retired local
-        // parser did (see `control_plane`'s
-        // `asap_tier_analysis::bare_selector_is_no_longer_asap_tier_answerable`),
-        // so this rejects with `NoCallNodeFound` again -- a DIFFERENT
-        // reason than the (now-stale) comment this replaced expected, but
-        // the routing OUTCOME is unchanged either way: capability-miss,
-        // fails over to archive. The `SketchStore` here holding only a
-        // DDSketch (quantile) policy is now moot for this specific query
-        // (rejected before ever reaching policy lookup), kept for the
-        // fixture's own sake / in case the bare-selector shape changes
-        // again.
+        // A bare selector has no aggregate root and fails over to archive before
+        // policy lookup, regardless of the registered DDSketch policy.
         let idx = Arc::new(SketchStore::new());
         idx.register(dd_meta(2, "http_latency_ms", &["zone"]));
         idx.append_sample(
@@ -2668,13 +2632,8 @@ mod asap_tier_classify_tests {
         );
     }
 
-    /// `sum by (zone) (rate(http_requests_total[5m]))` end-to-end.
-    /// The canonical Planner input contains an inner `AggIntent::Rate`, so
-    /// the post-ASAP resolver returns `RateShape` before execution, with no
-    /// legacy reducer left to fall through to. This
-    /// test used to pin the `evaluate_exact_agg_rate` composed-candidate
-    /// dispatch; now it pins the accepted replacement outcome:
-    /// capability-miss.
+    /// An inner Rate intent excludes this composed query from summary execution;
+    /// the engine must report a capability miss.
     #[tokio::test]
     async fn execute_sum_by_zone_rate_capability_misses_no_legacy_fallback() {
         use crate::precompute_engine::operators::sum_accumulator::SumAccumulator;
@@ -2740,17 +2699,8 @@ mod asap_tier_classify_tests {
         );
     }
 
-    /// `sketch_reducer.rs` retirement: `topk(K, sum by (zone)
-    /// (rate(...)))` -- the multinode demo's flagship query -- contains
-    /// an inner `rate(...)` call, so every candidate carries
-    /// `outer_fn=OuterFn::Rate` and `RateShape` self-excludes the whole
-    /// query from `SummaryExecutor` before ever binding. The engine's
-    /// `try_topk_over_rate_fallback` (the only thing that used to answer
-    /// this shape, via the ExactAgg(Sum) sids + an in-engine top-k slice)
-    /// is retired along with `sketch_reducer.rs` -- there is no fallback
-    /// left. Pins the accepted replacement outcome: capability-miss, at
-    /// both K ≥ n and K < n (this shape's fallback used to slice
-    /// differently in each case; now both just fail over to archive).
+    /// TopK over grouped rate fails over to archive for both K ≥ n and K < n.
+    /// The inner Rate intent excludes the entire query from summary execution.
     #[tokio::test]
     async fn execute_topk_over_sum_by_zone_rate_capability_misses_no_legacy_fallback() {
         use crate::precompute_engine::operators::sum_accumulator::SumAccumulator;
@@ -2901,15 +2851,8 @@ mod asap_tier_classify_tests {
 
     #[tokio::test]
     async fn rate_over_cms_frequency_capability_misses_no_legacy_fallback() {
-        // `sketch_reducer.rs` retirement: `rate(cms_metric[5m])` lowers to
-        // ExactAgg(Sum)+Rate, but the sid is FrequencyEstimate -- no
-        // ExactAgg sid matches, and `rate(...)` is also `RateShape`-excluded
-        // from `SummaryExecutor` regardless. The engine's frequency-rate
-        // fallback (`try_rate_over_frequency_fallback`) that used to answer
-        // this shape (Σ per-window frequency total ÷ coverage-clamped
-        // range) is retired along with `sketch_reducer.rs` -- even with a
-        // real registered freq sid, this now capability-misses, same as
-        // the no-sid case below.
+        // Rate is excluded from summary execution even with a registered frequency
+        // sid, so this request must capability-miss.
         let now = now_ms_for_test();
         let idx = Arc::new(SketchStore::new());
         register_cms_freq_sid(&idx, 7000, "cms_metric", &[], "", 600, now);
@@ -3063,24 +3006,9 @@ mod outer_agg_integration_tests {
         }
     }
 
-    /// `sketch_reducer.rs` retirement: `max by (zone)
-    /// (quantile_over_time(0.99, http_latency_ms[5m]))` used to reach the
-    /// legacy reducer (which answers the INNER `QuantileApprox` candidate
-    /// only, ignoring the outer `max`, then applies `apply_outer_agg_fold`
-    /// -- identity here, since each zone already has one row). There's no
-    /// equivalent in `SummaryExecutor`'s single-tree-bind model: the outer
-    /// `AggIntent::Max` commits unconditionally to its own `MinMax`
-    /// accumulator (`asap_aware_mapping::boundary::implementation_for_with`), which
-    /// requires a real, independently-registered `MinMax` sid that never
-    /// exists for this shape -- so the whole tree fails to realize even
-    /// though the inner quantile would answer fine standalone. This is a
-    /// genuine upstream L4 gap (filed as
-    /// https://github.com/ProjectASAP/ASAPController/issues/171 --
-    /// composing an outer exact fold over an already-realized inner
-    /// summary has no representation today), not something this
-    /// deployment routes around locally -- same category as the
-    /// `TopK { accuracy: Exact }` gap (ASAPController#151). Accepted for
-    /// now: capability-miss, failing over to archive.
+    /// An outer Max requires its own MinMax state in this summary plan.
+    /// An inner quantile sid alone cannot satisfy the whole tree; return a
+    /// capability miss so archive execution can answer the composed query.
     #[tokio::test]
     async fn execute_max_by_zone_over_quantile_over_time_capability_misses_pending_asapcontroller_171(
     ) {
diff --git a/data_plane/src/query_engines/asap_query_engine/live_serve.rs b/data_plane/src/query_engines/asap_query_engine/live_serve.rs
index ccfb7333a..95a36b7de 100644
--- a/data_plane/src/query_engines/asap_query_engine/live_serve.rs
+++ b/data_plane/src/query_engines/asap_query_engine/live_serve.rs
@@ -1,22 +1,5 @@
-//! The `SummaryExecutor` serving path — the sole way `data_plane` answers
-//! a query from the sketch tier. `shadow_compare.rs` (diagnostic-only
-//! comparison against the legacy reducer, used to validate this path
-//! before it went live) and `sketch_reducer.rs` (the legacy reducer
-//! itself) are both retired: neither was "ground truth" any more than
-//! this path is, and once this path was the default-on live serving
-//! path (design-target-architecture.md Part A), keeping a second,
-//! independently-planned answering mechanism around only meant two
-//! things could silently disagree with each other, not that either was
-//! more trustworthy. See
-//! `data_plane/docs/l4node-plan-executor-design.md` and the Phase 2
-//! plan's "What 'safe to serve' means, precisely" section for the exact
-//! gate this applies.
-//!
-//! `try_serve_from_summary_executor` returning `None` (flag off, a
-//! self-excluded shape like `rate()`/`irate()`/`topk(K, sum
-//! by(...)(rate(...)))`/keyed-CMS point-estimate, or no matching
-//! registered sid) means the query fails over to archive — there is no
-//! other sketch-tier path left to try.
+//! Execute sketch-tier queries through `SummaryExecutor`. Returning `None`
+//! means this path cannot answer and the caller must fail over to archive.
 
 use std::collections::BTreeMap;
 
@@ -86,18 +69,9 @@ fn summary_executor_live_value(value: Option<&str>) -> bool {
     })
 }
 
-/// Try to serve `query` entirely from `SummaryExecutor`. Returns `None`
-/// whenever the query can't be served this way (flag off, a
-/// self-excluded shape, no matching registered sid, or lowering/execution
-/// failed) — the caller fails over to archive. `Some(...)` means this
-/// answered the query.
-///
-/// This used to carry a third fallback reason: a grouping-ambiguity gate
-/// that declined any empty-`by` shape producing >1 group
-/// (ASAPController#163). That gate is gone — `Reduction`
-/// (ASAPController#165) lets `summary_executor.rs` resolve both halves of
-/// the ambiguity correctly on its own, so there is no longer a shape to
-/// decline. See `PostAsapReadoutOutcome`'s doc for the full reasoning.
+/// Try to serve `query` through `SummaryExecutor`. Return `None` if disabled,
+/// excluded by shape, missing a matching sid, or unable to lower or execute.
+/// The caller then falls back to archive.
 pub fn try_serve_from_summary_executor(
     index: &SketchStore,
     query: &str,
diff --git a/data_plane/src/query_engines/asap_query_engine/mod.rs b/data_plane/src/query_engines/asap_query_engine/mod.rs
index 1fd50b3bf..0bef6e4b9 100644
--- a/data_plane/src/query_engines/asap_query_engine/mod.rs
+++ b/data_plane/src/query_engines/asap_query_engine/mod.rs
@@ -1,13 +1,5 @@
-//! Warm-tier sketch query engine.
-//!
-//! `ASAPQueryEngine` is the PromQL query path that answers from the
-//! in-memory sketch DB
-//! ([`crate::storage_engines::sketch_db::SketchStore`]) and its
-//! per-`agg_id` precomputed accumulators. It returns ε/δ-bounded
-//! approximate answers for sketch-resident queries and `None` on
-//! a capability miss (router falls through, which after Step-1 of
-//! the JSONL deprecation means the archive tier or a hard 404 —
-//! the JSONL leg has been deleted).
+//! Warm-tier query engine over sid-keyed sketch storage. Capability misses
+//! allow the router to try archive execution.
 
 pub(crate) mod catalog_resolver;
 pub mod engine;
@@ -20,8 +12,6 @@ pub mod post_asap_readout;
 pub mod summary_exec;
 pub mod summary_executor;
 
-// Phase-5 reorg: ASAP-tier reducer moved to `sketch_db::query`. The
-// engine still consumes it via that canonical path.
 pub use crate::storage_engines::sketch_db::query as asap_tier;
 
 #[cfg(test)]
diff --git a/data_plane/src/query_engines/asap_query_engine/post_asap_readout.rs b/data_plane/src/query_engines/asap_query_engine/post_asap_readout.rs
index b91738c34..8632aba0a 100644
--- a/data_plane/src/query_engines/asap_query_engine/post_asap_readout.rs
+++ b/data_plane/src/query_engines/asap_query_engine/post_asap_readout.rs
@@ -23,39 +23,11 @@ use crate::storage_engines::sketch_db::index::SketchStore;
 /// where `samples` is `(window_end_unix_ms, value)`.
 pub type SeriesRows = Vec<(BTreeMap<String, String>, Vec<(i64, f64)>)>;
 
-/// The result of lowering + executing a query through
-/// `SummaryExecutor`, converted into the same shape `ASAPTierResult`
-/// uses, regardless of whether the answer came from the sketch
-/// (`ExecOutcome::Value`) or `ExactAgg` (`ExecOutcome::State`) side —
-/// callers that only care about "did this answer the query, and is it
-/// safe to trust" don't need to know which.
-/// NOTE — this used to carry an `ambiguous_merge_risk` flag, and
-/// `live_serve.rs` used it to DECLINE to serve an ambiguous shape.
-/// That gate is now removed, because the ambiguity it guarded against no
-/// longer exists.
+/// Summary execution result projected into `ASAPTierResult`, for both sketch
+/// values and exact accumulator states.
 ///
-/// It existed because an empty `by: Vec<ColumnId>` was indistinguishable
-/// between "no grouping concept applies" (the group split is correct) and
-/// "an aggregation operator asked to reduce everything" (the groups
-/// should have been merged) — exactly
-/// [ASAPController#163](https://github.com/ProjectASAP/ASAPController/issues/163).
-/// Unable to tell which, the safe move was to fall back to the legacy
-/// path whenever an empty `by` produced >1 group.
-///
-/// ASAPController#165 removed that ambiguity at the source by making the
-/// reduction kind explicit (`Reduction::{PerEntity, Reduce(GroupKeys)}`),
-/// and `summary_executor.rs::resolve_group_key` now acts on it directly.
-/// Both branches are resolved correctly BEFORE reaching here:
-///
-/// * `PerEntity` — the multi-group split is definitionally right (one row
-///   per entity, never merged), so it was never a "risk" to begin with.
-/// * `Reduce([])` — every candidate shares one group key, so the outcome
-///   has exactly ONE group and the old `values.len() > 1` trigger cannot
-///   fire at all.
-///
-/// The flag would therefore be unconditionally `false` today; keeping it
-/// would mean keeping a heuristic that can only ever misfire (declining
-/// correct `PerEntity` answers) now that the real signal is available.
+/// Grouping is resolved before this projection: `PerEntity` preserves each
+/// entity, while `Reduce([])` merges every candidate into a single group.
 pub struct PostAsapReadoutOutcome {
     pub series: SeriesRows,
     pub coverage: Option<(u64, u64)>,
@@ -1088,19 +1060,8 @@ mod tests {
 
     #[test]
     fn global_merge_shape_now_merges_instead_of_being_declined() {
-        // The exact ASAPController#163 shape: two HLL sids, no explicit
-        // by(), an aggregation-operator query. This test previously
-        // asserted `ambiguous_merge_risk == true` and TWO unmerged series
-        // -- i.e. it pinned the old workaround, where an empty `by` left
-        // `find_candidates` unable to tell "reduce everything" apart from
-        // "no grouping concept," so `live_serve` declined to serve the
-        // shape at all.
-        //
-        // With `Reduction` (ASAPController#165) that ambiguity is gone:
-        // `count(...)` is a genuine aggregation operator, so it lowers to
-        // `Reduce([])` and `resolve_group_key` gives every candidate the
-        // SAME group key -- the two sids MERGE into one answer, which is
-        // what the query actually asked for. No gate, no fallback.
+        // An ungrouped count reduces two HLL sids into one answer. `Reduce([])`
+        // assigns both candidates the same group key so their states merge.
         let idx = SketchStore::new();
         register_hll(&idx, 1, "svc-a", &["a", "b", "c"]);
         register_hll(&idx, 2, "svc-b", &["d", "e", "f"]);
diff --git a/data_plane/src/query_engines/asap_query_engine/summary_exec.rs b/data_plane/src/query_engines/asap_query_engine/summary_exec.rs
index 672363d12..9a9a46d33 100644
--- a/data_plane/src/query_engines/asap_query_engine/summary_exec.rs
+++ b/data_plane/src/query_engines/asap_query_engine/summary_exec.rs
@@ -1,31 +1,9 @@
-//! Serving-time execution model for the post-ASAP IR — the counterpart to
-//! `asap_aware_mapping::bind`'s planning-time `QueryExpr -> SummaryNode`.
+//! Backend execution model for ASAPPlanner's post-ASAP IR.
+//! Adapted from ASAPPlanner's summary executor.
 //!
-//! **Vendored, not upstream.** This module used to be
-//! `asap_sketch::exec` (`crates/sketch/src/exec.rs`) in what's now
-//! ASAPPlanner. It was deleted there in
-//! [ASAPPlanner#190](https://github.com/ProjectASAP/ASAPPlanner/issues/190)
-//! (folded into #197) on the grounds that "the only implementors anywhere
-//! in this workspace are `MockExecutor`/`ReductionSpyExecutor`, both
-//! `#[cfg(test)]`-only... no bin, example, or downstream crate in this
-//! repo constructs or runs a real executor" — true from ASAPPlanner's own
-//! repo, but this module's very own [`SummaryExecutor`] trait *is*
-//! implemented for real by
-//! [`summary_executor::AsapSummaryExecutor`](crate::query_engines::asap_query_engine::summary_executor),
-//! just in this (different) repo, which upstream's search couldn't see.
-//! ASAPPlanner's own README now explicitly scopes itself away from
-//! execution ("not doing any physical query planning") and lists
-//! connecting its output to a real backend as an open question (#1) — see
-//! `control_plane/docs/design-asapplanner-pin-migration.md` §3.2 for the
-//! full account. Ported here verbatim in spirit (same trait shape, same
-//! tree-walking algorithm, same tests) with one adaptation: ASAPPlanner
-//! split the old flat `SummaryKind`/`SummaryParams` pair into a
-//! per-family `SummaryFamilyType` tagged union
-//! (ASAPPlanner#218) before `exec.rs` was deleted, so `SummaryAgg`'s
-//! `kind`/`params` fields collapsed into one `family: SummaryFamilyType`
-//! field on the real, current `SummaryExpr::SummaryAgg` — this module's
-//! `find_candidates`/`ExecOutcome::State` follow that shape rather than
-//! the pre-split one the last upstream copy of `exec.rs` had.
+//! [`SummaryExecutor`] supplies storage and readout operations; the tree walker
+//! executes the selected summary plan. The concrete backend implementation is
+//! `AsapSummaryExecutor` in the sibling `summary_executor` module.
 
 use std::collections::BTreeMap;
 
diff --git a/data_plane/src/query_engines/asap_query_engine/summary_executor.rs b/data_plane/src/query_engines/asap_query_engine/summary_executor.rs
index 0b3583e42..e03e702d2 100644
--- a/data_plane/src/query_engines/asap_query_engine/summary_executor.rs
+++ b/data_plane/src/query_engines/asap_query_engine/summary_executor.rs
@@ -1244,42 +1244,14 @@ fn project_group_key(
         .collect()
 }
 
-/// Group-key construction for `find_candidates`, shared by both the
-/// `Sketch` and `ExactAgg` branches -- driven directly by the post-ASAP IR's
-/// `Reduction` (ASAPController#163/#164/#165), not inferred from whether
-/// `by` happens to be empty.
+/// Construct group keys from the explicit post-ASAP reduction, for both
+/// sketches and exact accumulators.
 ///
-/// This replaces the old family-specific split (`sketch_group_key` vs.
-/// `project_group_key` used bare): before `Reduction` existed on
-/// `SummaryAgg`, an empty `by: Vec<ColumnId>` was genuinely ambiguous --
-/// it could mean either "no explicit grouping was even resolvable" (a
-/// bare per-series range function like `quantile_over_time(0.99,
-/// http_latency_ms[10s])`, where the post-ASAP plan has no reference to any
-/// label column at all) or "a real cross-series reduction with zero
-/// grouping columns" (`count(hll_metric)`, `sum(...)`-shaped). Those two
-/// cases need OPPOSITE group-key behavior and the old `by: &[ColumnId]`
-/// signature could not tell them apart -- `sketch_group_key`'s heuristic
-/// (treat empty `by` as "keep every series distinct" for the Sketch
-/// family only) fixed the first case but could not fix the second, since
-/// by the time `find_candidates` saw a bare `[]`, the distinction was
-/// already lost.
+/// * `PerEntity` preserves the full sid label map and keeps entities distinct.
+/// * `Reduce(by)` projects onto the requested keys. Empty keys produce `{}`
+///   for every candidate, merging all candidates into one group.
 ///
-/// `Reduction` restores it directly:
-/// - `PerEntity`: no grouping concept at all -- use the sid's own FULL
-///   label map, matching the legacy `sketch_reducer.rs::evaluate_core`
-///   path's behavior exactly (it passes `series_label_values` straight
-///   through, unconditionally), so distinct series always stay distinct
-///   rows. Applies uniformly to both families now (previously
-///   `ExactAgg`'s `project_group_key` had no equivalent, since `Sum`/
-///   `Increase`-shaped exact aggregations only ever reach an unqualified
-///   PromQL aggregation operator, which is never `PerEntity`).
-/// - `Reduce(by)`: a genuine reduction. Project onto `by_names` as
-///   before -- when `by_names` is empty this naturally returns the SAME
-///   `{}` key for every matching candidate, correctly merging them into
-///   one group (the fix for the `count(hll_metric)`-style case the old
-///   `by: &[ColumnId]` signature couldn't resolve). When non-empty, an
-///   explicit grouping was resolvable from the query (e.g. `quantile by
-///   (zone) (...)`), so project onto it as requested.
+/// An empty column list alone cannot distinguish these two semantics.
 fn resolve_group_key(
     reduction: &Reduction,
     by_names: &[String],
diff --git a/data_plane/src/query_engines/routing/backend_storage_routing.rs b/data_plane/src/query_engines/routing/backend_storage_routing.rs
index 100c25216..04498d147 100644
--- a/data_plane/src/query_engines/routing/backend_storage_routing.rs
+++ b/data_plane/src/query_engines/routing/backend_storage_routing.rs
@@ -1,97 +1,12 @@
-//! Per-metric storage-backend routing table consulted by the HTTP query
-//! handler at request time.
+//! Per-metric routing with optional query-shape filters.
 //!
-//! ## Why this exists
+//! YAML accepts single targets under `metrics` and target lists under `routes`.
+//! For metrics listed in both, `routes` wins. Missing metrics use the configured
+//! default, which defaults to `SketchStore`. JSON configuration is also accepted
+//! through [`BackendStorageRouting::from_json_payload`].
 //!
-//! Phase-5 (PR #87) wired the `EngineRouter` into the HTTP query handler,
-//! but the per-metric `StorageBackend` axis was sourced from
-//! `StreamingConfig::storage_backend()` — a single field that applies to
-//! the entire streaming config. In production deploys (the
-//! `precompute_engine` binary loading `backend-streaming.yaml`) the
-//! field decodes via `Self::new(...)` which always defaults to
-//! `SketchStore`, so the handler always took the
-//! `ASAPQueryEngine`-direct-dispatch branch and the `EngineRouter` was
-//! effectively bypassed for every query — the `data_source:
-//! thanos_query` info-line never landed on cold-archive responses
-//! even when the chunks were on disk in MinIO.
-//!
-//! The fix lives **outside** the streaming pipeline: the streaming
-//! engine on the OTLP-ingest path never sees Gorilla data (the
-//! `gorillas3processor` writes chunks directly to S3), so there is
-//! nothing for `StreamingConfig::from_yaml_data` to learn. What we
-//! actually need is a tiny standalone routing table — one entry per
-//! metric whose storage backend differs from the default — that the
-//! HTTP handler consults to pick the right engine for each query.
-//!
-//! ## v7: dual-routing per metric
-//!
-//! v6.1 surfaced an architectural gap: routing one metric to one engine
-//! forces an exclusive trade-off between criterion ④ (ASAP-tier
-//! accuracy) and criterion ⑤ (cold-fallback). Every quantile/sum-by
-//! query on `http_requests_total` had to go to either the ASAP tier
-//! (so the accuracy reducer could compute relative error) or the
-//! archive (so the `data_source: thanos_query` info-line landed on
-//! the cold-fallback probe). v7 closes this by letting one metric have
-//! multiple targets, each with an optional query-shape filter; the
-//! HTTP handler inspects the parsed PromQL and picks the matching
-//! target. Predictable / planned queries (quantile, sum_over_time)
-//! land on the ASAP tier; ad-hoc / post-hoc queries
-//! (count, topk, rate-post-hoc) route to the cold archive.
-//!
-//! ## Schema
-//!
-//! Two compatible shapes are accepted. The single-target form is
-//! preserved verbatim from v6.1 so existing deploys keep working
-//! unchanged:
-//!
-//! ```yaml
-//! # v6.1 form (single-target):
-//! default: sketch_store
-//! metrics:
-//!   audit_events: gorilla_object_store
-//! ```
-//!
-//! ```yaml
-//! # v7 form (multi-target with query-shape selection):
-//! default: sketch_store
-//! routes:
-//!   - metric: http_requests_total
-//!     targets:
-//!       - backend: sketch_store
-//!         # default — predictable / planned queries land here
-//!       - backend: gorilla_object_store
-//!         applies_to_query_shape: [count, topk, rate_post_hoc]
-//!   - metric: http_freshness_probe_warm
-//!     targets:
-//!       - backend: sketch_store
-//!   - metric: http_freshness_probe_archive
-//!     targets:
-//!       - backend: gorilla_object_store
-//! ```
-//!
-//! The two shapes can be mixed in the same YAML — metrics under
-//! `metrics:` keep the old single-target semantics; metrics under
-//! `routes:` use the new list-of-targets semantics. A metric listed
-//! in BOTH wins from `routes:` (multi-target overrides single-target).
-//!
-//! Valid `StorageBackend` values mirror the snake-cased serde tags on
-//! `crate::storage_engines::types::StorageBackend`: `sketch_store`,
-//! `gorilla_object_store`, `double_write`, `prometheus_remote`. (Step-1
-//! of the JSONL deprecation refactor removed the `cold_jsonl_fallback` tag.)
-//!
-//! Loaded once at backend startup (CLI flag `--backend-storage-routing`
-//! on `precompute_engine`) and stored in `AppState`. Lookup is
-//! O(metric-name-hash); a query that doesn't match any entry falls back
-//! to `default` (which itself falls back to `SketchStore`).
-//!
-//! ## Out of scope
-//!
-//! * Hot reload — the control plane's plan-push is the long-term answer
-//!   for per-metric routing; this YAML layer is the bridge that
-//!   unblocks issue #46 criteria ④/⑤/⑥ until the plan-push lands.
-//! * Per-`(metric, statistic, accuracy)` granularity — `StorageBackend`
-//!   already encodes the `DoubleWrite` axis the cost-aware dispatcher
-//!   uses to pick warm-vs-archive per query.
+//! The HTTP layer snapshots the hot-reload routing handle per request so each
+//! query sees one consistent table during concurrent configuration updates.
 
 use std::collections::HashMap;
 use std::path::Path;
@@ -109,21 +24,8 @@ use crate::storage_engines::types::{
 // Query-shape taxonomy
 // ---------------------------------------------------------------------------
 
-/// A coarse-grained classification of an incoming PromQL query. The
-/// HTTP handler extracts this from the parsed AST and consults the
-/// routing table's `applies_to_query_shape` filters to pick a target.
-///
-/// The shapes intentionally mirror the v7 spec's
-/// `[count, topk, rate_post_hoc]` enumeration — each is a PromQL
-/// shape the cold-archive engine answers natively, and which the
-/// ASAP-tier sketch path either can't serve at all (count over an
-/// approximate sketch is misleading) or serves with worse precision
-/// than the archive (rate post-hoc).
-///
-/// Phase α (control-plane-emitted routing tables) adds `HistogramQuantile`
-/// / `Delta` / `Deriv` / `Absent` — these are PromQL shapes no ASAP-tier
-/// sketch can serve and the control plane's emitter reliably routes them
-/// to the archive.
+/// Coarse PromQL shape used to match a routing target's
+/// `applies_to_query_shape` filter.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryOperatorShape {
@@ -533,7 +435,7 @@ impl BackendStorageRouting {
         Ok(routing)
     }
 
-    /// Phase α (MVP): parse a control-plane-emitted JSON document into a
+    /// parse a control-plane-emitted JSON document into a
     /// fresh routing table. The schema mirrors
     /// `control_plane/src/emit/stage_config.rs::emit_backend_storage_routing`:
     ///
@@ -895,7 +797,7 @@ pub fn routing_table_hash(table: &BackendStorageRouting) -> String {
 }
 
 // ---------------------------------------------------------------------------
-// Phase α: HotReloadBackendStorageRouting — atomic-swap wrapper
+// HotReloadBackendStorageRouting — atomic-swap wrapper
 // ---------------------------------------------------------------------------
 
 /// Per-tenant atomic-swap wrapper around `BackendStorageRouting`,
@@ -1397,7 +1299,7 @@ routes:
         assert_eq!(classify_query_shape(&e), QueryOperatorShape::Other);
     }
 
-    // ── Phase α: from_json_payload + replace + hot-reload tests ────────
+    // ── from_json_payload + replace + hot-reload tests ────────
 
     fn fixture_json() -> serde_json::Value {
         serde_json::json!({
@@ -1565,7 +1467,7 @@ routes:
         assert_eq!(r.lookup("audit_events"), StorageBackend::GorillaObjectStore);
     }
 
-    /// Phase ε.2: the control plane's Mode 3
+    /// the control plane's Mode 3
     /// (`RawAtEdgePrometheusArchive`) emits `engine: prometheus_remote`
     /// in the routing JSON for metrics whose raw data is shipped to
     /// Prometheus's native OTLP receiver. The backend's parser must
diff --git a/data_plane/src/query_engines/routing/capability_matching.rs b/data_plane/src/query_engines/routing/capability_matching.rs
index 716d55d94..607d1977b 100644
--- a/data_plane/src/query_engines/routing/capability_matching.rs
+++ b/data_plane/src/query_engines/routing/capability_matching.rs
@@ -45,7 +45,7 @@ pub use planner_types::types::AccuracyTarget;
 ///   collapses the old per-`metric_storage` sequences into one shared
 ///   ASAP-first-then-archive contract.
 /// * `PrometheusRemote` keeps its own single-backend sequence
-///   `[PrometheusRemote]` (Phase ε.2): the metric's raw samples never
+///   `[PrometheusRemote]`: the metric's raw samples never
 ///   landed in ASAP-managed storage, so there is no ASAP-tier sketch to
 ///   fall back on and the accuracy hint does not apply. A missing
 ///   engine surfaces as a `NoEngineRegistered` 503 from the HTTP
@@ -82,7 +82,7 @@ mod tests {
     use super::*;
 
     // -----------------------------------------------------------------------
-    // Phase-5: storage-backend routing
+    // storage-backend routing
     //
     // The Phase-5 `EngineRouter` (see `query_engine_routing.rs`) consults
     // `compatible_storage_backends(stat, accuracy, metric_storage)` to pick
diff --git a/data_plane/src/query_engines/routing/query_engine_routing.rs b/data_plane/src/query_engines/routing/query_engine_routing.rs
index dd5a50473..6ae23ded5 100644
--- a/data_plane/src/query_engines/routing/query_engine_routing.rs
+++ b/data_plane/src/query_engines/routing/query_engine_routing.rs
@@ -67,21 +67,13 @@ pub struct EngineCapabilities {
     /// `compatible_storage_backends(...)` for an ordered list of
     /// `StorageBackend`s and looks each up via this field.
     pub storage_backend: StorageBackend,
-    /// Memory budget (in bytes) the engine is willing to buffer for
-    /// streaming-aggregate queries. Used by the cost-aware dispatcher
-    /// when several engines are eligible for the same query (today it's
-    /// purely informational; the Phase-6 cost model will consume it).
+    /// Informational memory budget for streaming aggregation. The router does
+    /// not currently use it to rank eligible engines.
     pub supports_streams_above_bytes: usize,
 }
 
-/// The Phase-5 dispatch boundary. Concrete engines implement this trait so
-/// the [`EngineRouter`] can hold them as `Arc<dyn QueryEngine>` rather
-/// than case-on-concrete.
-///
-/// `execute` takes the query as `&str` (matching `GorillaQueryEngine`'s
-/// existing surface) and returns a wire-ready [`QueryResult`]. Internal
-/// engine signatures (e.g. `ASAPQueryEngine::handle_query`'s `Option<...>`)
-/// are translated by the impl so callers can program against the trait.
+/// Dispatch interface for engines held as `Arc<dyn QueryEngine>`.
+/// Queries arrive as strings and results use the shared `QueryResult` shape.
 #[async_trait]
 pub trait QueryEngine: Send + Sync {
     /// Answer `query` against this engine's storage tier.
@@ -753,7 +745,7 @@ mod tests {
         );
     }
 
-    /// Phase ε.2: a routing-table entry with
+    /// a routing-table entry with
     /// `metric_storage = StorageBackend::PrometheusRemote` must
     /// dispatch to the engine registered under `prometheus_remote`.
     /// Mirrors the gorilla-archive single-backend dispatch test;
@@ -785,7 +777,7 @@ mod tests {
         );
     }
 
-    /// Phase ε.2: when `ASAP_PROMETHEUS_QUERY_URL` is unset the
+    /// when `ASAP_PROMETHEUS_QUERY_URL` is unset the
     /// `prometheus_remote` engine is not registered, and a routing
     /// entry that targets it must surface a clear
     /// `NoEngineRegistered` error rather than silently falling
diff --git a/data_plane/src/query_engines/thanos_query_engine/forward.rs b/data_plane/src/query_engines/thanos_query_engine/forward.rs
index d84661714..ad67d49e1 100644
--- a/data_plane/src/query_engines/thanos_query_engine/forward.rs
+++ b/data_plane/src/query_engines/thanos_query_engine/forward.rs
@@ -415,7 +415,7 @@ impl QueryEngine for ThanosQueryEngine {
             // Forwarder doesn't materialise samples locally;
             // upstream thanos-query owns the memory budget. We
             // surface a generous ceiling so the cost-aware
-            // dispatcher (Phase-6) prefers thanos for large
+            // dispatcher prefers thanos for large
             // streams once it lands.
             supports_streams_above_bytes: usize::MAX,
         }
diff --git a/data_plane/src/storage_engines/sketch_db/accuracy.rs b/data_plane/src/storage_engines/sketch_db/accuracy.rs
index 30019bedf..5c0acd008 100644
--- a/data_plane/src/storage_engines/sketch_db/accuracy.rs
+++ b/data_plane/src/storage_engines/sketch_db/accuracy.rs
@@ -217,10 +217,7 @@ fn shared_profile(params: PlannerParams) -> AccuracyProfile {
 // says it's OK for them to drift — this module is the single
 // authority on *accuracy*, not on *construction*.
 
-/// Reads canonical `d` (depth = rows) / `w` (width = cols) keys.
-/// The legacy `row_num` / `col_num` form was retired in lock-step
-/// with the asapcollector migration to canonical keys — see
-/// `accumulator_factory::cms_params` for the matching change.
+/// Read canonical depth `d` and width `w` parameters.
 fn cms_params(config: &AggregationConfig) -> (u64, u64) {
     let rows = config
         .parameters
@@ -724,10 +721,6 @@ mod tests {
         assert_eq!(p.epsilon, 0.01);
     }
 
-    // (The historical `set_aggregators_are_exact` test verified the
-    // accuracy bound for `SetAggregator` / `DeltaSetAggregator`;
-    // retired alongside the family itself.)
-
     #[test]
     fn legacy_wrapper_types_fall_back_to_exact() {
         // `SingleSubpopulation` / `MultipleSubpopulation` are
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/mod.rs b/data_plane/src/storage_engines/sketch_db/backfill/mod.rs
index d8d15b012..a61f0099e 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/mod.rs
@@ -1,52 +1,9 @@
-//! `BackfillJob` lifecycle types + in-memory `BackfillRegistry`.
+//! Backfill job lifecycle, registry, readers, and rebuild workers.
 //!
-//! Implements §10 (refreshable view maintenance / backfill path) of the
-//! future storage scope ([`future-storage-and-compression.md`](../../../../../docs/design_docs/future-storage-and-compression.md)).
-//!
-//! ## Why this exists
-//!
-//! The sketch tier's §8 incremental maintenance can't fill data from
-//! BEFORE an `agg_id` was created. When a reconfigure introduces a new
-//! agg_id — say the operator widens a CMS from 256 to 2048, or swaps
-//! in KLL200 on top of a metric that previously had only CMS — the new
-//! agg has zero history. Queries spanning the reconfigure boundary
-//! either see a data cliff (which the §7 schema timeline surfaces
-//! honestly via `Partial` results + `warnings`) or have to fall
-//! back to the exact DB.
-//!
-//! Backfill closes that gap: a `BackfillJob` reads raw samples from
-//! the exact DB for a `(agg_id, time_range)` window, rebuilds the
-//! sketch deterministically (§10.5), and writes it into the store
-//! tagged as `origin = Backfilled { job_id }`. After the job
-//! completes, the new agg_id's timeline segment covers the historical
-//! range too.
-//!
-//! ## Phase 5a scope (what this file covers)
-//!
-//! Pure data types + a thread-safe registry:
-//!
-//! * `BackfillJob` struct with lifecycle fields (`status`,
-//!   `windows_done` / `windows_total`, `started_at_ms`,
-//!   `completed_at_ms`, `error_message`).
-//! * `BackfillSource` enum (the four variants from §10.2) plus the
-//!   `OtherSketch { source_agg_id }` intra-tier case.
-//! * `BackfillStatus` enum with the full state machine (Queued →
-//!   Running → Complete / Failed / Cancelled).
-//! * `Coverage` enum (Complete / BackfillInProgress / Missing).
-//! * `BackfillRegistry` — monotonic `job_id` allocation + thread-safe
-//!   create / get / list / update_status / cancel, entirely
-//!   in-memory.
-//!
-//! ## Out of scope for 5a (future phases)
-//!
-//! * `RawSampleReader` trait and concrete readers (§10.2) — Phase 5b.
-//! * `BackfillWorkerPool` draining the registry — Phase 5c.
-//! * HTTP `POST /api/v1/db/backfill` + `GET /api/v1/db/backfill/jobs`
-//!   endpoints — Phase 5d.
-//! * Deterministic sketch rebuild (§10.5) — Phase 5e.
-//! * Coverage lookup by the query path (§7.3) — Phase 5f.
-//! * On-disk persistence of job records across restart — Phase 5g
-//!   (analogous to schema persistence in Phase 2c).
+//! Backfill reconstructs windows preceding a materialization's live ingestion
+//! from source samples. Jobs progress from Queued to Running and then Complete,
+//! Failed, or Cancelled. The registry tracks written windows for coverage lookup
+//! and optionally persists job records across restarts.
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
@@ -105,7 +62,7 @@ pub enum BackfillSource {
 ///
 /// Complete / Failed / Cancelled are terminal. The registry keeps
 /// terminal jobs visible for a tunable retention so operators and
-/// the HTTP list endpoint (Phase 5d) can see recent history.
+/// the HTTP list endpoint can see recent history.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BackfillStatus {
     /// Accepted by the registry, waiting for a worker. Registry's
@@ -229,7 +186,7 @@ pub enum Coverage {
 ///   Complete / Failed / Cancelled, further transitions are
 ///   rejected with `false` return.
 ///
-/// ## Persistence (Phase 5g)
+/// ## Persistence
 ///
 /// Opt-in via [`Self::with_persistence`] or the
 /// [`Self::load_or_new`] constructor. When set, the registry
@@ -1151,7 +1108,7 @@ mod tests {
         assert!(BackfillStatus::Cancelled.is_terminal());
     }
 
-    // ─── Phase 5g: persistence tests ───────────────────────────────
+    // ─── persistence tests ───────────────────────────────
 
     #[test]
     fn persistence_roundtrip_preserves_job_state() {
@@ -1295,7 +1252,7 @@ mod tests {
         assert!(!path.exists());
     }
 
-    // ─── Phase 5f: coverage() tests ─────────────────────────────
+    // ─── coverage() tests ─────────────────────────────
 
     #[test]
     fn range_covered_by_empty_ranges_is_false() {
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/processor.rs b/data_plane/src/storage_engines/sketch_db/backfill/processor.rs
index b791bf827..a8f8733ff 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/processor.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/processor.rs
@@ -1,67 +1,16 @@
-//! `BackfillWindowProcessor` — the Phase 5e implementation of
-//! [`WindowProcessor`] that actually rebuilds sketches and writes
-//! them into the store.
+//! Rebuild window accumulators from a raw sample reader and write them to storage.
 //!
-//! Implements §10 (refreshable view maintenance) of the sketch DB
-//! design ([`future-storage-and-compression.md`](../../../../../docs/design_docs/future-storage-and-compression.md)).
-//! Reads raw samples from a [`RawSampleReader`] (Phase 5b), groups
-//! them by the agg's `grouping_labels` just like live ingest does,
-//! and writes per-(group, window) precomputes to the store.
+//! Backfill runs in its own worker, separate from live ingestion and active panes.
+//! It shares the pure accumulator factory with live ingest and records written
+//! windows in the backfill registry for coverage lookup.
 //!
-//! ## Separation from live ingest
+//! Jobs created through `BackfillRegistry::create_checked` end at or before the
+//! materialization's creation time, keeping replay ranges disjoint from live
+//! ingestion.
 //!
-//! The user's Phase 5e direction was: "backfill should be a wholly
-//! separate path; workers / results / data should carry distinct
-//! identification; prefer isolation even at the cost of some
-//! duplication." The code structure honours this:
-//!
-//! * **Separate worker**: processor runs inside a `BackfillWorker`
-//!   (Phase 5c), which is in turn driven by a `BackfillService`
-//!   tokio task that is NOT part of the `PrecomputeEngine`.
-//! * **Separate output path**: writes go straight to the
-//!   `Store::insert_precomputed_output_batch` call without passing
-//!   through `OutputSink`/`PrecomputeEngine`/`WindowManager`. The
-//!   live worker does the same call at the end of its chain, but
-//!   the backfill path gets there through its own code.
-//! * **Distinct identification**: after every successful batch
-//!   write the processor calls
-//!   `BackfillRegistry::record_window_written(job_id, agg_id,
-//!   window_range)`. Phase 5f's coverage tracker will consult this
-//!   list to distinguish `Backfilled { job_id }` from `Missing`
-//!   without needing a provenance field on the on-disk precompute
-//!   format.
-//! * **Shared primitives (deliberately)**: the pure
-//!   `create_accumulator_updater` factory is reused (via
-//!   [`super::backfill_window_builder::build_backfilled_accumulator`]).
-//!   See that module's doc for why.
-//!
-//! ## Time-disjoint invariant
-//!
-//! The processor never checks `is_writable(agg_id)` or locks
-//! against live writes on the same `(agg_id, window)` — the
-//! [`BackfillRegistry::create_checked`] constructor already
-//! enforces that the backfill range ends at-or-before the agg's
-//! `created_at_ms`. Live ingest owns `[created_at, ∞)`; backfill
-//! owns `[0, created_at)`. Disjoint by construction.
-//!
-//! ## Determinism (§10.5)
-//!
-//! For deployments where live ingest goes through Prometheus
-//! remote write (backend-native sketch construction), the
-//! backfilled sketch is **bit-identical** to what live would have
-//! produced from the same samples in the same order, because both
-//! paths call `create_accumulator_updater` + `update_single` /
-//! `update_keyed` in ingest order. The live-vs-backfill parity
-//! test in this file locks that invariant.
-//!
-//! For deployments where live goes through the DataCollector
-//! OTLP path (DC builds the sketch via sketchlib-go and the
-//! backend only deserialises), bit-identicalness requires the
-//! Go-side sketchlib and the Rust-side sketch-core to produce
-//! identical output for the same input. That cross-language
-//! audit is tracked as separate work; today, backfill in such
-//! deployments is "approximately equivalent within sketch error
-//! bounds ε".
+//! For backend-native construction, the same samples in the same order use the
+//! same factory and update operations as live ingest. Cross-language collector
+//! construction requires separate parity verification.
 
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -178,11 +127,8 @@ pub struct BackfillWindowProcessor {
     /// `AggregationConfig` for `agg_id`. The snapshot is cheap
     /// (Arc refcount bump) so we don't optimise further.
     config: HotReloadStreamingConfig,
-    /// Phase 5 M2.3.6g — replayed batches land here. The legacy
-    /// `Arc<dyn Store>` field is gone; SketchStore is the only
-    /// destination. Optional so tests that don't observe write
-    /// effects can skip attaching one (the processor becomes a
-    /// registry-only logger in that case).
+    /// Destination for rebuilt windows. Tests may omit it to record registry
+    /// provenance without storing payloads.
     sketch_index: Option<Arc<crate::storage_engines::sketch_db::index::SketchStore>>,
     /// Shared sid mint authority. Same `SeriesIdResolver` the OTel
     /// ingest path uses, so backfilled precompute sids land in the
@@ -366,13 +312,8 @@ impl WindowProcessor for BackfillWindowProcessor {
             batch.push((sid, output, accumulator));
         }
 
-        // Phase 5 M2.3.6g — replayed batches land in SketchStore only.
-        // No legacy SketchStore write path remains. When no
-        // sketch_index is attached (tests), the writes are simply
-        // dropped — the registry still records the (agg_id, range)
-        // provenance below. When sketch_index is attached but no
-        // resolver was provided, the precompute write is skipped
-        // with a warn — sid minting requires the shared resolver.
+        // Tests without a sketch index record provenance only. Writes with an index
+        // require the shared sid resolver; otherwise log a warning and skip them.
         if let Some(idx) = self.sketch_index.as_ref() {
             match self.series_resolver.as_ref() {
                 Some(_resolver) => {
@@ -622,25 +563,8 @@ mod tests {
         // every expected write.
     }
 
-    /// ## The parity test (§10.5 determinism invariant)
-    ///
-    /// This is the test that locks the "backfill produces the same
-    /// sketch as live" claim from the module doc. For the raw-ingest
-    /// path (sketch-core-native construction), a backfilled
-    /// accumulator MUST serialise to exactly the same bytes as a
-    /// live-built accumulator fed the same samples in the same order.
-    ///
-    /// The test builds two SumAccumulators from the same sample
-    /// sequence (one via the live path's `create_accumulator_updater`
-    /// plus `update_single`, and one via the backfill path's
-    /// `build_backfilled_accumulator`) and asserts their
-    /// `serialize_to_bytes()` outputs are byte-identical.
-    ///
-    /// A similar CMS parity test would be ideal; it's skipped here
-    /// because `CountMinSketchAccumulator::new` in sketch-core takes
-    /// more params than we exercise elsewhere and would require
-    /// deeper wiring. If Phase 5e needs stronger coverage, add a
-    /// CMS-specific parity test — it'll follow the exact same shape.
+    /// Sum accumulators built by live and backfill paths must serialize identically
+    /// when given the same ordered samples.
     #[test]
     fn backfill_builds_bit_identical_sum_accumulator_to_live() {
         use crate::precompute_engine::accumulator_factory::create_accumulator_updater;
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/prometheus_reader.rs b/data_plane/src/storage_engines/sketch_db/backfill/prometheus_reader.rs
index aa5ab6524..ea071d5a2 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/prometheus_reader.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/prometheus_reader.rs
@@ -37,7 +37,7 @@
 //!
 //! Every network / parse failure is mapped to a
 //! [`RawSampleReaderError`] variant. The backfill worker
-//! (Phase 5c) stringifies the error into
+//! stringifies the error into
 //! `BackfillJob::error_message` and marks the job `Failed`, so a
 //! broken Prometheus URL fails loud instead of quietly looping.
 
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/service.rs b/data_plane/src/storage_engines/sketch_db/backfill/service.rs
index 3b10f79b8..af75b380a 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/service.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/service.rs
@@ -98,8 +98,7 @@ impl Default for BackfillServiceConfig {
 /// the loop gracefully.
 pub struct BackfillService {
     registry: Arc<BackfillRegistry>,
-    /// Phase 5 M2.3.6g — replayed batches land in `SketchStore` only;
-    /// the legacy `Arc<dyn Store>` field is gone.
+    /// Destination for rebuilt windows.
     sketch_index: Option<Arc<crate::storage_engines::sketch_db::index::SketchStore>>,
     /// Shared sid mint authority — wired alongside `sketch_index` so
     /// backfilled precompute sids share the namespace with live ingest.
@@ -318,16 +317,9 @@ pub fn noop_reader_factory() -> ReaderFactory {
     })
 }
 
-/// Production-ready `ReaderFactory` covering the source variants
-/// whose readers ship in-tree as of Phase 5h:
-///
-/// * [`BackfillSource::Prometheus`] — routed to
-///   [`super::prometheus_reader::PrometheusReader`].
-///
-/// Other variants return a clear
-/// "not yet implemented" error, which the worker surfaces on
-/// `BackfillJob::error_message` so the control plane / operator sees
-/// exactly which reader is missing.
+/// Default reader factory for Prometheus sources. ClickHouse requires a
+/// deployment reader factory; unsupported sources fail with an error visible
+/// on the backfill job.
 pub fn default_reader_factory() -> ReaderFactory {
     Arc::new(|source, _materialization| match source {
         BackfillSource::Prometheus { url } => {
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/window_builder.rs b/data_plane/src/storage_engines/sketch_db/backfill/window_builder.rs
index 55ba2f772..04a4eed39 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/window_builder.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/window_builder.rs
@@ -1,51 +1,8 @@
-//! Sketch construction for the backfill path.
+//! Build a backfill window accumulator from source samples in ingestion order.
 //!
-//! Implements the "real rebuild" piece of §10 (refreshable view
-//! maintenance) from the sketch DB design
-//! ([`future-storage-and-compression.md`](../../../../../docs/design_docs/future-storage-and-compression.md)).
-//! Given an `AggregationConfig` and a batch of raw samples for one
-//! `(agg_id, window)` pair, produces the `Box<dyn AggregateCore>`
-//! that would have been produced had those samples flowed through
-//! live ingest in the same order.
-//!
-//! ## Shared primitive vs duplicated code
-//!
-//! The user's direction for Phase 5e was: "backfill functions should
-//! all be separate, not reusing the live path." The interpretation
-//! here splits two things that could each be called "the live path":
-//!
-//! 1. **The worker pipeline**: `PrecomputeEngine` → `SeriesRouter`
-//!    → `Worker` → `active_panes` → `WindowManager` →
-//!    `output_sink.emit_batch`. This is stateful infrastructure
-//!    that owns live latency budgets. **NOT reused** — the backfill
-//!    service runs a completely separate tokio task, uses its own
-//!    writer, and never touches an `active_pane`.
-//!
-//! 2. **The `create_accumulator_updater` factory**: a pure function
-//!    `AggregationConfig -> Box<dyn AccumulatorUpdater>`. Takes no
-//!    shared state, has no latency budget, is a 60-line match
-//!    statement. **IS reused** by this module.
-//!
-//! The reuse is deliberate: duplicating the factory would mean every
-//! new sketch type needs matching entries in two places, and the
-//! ε-precision end-to-end determinism test would catch drift only
-//! post-merge. Centralising on one factory makes "live ≡ backfill"
-//! a build-time invariant rather than a runtime one.
-//!
-//! If this interpretation is wrong — if the requirement is strict
-//! duplication accepting the drift risk — swap
-//! `create_accumulator_updater` below for a copy-pasted match
-//! statement. Everything else in the backfill module tree is
-//! already its own code path.
-//!
-//! ## Phase 5e scope (this file)
-//!
-//! * `build_backfilled_accumulator(config, samples) -> Box<dyn
-//!   AggregateCore>` — the pure function that rebuilds one
-//!   window's accumulator from its samples.
-//! * Handles both SingleSubpopulation (update_single) and
-//!   MultipleSubpopulation (update_keyed) dispatch — mirrors
-//!   `worker::apply_sample`.
+//! Backfill has its own worker pipeline and does not touch live active panes.
+//! It shares the pure accumulator factory and update primitives with live ingest
+//! so both paths use the same sketch semantics.
 
 use crate::precompute_engine::accumulator_factory::{
     create_accumulator_updater, AccumulatorUpdater,
diff --git a/data_plane/src/storage_engines/sketch_db/backfill/worker.rs b/data_plane/src/storage_engines/sketch_db/backfill/worker.rs
index ba09bdd48..c9e22b179 100644
--- a/data_plane/src/storage_engines/sketch_db/backfill/worker.rs
+++ b/data_plane/src/storage_engines/sketch_db/backfill/worker.rs
@@ -1,59 +1,10 @@
-//! `BackfillWorker` — drives a single [`BackfillJob`] through the
-//! registry state machine.
+//! Drive one backfill job through its registry lifecycle.
 //!
-//! Implements §10.3 (refresh as a separate worker pool) of the
-//! future storage scope ([`future-storage-and-compression.md`](../../../../../docs/design_docs/future-storage-and-compression.md)).
-//! Phase 5c scope: one job at a time, synchronous windowing loop,
-//! pluggable processor. The multi-worker pool with priority +
-//! isolation from live ingest (§11.4) lands in a follow-up.
-//!
-//! ## What the worker does
-//!
-//! 1. Calls [`BackfillRegistry::start`] to transition the job from
-//!    `Queued` to `Running`. If that returns `false` (unknown job /
-//!    non-queued), bails out.
-//! 2. Splits the job's `[start_ms, end_ms)` range into
-//!    `windows_total` equal windows. Rounding: any leftover ms from
-//!    integer division is absorbed into the final window so the
-//!    caller sees exactly `windows_total` windows and the full range
-//!    is covered.
-//! 3. For each window in order:
-//!    * Reads matching samples via [`RawSampleReader::read_samples`].
-//!    * Hands them to [`WindowProcessor::process_window`] along with
-//!      the job's `agg_id` and the window's `(start, end)` range.
-//!    * Calls [`BackfillRegistry::tick_progress`] so the §10.4
-//!      coverage tracker sees progress as a monotonically-increasing
-//!      fraction.
-//!    * Re-checks the job status before the next window — if
-//!      `Cancelled`, stops cleanly without `mark_failed`ing (the
-//!      caller already terminalised it).
-//! 4. On all windows succeeding, calls [`BackfillRegistry::mark_complete`].
-//! 5. On any reader or processor error, calls
-//!    [`BackfillRegistry::mark_failed`] with the error stringified
-//!    and bubbles the error up so the caller can react.
-//!
-//! ## Phase 5c scope (what this file covers)
-//!
-//! * `WindowProcessor` trait — the per-window callback the worker
-//!   invokes. Phase 5e implements the real sketch-building
-//!   processor; for now a [`RecordingProcessor`] captures calls for
-//!   tests.
-//! * `BackfillWorker::run_job(job_id, filter, reader, processor)` —
-//!   the one-job-at-a-time driver.
-//! * Tests covering happy path, reader error, processor error,
-//!   mid-run cancellation, single-window edge case, empty-samples
-//!   window, and non-queued job rejection.
-//!
-//! ## Out of scope for 5c (future phases)
-//!
-//! * Multi-worker concurrency + job prioritisation (§11.4) — a
-//!   `BackfillPool` wrapping N `BackfillWorker` tasks polling the
-//!   registry, coming in Phase 5c-2 or 5d.
-//! * Reader selection from `BackfillSource` — Phase 5e wires
-//!   concrete readers per variant.
-//! * Actual sketch construction inside the processor — Phase 5e.
-//! * §6.3 schema barrier enforcement on backfill writes — Phase 5e
-//!   (when the processor actually writes into the store).
+//! Transition Queued to Running, divide the requested range into windows, and
+//! read and process each window in order. The final window absorbs any integer
+//! rounding remainder. Check cancellation between windows, record progress,
+//! and mark the job Complete or Failed. Reader selection and sketch construction
+//! are supplied by the caller.
 
 use std::sync::Arc;
 
@@ -62,11 +13,8 @@ use async_trait::async_trait;
 use super::raw_sample_reader::{LabelFilter, RawSample, RawSampleReader};
 use super::{BackfillRegistry, BackfillStatus};
 
-/// Per-window callback invoked by [`BackfillWorker`] after reading
-/// samples for a window. Phase 5e implements a real processor that
-/// feeds samples into a fresh accumulator and writes the resulting
-/// precompute to the store; for now the trait exists so the worker's
-/// orchestration logic is independently testable.
+/// Per-window callback after source samples are read. Separates job
+/// orchestration from accumulator construction and storage writes.
 #[async_trait]
 pub trait WindowProcessor: Send + Sync {
     async fn process_window(
diff --git a/data_plane/src/storage_engines/sketch_db/data/mod.rs b/data_plane/src/storage_engines/sketch_db/data/mod.rs
index d5c423311..01c297274 100644
--- a/data_plane/src/storage_engines/sketch_db/data/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/data/mod.rs
@@ -44,10 +44,6 @@
 //! - [`AggregationType`] — the agg-type enum that
 //!   `AggKind::ExactAgg` carries.
 
-// `xxhash_rust::xxh64` import retired alongside `compute_sid` (PR-4).
-// Sid minting is now registry-allocated via `SeriesIdResolver` — no
-// content-addressed hash is computed at this layer.
-
 // ── Capability re-exports ────────────────────────────────────────────────────
 //
 // Step 2a consolidated all capability state into
@@ -122,16 +118,8 @@ pub enum AggKind {
         /// the policy has no spatial filter.
         spatial_filter_canonical: String,
     },
-    /// Exact aggregation state — Sum, Count, Avg, Rate, MinMax,
-    /// SetAggregator, etc. Payload at storage layer is whatever the
-    /// per-accumulator serializer produces.
-    ///
-    /// Variant name history: previously `AggKind::Precompute` — the
-    /// rename to `ExactAgg` (PR `refactor/sid-identity-spatial-filter-and-rename`)
-    /// reflects that `precompute_engine/` is the *engine* that
-    /// produces both sketch and exact-aggregation outputs, while this
-    /// variant names what the *payload* is. The two had been
-    /// confusingly conflated.
+    /// Exact accumulator state. Payload bytes come from the corresponding
+    /// accumulator serializer.
     ExactAgg {
         agg_type: AggregationType,
         /// Stable canonical encoding of the agg's
@@ -414,16 +402,6 @@ fn sketch_config_canonical(cfg: &SketchConfig) -> String {
     }
 }
 
-// ── sid hash ────────────────────────────────────────────────────────────────
-//
-// `compute_sid` was retired alongside `compute_sketch_sid` (PR-3) and
-// the precompute ingest migration (PR-4). All sid minting now flows
-// through `SeriesIdResolver` — one registry-allocated u64 per
-// `(metric, attrs_fingerprint, agg_kind_canonical)` triple, shared
-// across the OTel sketch ingest path and the precompute output path.
-// See `AggKind::canonical_string` for the agg-kind canonicalization
-// that replaces the byte-layout this hash used to produce.
-
 // ── Accuracy ────────────────────────────────────────────────────────────────
 
 /// Accuracy bound derived from `SketchConfig`. Surfaced to the user
diff --git a/data_plane/src/storage_engines/sketch_db/index/epoch_columnar.rs b/data_plane/src/storage_engines/sketch_db/index/epoch_columnar.rs
index 695c75052..f4bffd518 100644
--- a/data_plane/src/storage_engines/sketch_db/index/epoch_columnar.rs
+++ b/data_plane/src/storage_engines/sketch_db/index/epoch_columnar.rs
@@ -1,37 +1,12 @@
-//! Epoch-partitioned columnar storage — generic payload type.
+//! Epoch-partitioned columnar storage with a generic payload type.
 //!
-//! Lifted from `sketch_store::common` (legacy SketchStore index)
-//! with the payload column type made generic so the new SketchStore
-//! (Phase 5) can reuse the legacy's six storage optimizations
-//! (`INDEX_DESIGN.md`) without dragging in `Arc<dyn AggregateCore>`
-//! dynamic dispatch.
+//! Parallel window, label-id, and payload columns let range scans inspect only
+//! window metadata. Indexes store offsets rather than cloning payloads; the
+//! window index is built lazily and invalidated on insert. Monotonic ingestion
+//! skips redundant probes, and rotation preallocates epoch buffers.
 //!
-//! # Optimizations carried over from legacy
-//!
-//! | Opt | What |
-//! |-----|------|
-//! | 1 | Lazy `window_to_ids` index — built on first exact query, invalidated cheaply on insert |
-//! | 2 | Offset-based index — stores `u32` column offsets, not payload clones |
-//! | 3 | Monotonic ingest fast path — skip `HashSet` probe for consecutive same-window inserts |
-//! | 4 | Batch metadata hoisting — caller responsibility (the OTLP receive path groups DPs by sid) |
-//! | 5 | Columnar storage — three parallel arrays; range scan touches only `windows_col` |
-//! | 6 | Pre-allocated epoch buffers on rotation |
-//!
-//! # Differences from legacy
-//!
-//! - **Generic payload type**: `MutableEpoch<P>` instead of
-//!   `Vec<Arc<dyn AggregateCore>>`. The new SketchStore stores
-//!   `SketchSampleState` directly (typed bytes + encoding tag) — no
-//!   dyn dispatch, no Arc cloning, payload moves into the column.
-//! - **Series-values keyed via `LabelValuesId = u32`** (renamed from
-//!   legacy `MetricID = u32`). The intern table maps the per-series
-//!   group-by VALUES vector to a compact ID, since the SketchStore's
-//!   sid already captures the metric identity at the level above.
-//!
-//! See INDEX_DESIGN.md in `sketch_store/` for the full complexity
-//! analysis (Insert O(1), range query O(M) mutable / O(log N + k)
-//! sealed, etc.) — those bounds carry over verbatim because the
-//! algorithmic structure is unchanged.
+//! Label-value vectors are interned as `LabelValuesId`; the owning sid already
+//! identifies the metric. Callers can hoist shared metadata when batching writes.
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 
diff --git a/data_plane/src/storage_engines/sketch_db/index/mod.rs b/data_plane/src/storage_engines/sketch_db/index/mod.rs
index 80114880d..84e8a2071 100644
--- a/data_plane/src/storage_engines/sketch_db/index/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/index/mod.rs
@@ -14,7 +14,7 @@
 //! exist when an agent registers a pre-merge identity that the gateway
 //! folds into a different (post-merge) identity before backend ever sees
 //! the sketch payload. Query path treats ghost sids as ASAP-tier MISS
-//! and falls through to Thanos archive (Phase 6).
+//! and falls through to Thanos archive.
 //!
 //! See design doc §4.6 ("OTLP metadata model + backend store layout") at
 //! `docs/design_docs/series-identity.md`.
@@ -37,10 +37,6 @@ use crate::storage_engines::sketch_db::sds::{
     DataDescriptor, SdsBinding, SummaryDescriptor, SummaryDescriptorRegistry,
 };
 
-// Phase-5 reorg: payload taxonomy + sid hashing + accuracy moved to
-// `sketch_db::data`. Re-exported here so existing call sites
-// (`crate::storage_engines::sketch_db::index::*`) keep compiling
-// during the reorg.
 pub use crate::storage_engines::sketch_db::data::{
     canonical_parameters, AccuracyBound, AggKind, AggPayload, AggregationType, Capability,
     SketchAlgorithm, SketchConfig, SketchEncoding, SketchSampleState, SketchTimeSeries,
@@ -191,20 +187,11 @@ fn build_attrs_fp_and_label_map(
     Ok((attrs_fp, label_values_map))
 }
 
-/// Metadata for one logical sketch instance, keyed by `series_id`.
-/// Populated at ingest time when a sketch DataPoint with a fresh sid
-/// arrives (or `(metric, attrs)` produces a fresh sid via the
-/// SeriesIdResolver). Subsequent emits of the same sid append to the
-/// associated `SidStoreData` without re-touching this metadata.
+/// Metadata for one logical sketch instance, keyed by sid. Ingest registers it
+/// on first sight; later writes append to the associated per-sid storage.
 ///
-/// **Lifecycle fields** (Phase 5 M1): mirror `AggSchema`'s
-/// `Active → Retired → Expired` state machine so the sid-keyed path
-/// has the same write-side barrier semantics as the agg_id-keyed path.
-/// `status()` is derived from `retired_at_ms` + `expires_at_ms` and
-/// the wall clock — never stored directly. M2 cuts the ingest barrier
-/// over from `SchemaRegistry::is_writable(agg_id)` to
-/// `SketchStore::is_writable(sid)`; until then both registries run
-/// side by side.
+/// Lifecycle status is derived from retirement and expiry timestamps plus the
+/// wall clock. Only active instances accept writes.
 #[derive(Debug, Clone)]
 pub struct SketchInstanceMetadata {
     pub sid: u64,
@@ -262,10 +249,7 @@ impl SketchInstanceMetadata {
         }
     }
 
-    /// Whether this sid accepts writes. Equivalent to
-    /// `status() == AggStatus::Active`. Phase 5 ingest barrier
-    /// (M2 cutover) will call this in place of
-    /// `SchemaRegistry::is_writable(agg_id)`.
+    /// Whether this sid accepts writes: `status() == AggStatus::Active`.
     pub fn is_writable(&self) -> bool {
         matches!(self.status(), AggStatus::Active)
     }
@@ -303,10 +287,6 @@ impl SketchInstanceMetadata {
     }
 }
 
-// `SketchSampleState`, `SketchEncoding`, `SketchTimeSeries`, and
-// `AggPayload` moved to `sketch_db::data` in the Phase-5 reorg; they're
-// re-exported at the top of this file for backwards compatibility.
-
 /// Per-sid storage value — wraps `SidStoreData` in an `RwLock` so the
 /// outer DashMap stays read-mostly and per-sid writes don't block one
 /// another. Payload type is the unified [`AggPayload`] enum so one
@@ -576,13 +556,9 @@ impl From<&asap_types::producer_plan::SummaryFrameIdentity> for IncompleteSummar
     }
 }
 
-/// Two-level sketch index. Replaces the legacy `aggregation_id`-keyed
-/// SimpleStore lookup once Phase 5 wiring lands at the streaming engine
-/// ingest path and the query path.
-///
-/// `instances` is keyed under a `RwLock<HashMap>` because the registration
-/// rate is low (one write per first-seen sid) and reads dominate;
-/// `series` is a `DashMap` because per-sid writes happen on every DP.
+/// Two-level sketch index. Metadata uses `RwLock<HashMap>` for infrequent
+/// registration and frequent reads; per-sid data uses `DashMap` for writes on
+/// every datapoint.
 #[derive(Clone, Copy)]
 pub(crate) struct SummaryReadRevision {
     admission: u64,
@@ -2606,11 +2582,7 @@ impl SketchStore {
         }
     }
 
-    // ── Phase 5 M1: lifecycle-status surface ─────────────────────────
-    //
-    // Mirror the `SchemaRegistry` lifecycle methods so the ingest /
-    // eviction paths can cut over from `agg_id` to `sid` in M2. Until
-    // M2 lands, both registries run side by side.
+    // Sid lifecycle transitions and status lookup.
 
     /// Whether `sid` accepts writes. Equivalent to
     /// `status(sid) == AggStatus::Active`. Returns `false` for
@@ -2938,12 +2910,8 @@ impl SketchStore {
 }
 
 impl SketchStore {
-    /// Phase 5 M2.3.6g — runtime-info / diagnostic helper. Returns the
-    /// per-sid `first_seen_unix_ms` for every registered sid. The
-    /// legacy `Store::get_earliest_timestamp_per_aggregation_id` returned
-    /// an analogous `agg_id → ts` map; this is the SketchStore
-    /// equivalent. HTTP server's `/api/v1/status/runtimeinfo` adapter
-    /// surfaces it under the JSON field `earliest_timestamp_per_sid`.
+    /// Return first-seen timestamps per sid for runtime diagnostics. The HTTP
+    /// adapter exposes this as `earliest_timestamp_per_sid`.
     pub fn earliest_timestamps_per_series_id(&self) -> std::collections::HashMap<u64, u64> {
         let g = self.instances.read().unwrap();
         g.iter()
@@ -3494,13 +3462,8 @@ impl SketchStore {
     }
 }
 
-// ── Phase 5 M2.3.6b — EpochSource impl ──────────────────────────────────────
-//
-// Lets the existing persistence flusher (`store/persistence/flusher.rs`)
-// drive `SketchStore` instead of `SketchStorePerKey`. The `agg_id: u64`
-// field on `SealedEpochRef` / `EpochSnapshot` carries a `sid` here —
-// the trait keeps the historical name so the flusher / manifest /
-// part-writer stay untouched.
+// Persistence epoch interface. The `agg_id` field on epoch references carries
+// a sid in this store; persistence readers and writers must interpret it so.
 impl crate::storage_engines::sketch_db::index::persistence::EpochSource for SketchStore {
     fn flush_before_ms(&self) -> Option<u64> {
         let cutoff = self
diff --git a/data_plane/src/storage_engines/sketch_db/lifecycle/eviction.rs b/data_plane/src/storage_engines/sketch_db/lifecycle/eviction.rs
index dbe81fbb2..14c9ea2db 100644
--- a/data_plane/src/storage_engines/sketch_db/lifecycle/eviction.rs
+++ b/data_plane/src/storage_engines/sketch_db/lifecycle/eviction.rs
@@ -1,49 +1,11 @@
-//! `SchemaEvictionService` — background task that drops
-//! `AggStatus::Expired` schemas' data and removes them from the
-//! registry.
+//! Remove expired sid instances and their stored data on a periodic sweep.
 //!
-//! Implements the §6.2 "scheduled for deletion by the time-TTL
-//! sweep" semantics the lifecycle enum promises. Sits alongside
-//! the SketchStore's age-based `persistence_delete_older_than`
-//! retention — the two are independent:
+//! Lifecycle retention is separate from age-based data retention. Configure
+//! `persistence_delete_older_than > retirement_retention` so whole-instance
+//! eviction can precede age-based record removal.
 //!
-//! * **Schema retention** (this module): lifecycle-driven. When a
-//!   schema is removed from `StreamingConfig` it transitions
-//!   `Active → Retired → Expired`; when `expires_at_ms` passes we
-//!   drop its `agg_id`.
-//! * **Data retention** (SketchStore): age-driven. Records
-//!   older than `persistence_delete_older_than` get swept up
-//!   regardless of schema.
-//!
-//! ## Ordering guideline
-//!
-//! The user's design rule is: `persistence_delete_older_than >
-//! retirement_retention`. That way data-retention never beats
-//! schema-eviction to the punch on an Expired schema's records —
-//! schema-eviction takes them out cleanly in one bulk drop
-//! (O(1)-ish per the `drop_agg_id` contract) before data-retention
-//! would wade in record-by-record. `SchemaEvictionService` logs a
-//! `warn!` at startup if the ordering is inverted.
-//!
-//! ## What the service does on each tick
-//!
-//! 1. Snapshot the schema registry: collect every `AggStatus::Expired`
-//!    schema.
-//! 2. For each Expired schema's `agg_id`:
-//!    - Cancel any `Running` backfill job targeting that agg_id
-//!      (they're writing to data about to be dropped — wasted work).
-//!    - Call `store.drop_agg_id(agg_id)` to evict the windows.
-//!    - `schema_registry.remove_schema(agg_id)` to drop the registry
-//!      entry so it won't be re-evicted next tick.
-//! 3. Log an audit line per eviction with `agg_id`, metric,
-//!    `retired_at_ms`, windows evicted.
-//!
-//! ## Dry-run
-//!
-//! `--schema-eviction-dry-run` sets `dry_run: true`. Every step
-//! above runs through the discovery + logging, but `drop_agg_id`
-//! and `remove_schema` are skipped. Use this to validate a new
-//! retention value before letting it delete anything.
+//! Dry-run logs discovered instances without removing them. Backfill jobs are
+//! policy-keyed, so this sid-level sweep does not cancel those jobs.
 
 use std::sync::Arc;
 use std::time::Duration;
@@ -56,9 +18,7 @@ use crate::storage_engines::sketch_db::backfill::BackfillRegistry;
 use crate::storage_engines::sketch_db::index::SketchStore;
 use crate::storage_engines::sketch_db::lifecycle::{AggStatus, DEFAULT_RETIREMENT_RETENTION};
 
-/// Configuration for the eviction loop. Separate from
-/// `SchemaRegistry`'s `retirement_retention` because the service
-/// owns the poll schedule, not the data model.
+/// Eviction schedule and dry-run configuration.
 #[derive(Clone, Debug)]
 pub struct SchemaEvictionConfig {
     /// How often to scan for Expired schemas. Coarse (default 5 min)
@@ -78,15 +38,8 @@ impl Default for SchemaEvictionConfig {
     }
 }
 
-/// Long-running tokio task that drops `Expired` sids' data.
-///
-/// Post-schema-retirement: the sweep is sid-driven. `SchemaRegistry`
-/// is gone; this service iterates the sid catalog directly and
-/// removes any sid whose status has progressed past `Retired`.
-/// `BackfillRegistry` is retained so future sid↔backfill wiring can
-/// reattach (today the sweep no longer cancels in-flight backfills
-/// because backfill jobs remain agg_id-keyed; a follow-up will
-/// rekey them on sid and restore the cancel step).
+/// Background task that removes expired instances from the sid catalog.
+/// The backfill registry is retained but is not consulted for cancellation.
 pub struct SchemaEvictionService {
     backfill: Arc<BackfillRegistry>,
     sketch_index: Arc<SketchStore>,
diff --git a/data_plane/src/storage_engines/sketch_db/lifecycle/mod.rs b/data_plane/src/storage_engines/sketch_db/lifecycle/mod.rs
index 292ebefc9..12f9b40ae 100644
--- a/data_plane/src/storage_engines/sketch_db/lifecycle/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/lifecycle/mod.rs
@@ -1,24 +1,8 @@
-//! Sid lifecycle — `Active`/`Retired`/`Expired` over per-sid metadata,
-//! eviction services, and the ingest barrier.
+//! Sid lifecycle reconciliation and eviction.
 //!
-//! Post-M2.3 reorg #5. The sid-level lifecycle state itself (the
-//! `retired_at_ms` / `expires_at_ms` fields on
-//! [`crate::storage_engines::sketch_db::index::SketchInstanceMetadata`],
-//! plus `force_retire` / `force_expire` / `is_writable` / `list_by_status`
-//! / `remove_instance` / `remove_instances_for_agg_config` methods on
-//! `SketchStore`) lives in `index/` next to the data it gates. This
-//! module owns the **services** that drive lifecycle transitions:
-//!
-//! - [`eviction::SchemaEvictionService`] — background tokio task that
-//!   sweeps `Expired` agg-configs (from the `SchemaRegistry`) and
-//!   removes their residual sids from `SketchStore` via
-//!   `remove_instances_for_agg_config`. Schedule-driven half of the
-//!   "control plane dropped a config → its sids go away" flow.
-//!
-//! - [`reconcile::reconcile_from_streaming_config`] — sid-level mirror
-//!   of [`SchemaRegistry::reconcile`](crate::storage_engines::sketch_db::schema::SchemaRegistry::reconcile),
-//!   landed in schema-retirement #4 alongside the otel.rs reconcile
-//!   call-site migration.
+//! Instance metadata in the index owns retirement and expiry timestamps.
+//! [`reconcile::reconcile_from_streaming_config`] retires orphaned precompute
+//! instances; [`eviction::SchemaEvictionService`] removes expired instances.
 
 pub mod eviction;
 pub mod reconcile;
diff --git a/data_plane/src/storage_engines/sketch_db/lifecycle/reconcile.rs b/data_plane/src/storage_engines/sketch_db/lifecycle/reconcile.rs
index d3574d782..944d6e892 100644
--- a/data_plane/src/storage_engines/sketch_db/lifecycle/reconcile.rs
+++ b/data_plane/src/storage_engines/sketch_db/lifecycle/reconcile.rs
@@ -1,35 +1,10 @@
-//! Sid-level reconcile against a fresh `StreamingConfig` snapshot —
-//! schema retirement #4.
+//! Reconcile sid lifecycle against a streaming configuration snapshot.
 //!
-//! Mirrors the "retire orphans" half of the legacy
-//! [`SchemaRegistry::reconcile`](crate::storage_engines::sketch_db::schema::SchemaRegistry::reconcile)
-//! but reads / writes the sid catalog directly. The "add new ids"
-//! half is implicit in the sid model: sids are minted lazily by the
-//! ingest path on first write (see
-//! `SketchStore::ingest_precompute_for_agg_config` and the modified-OTLP
-//! sketch path), so there is nothing to pre-register up front.
+//! Retire precompute instances whose content signature is absent from the
+//! configuration. New sids are registered lazily by ingestion.
 //!
-//! ## Signature comparison
-//!
-//! Each sid carries a content signature `(metric_name, agg_kind,
-//! group_by_keys)` derived from the agg-config + attrs at ingest time.
-//! Each agg-config in the new `StreamingConfig` likewise canonicalizes
-//! to a signature. A sid is "orphaned" when its signature does not
-//! match any agg-config in the new config — at that point ingest can
-//! no longer route to it, and it must be retired so the eviction
-//! sweep can later drop it.
-//!
-//! Sketch-typed agg-configs are not yet covered: the
-//! `AggregationConfig` shape doesn't carry a `SketchAlgorithm` /
-//! `SketchConfig` natively (control plane pushes them through a parallel
-//! capability-routing channel). For now the reconciler treats every
-//! agg-config as a precompute signature; sketch sids never compare
-//! equal so they're never retired by this path. That matches the
-//! pre-retirement behavior: `SchemaRegistry::reconcile` only retired
-//! agg_ids in its own registry, which mirrored the
-//! `StreamingConfig.aggregation_configs` map (also precompute-only).
-//! Sketch lifecycle stays driven by the control plane's eviction RPC
-//! until M3 unifies the two.
+//! Sketch sids use different signatures from the precompute configuration and
+//! are excluded from this reconciliation; their lifecycle is managed separately.
 
 use std::collections::{BTreeSet, HashSet};
 use std::sync::Arc;
diff --git a/data_plane/src/storage_engines/sketch_db/mod.rs b/data_plane/src/storage_engines/sketch_db/mod.rs
index 428886af6..847bef725 100644
--- a/data_plane/src/storage_engines/sketch_db/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/mod.rs
@@ -1,32 +1,8 @@
-//! Summary-storage components.
+//! Summary storage, persistence, query composition, lifecycle, and backfill.
 //!
-//! See [`summary-storage.md`](../../../../../docs/design_docs/summary-storage.md)
-//! for the semantic contract. This module houses the components that live
-//! "above" the existing `SketchStore` and turn it into a sketch-aware
-//! storage engine over time:
-//!
-//! * `schema` — per-`agg_id` `AggSchema` with `Active` / `Retired` /
-//!   `Expired` lifecycle, plus the `SchemaRegistry` that the ingest path
-//!   consults via `is_writable(agg_id)` (the §6.3 write-side barrier).
-//!   Also exposes the §7 metric timeline (`timeline_for_metric`) which
-//!   the query path uses to dispatch per-segment across reconfigure
-//!   boundaries.
-//!
-//! Earlier phases: 2a added the in-memory schema registry; 2b wired
-//! the `POST /api/v1/streaming-config` swap handler to drive
-//! reconciliation explicitly; 2c added on-disk persistence; 3a added
-//! the §7 schema-timeline read API; 3b added the cross-schema
-//! combiner (`crate::query_engines::timeline_dispatch`).
-//!
-//! * `backfill` — §10 of the design. `BackfillJob` lifecycle types
-//!   (`BackfillSource`, `BackfillStatus`, `Coverage`) plus an
-//!   in-memory `BackfillRegistry` that the control plane pushes jobs
-//!   into and the worker pool drains. Phase 5a (this commit) lands
-//!   the data types and registry only — no I/O, no workers, no
-//!   HTTP. Follow-up phases add the `RawSampleReader` trait
-//!   (5b), the worker pool (5c), HTTP trigger / list endpoints (5d),
-//!   real rebuild logic (5e), and coverage integration with the
-//!   query path (5f).
+//! The sid-keyed index holds instance metadata and per-window state. Lifecycle
+//! services reconcile configured policies and evict expired instances. Backfill
+//! rebuilds windows from source samples through its own worker and registry.
 
 pub mod accuracy;
 pub mod backfill;
diff --git a/data_plane/src/storage_engines/sketch_db/query/asap_tier_result.rs b/data_plane/src/storage_engines/sketch_db/query/asap_tier_result.rs
index 8f2fb33d8..12aeeef19 100644
--- a/data_plane/src/storage_engines/sketch_db/query/asap_tier_result.rs
+++ b/data_plane/src/storage_engines/sketch_db/query/asap_tier_result.rs
@@ -1,18 +1,5 @@
-//! `ASAPTierResult` — the per-series, per-window scalar-result shape
-//! `SummaryExecutor` (via `live_serve.rs`/`post_asap_readout.rs`) fills in for
-//! the engine to adapt into `QueryResult`.
-//!
-//! This module used to also hold `SketchReducer`, the legacy per-Capability
-//! reducer that answered queries directly from decoded sketch bytes before
-//! `SummaryExecutor` existed. It's retired: neither it nor
-//! `shadow_compare.rs` (the diagnostic comparison that validated
-//! `SummaryExecutor` against it) was any more "ground truth" than the
-//! `SummaryExecutor` path itself, and keeping a second, independently
-//! re-derived answering mechanism around after `SummaryExecutor` became
-//! the live default only meant two things could silently disagree with
-//! each other. `ASAPTierResult` survives because it's the shared
-//! wire-shape both the old reducer and `live_serve.rs` produced —
-//! nothing about it is reducer-specific.
+//! Per-series, per-window scalar results produced by summary execution and
+//! adapted by the query engine into `QueryResult`.
 
 use std::collections::BTreeMap;
 
diff --git a/data_plane/src/storage_engines/sketch_db/query/mod.rs b/data_plane/src/storage_engines/sketch_db/query/mod.rs
index e0b15c00e..5b4f64493 100644
--- a/data_plane/src/storage_engines/sketch_db/query/mod.rs
+++ b/data_plane/src/storage_engines/sketch_db/query/mod.rs
@@ -1,44 +1,7 @@
-//! Warm-tier sketch query evaluator (Phase 5 follow-up to PR #122).
+//! Sketch query state decoding, composition, and result types.
 //!
-//! PR #122 wired the ASAP-tier classification hook in
-//! [`crate::query_engines::asap_query_engine::engine::ASAPQueryEngine`]'s
-//! `QueryEngine::execute` adapter: parse the PromQL, extract
-//! `(metric_name, label_keys)`, look up candidate sids via
-//! [`crate::storage_engines::sketch_db::index::SketchStore::instances_matching`],
-//! and classify each sid. On `Ghost`/`Unknown`, return
-//! `EngineError::CapabilityMiss(SketchStore, …)` so the
-//! `EngineRouter` fails over to the archive engine.
-//!
-//! That hook today still falls through to `handle_query` (legacy
-//! datafusion path) on the all-`Hit` case. This module replaces
-//! that fall-through with **direct sketch evaluation** from
-//! [`SketchStore::query_range`]'s output: deserialize each
-//! window's sketch state, dispatch on the per-instance
-//! [`crate::storage_engines::sketch_db::index::Capability`], and reduce to a
-//! per-window scalar via the canonical sketch query (DDSketch /
-//! KLL → quantile, HLL → cardinality estimate, CMS / CountSketch
-//! → frequency point query, CMS-with-heap → top-k items).
-//!
-//! The deserialize + query glue mirrors the per-Capability paths
-//! already exercised by `precompute_operators::*_accumulator.rs` —
-//! same `asap_sketchlib` library calls so behavior matches the
-//! precompute (ingest-side) path bit-for-bit.
-//!
-//! ## Public surface
-//!
-//! * [`ASAPTierResult`] — per-series timestamped scalar samples
-//!   matching the shape of [`crate::query_engines::query_result::QueryResult::Matrix`],
-//!   filled in by `SummaryExecutor` (via
-//!   `asap_query_engine::live_serve`/`post_asap_readout`) — the sole
-//!   sketch-serving path; the legacy `SketchReducer` this module used
-//!   to also hold is retired (see `asap_tier_result.rs`'s doc).
-//!
-//! Query answering itself now goes entirely through
-//! [`control_plane::asap_tier_analysis::analyze_promql_for_asap_tier`]
-//! (candidate/capability resolution) and
-//! `asap_query_engine::live_serve::try_serve_from_summary_executor`
-//! (the actual `SummaryExecutor` dispatch) — nothing in this module
-//! parses PromQL or decodes sketch bytes directly anymore.
+//! [`ASAPTierResult`] carries timestamped scalar samples from summary execution
+//! to the query engine. Query planning and execution live outside this module.
 
 pub mod asap_tier_result;
 pub mod decoders;
diff --git a/data_plane/src/storage_engines/sketch_db/query/timeline.rs b/data_plane/src/storage_engines/sketch_db/query/timeline.rs
index 51329ad48..c06c84522 100644
--- a/data_plane/src/storage_engines/sketch_db/query/timeline.rs
+++ b/data_plane/src/storage_engines/sketch_db/query/timeline.rs
@@ -1,42 +1,12 @@
-//! Sid-level `timeline_for_metric` — schema retirement #1.
+//! Build a metric timeline from sid metadata.
 //!
-//! Produces the same `Vec<TimelineSegment>` shape as
-//! [`SchemaRegistry::timeline_for_metric`](crate::storage_engines::sketch_db::schema::SchemaRegistry::timeline_for_metric)
-//! but reads exclusively from the sid catalog
-//! ([`SketchStore::instances`](crate::storage_engines::sketch_db::index::SketchStore)).
-//! Lets the schema retirement remove the `SchemaRegistry`-keyed
-//! historical timeline without losing the cross-reconfigure query
-//! routing primitive.
+//! Group instances by `(agg_kind, group_by_keys)`, then fold first-seen and
+//! retirement timestamps. A group stays active if any member is active. Sort
+//! groups by start time and clip each segment to the next start, retirement,
+//! and requested time range.
 //!
-//! ## Algorithm
-//!
-//! 1. Snapshot all `SketchInstanceMetadata` for `metric` from the
-//!    sid catalog.
-//! 2. Group by content signature: `(agg_kind, group_by_keys)`. Each
-//!    group corresponds to one logical agg-config (multiple sids of
-//!    the same config share this signature; they differ only in
-//!    attrs values).
-//! 3. For each group, fold the per-sid lifecycle fields into one
-//!    per-group representative:
-//!    - `start_ms` = `min(first_seen_unix_ms)` across the group
-//!    - `retired_at_ms` = `Some(min(retired_at_ms))` iff every sid
-//!      in the group is retired, else `None`
-//!    - `status` = same fold (group is Active if any sid is Active;
-//!      Retired if all retired and none expired; Expired otherwise)
-//! 4. Apply the same segmenting logic as `SchemaRegistry`:
-//!    sort by start_ms, compute `own_end` = `min(next.start_ms,
-//!    self.retired_at_ms, u64::MAX)`, clip to `[t1_ms, t2_ms]`.
-//!
-//! ## `agg_id` field — what we put in it
-//!
-//! `TimelineSegment.agg_id: u64` made sense when timelines were
-//! produced from a `SchemaRegistry` of agg-configs. In the sid model
-//! we don't have a single agg_id per config — we have an
-//! agg-signature (the content tuple `(metric, agg_kind, group_by_keys)`).
-//! For schema-retirement back-compat with HTTP consumers, we surface
-//! a deterministic 64-bit hash of the signature in that field — same
-//! kind of stable-across-restarts content-derived id that PR #151
-//! used for `compute_agg_config_id`.
+//! `TimelineSegment.agg_id` carries a deterministic hash of the metric and
+//! content signature, rather than an individual sid.
 
 use std::collections::{BTreeMap, BTreeSet};
 
diff --git a/data_plane/src/storage_engines/traits.rs b/data_plane/src/storage_engines/traits.rs
index e6b9211f6..00af9eb06 100644
--- a/data_plane/src/storage_engines/traits.rs
+++ b/data_plane/src/storage_engines/traits.rs
@@ -8,8 +8,5 @@ pub type TimestampedBucket = ((u64, u64), Arc<dyn AggregateCore>);
 /// Map from key to timestamped buckets (sparse - only contains buckets that exist)
 pub type TimestampedBucketsMap = HashMap<Option<KeyByLabelValues>, Vec<TimestampedBucket>>;
 
-/// Result type the ASAP-tier code returns from operations that
-/// historically went through the now-retired `Store` trait. Kept as a
-/// crate-wide alias for callers that haven't migrated their signatures
-/// off `Result<_, Box<dyn std::error::Error + Send + Sync>>`.
+/// Shared result type for fallible storage operations.
 pub type StoreResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;
diff --git a/data_plane/src/storage_engines/types/precomputed_output.rs b/data_plane/src/storage_engines/types/precomputed_output.rs
index 26bcc733e..130f761ba 100644
--- a/data_plane/src/storage_engines/types/precomputed_output.rs
+++ b/data_plane/src/storage_engines/types/precomputed_output.rs
@@ -31,18 +31,7 @@ pub enum Origin {
     Backfilled { job_id: u64 },
 }
 
-/// One window of one (sid, label-values) group's emitted aggregation
-/// state. Produced by `PrecomputeWorker` / `BackfillWindowProcessor`
-/// and consumed by `SketchStoreSink::append_to_index`.
-///
-/// **PR-6 follow-up:** the `aggregation_id: u64` field that this struct
-/// used to carry alongside `policy_fp` is gone — `policy_fp` is the
-/// only identity handle. PR 4 added `policy_fp` as a parallel field
-/// with `aggregation_id` kept for legacy compat; PR 5 retired
-/// `AggregationConfig::aggregation_id`; this PR completes the cleanup
-/// by retiring the field on `PrecomputedOutput` too. Sinks resolve the
-/// source config via `PolicyRegistry::get(policy_fp)`.
-/// In-process proof of which accepted input revision a window includes.
+/// Proof of which accepted input revision a window includes.
 #[derive(Debug, Clone)]
 pub struct SummaryInputRevision {
     pub generation: std::sync::Arc<asap_types::sds::CatalogGeneration>,
diff --git a/data_plane/src/storage_engines/types/streaming_config.rs b/data_plane/src/storage_engines/types/streaming_config.rs
index 5c8b9ff42..74c6b2da9 100644
--- a/data_plane/src/storage_engines/types/streaming_config.rs
+++ b/data_plane/src/storage_engines/types/streaming_config.rs
@@ -120,11 +120,8 @@ impl StreamingConfig {
 
         if let Some(aggregations) = data.get("aggregations").and_then(|v| v.as_sequence()) {
             for aggregation_data in aggregations {
-                // Read per-agg retention directly from the YAML entry
-                // (previously was looked up via inference_config's
-                // query→agg map). `aggregationId` is no longer
-                // required — `AggregationConfig::from_yaml_data`
-                // derives it from content when absent (M2 follow-up).
+                // Retention comes from each aggregation entry; identity is derived from
+                // its configuration content.
                 let num_aggregates_to_retain = aggregation_data
                     .get("numAggregatesToRetain")
                     .and_then(|v| v.as_u64());
diff --git a/data_plane/src/tests/mod.rs b/data_plane/src/tests/mod.rs
index bc38c61e5..a7e21b1e6 100644
--- a/data_plane/src/tests/mod.rs
+++ b/data_plane/src/tests/mod.rs
@@ -1,13 +1,6 @@
 pub mod accuracy_empirical_validation_tests;
 pub mod accuracy_in_promql_response_tests;
 pub mod capability_miss_http_e2e_tests;
-// M2.3.6g — legacy SketchStore-specific suites retired:
-// persist_format_versioning_tests, persistence_integration_tests,
-// persistence_perf_tests, store_correctness_tests.
-// B7.5 retirement — `capability_matching_tests` and
-// `schema_timeline_dispatch_tests` exercised the now-deleted
-// legacy `build_query_execution_context_promql` /
-// `handle_query_promql` paths; removed alongside the engine fns.
 pub mod prometheus_forwarding_tests;
 pub mod trait_design_tests;
 
diff --git a/data_plane/src/tests/test_utilities/engine_factories.rs b/data_plane/src/tests/test_utilities/engine_factories.rs
index b5daec83c..203330293 100644
--- a/data_plane/src/tests/test_utilities/engine_factories.rs
+++ b/data_plane/src/tests/test_utilities/engine_factories.rs
@@ -148,22 +148,8 @@ pub fn create_engine_single_pop_with_aggregated(
     ASAPQueryEngine::new(1).with_sketch_index(sketch_index)
 }
 
-/// Creates a ASAPQueryEngine with dual-input (separate value and keys
-/// aggregations). Currently dead code — the only historical caller
-/// exercised the retired `SetAggregator` / `DeltaSetAggregator`
-/// key-tracking pair. Retained as a builder utility for future
-/// dual-input shapes (e.g. HydraKLL value + a not-yet-defined key
-/// aggregation); delete if no caller materialises.
-///
-/// # Arguments
-/// * `metric` - Metric name
-/// * `value_agg_type` - Accumulator type for values
-/// * `key_agg_type` - Accumulator type for keys
-/// * `grouping_labels` - Store GROUP BY columns
-/// * `aggregated_labels` - Labels that key the accumulator internally
-/// * `value_data` - Data for value aggregation (agg_id=1)
-/// * `keys_data` - Data for keys aggregation (agg_id=2)
-/// * `promql_query` - The PromQL query string
+/// Build a test engine with separate value and key aggregations. Each input
+/// carries its own accumulator type, labels, and samples.
 #[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub fn create_engine_dual_input(
diff --git a/data_plane/src/tests/test_utilities/mod.rs b/data_plane/src/tests/test_utilities/mod.rs
index 2f48c9da9..824a72884 100644
--- a/data_plane/src/tests/test_utilities/mod.rs
+++ b/data_plane/src/tests/test_utilities/mod.rs
@@ -1,10 +1,4 @@
-//! Test utilities for query equivalence testing
-//!
-//! Provides engine-construction helpers shared by the surviving
-//! capability-miss + asap-tier integration tests. The
-//! `comparison.rs` module was retired with B7.5 because it
-//! reached into the now-deleted `QueryExecutionContext` /
-//! `StoreQueryPlan` legacy types.
+//! Engine-construction helpers shared by capability-miss and ASAP-tier tests.
 
 pub mod engine_factories;
 pub mod timing;

From fdd67be33be57c2406fc5e968bf58fabbb4f36b2 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Sun, 13 Sep 2026 10:30:09 -0600
Subject: [PATCH 2/4] refactor: unify HTTP query adapter traits

---
 .../src/drivers/query/adapters/factory.rs     |  12 --
 data_plane/src/drivers/query/adapters/mod.rs  |   4 +-
 .../drivers/query/adapters/prometheus_http.rs |  12 +-
 .../src/drivers/query/adapters/traits.rs      |  21 +-
 .../query/adapters/victoriametrics_http.rs    |  10 +-
 data_plane/src/drivers/query/mod.rs           |   2 +-
 data_plane/src/drivers/query/servers/http.rs  | 180 +++++-------------
 7 files changed, 56 insertions(+), 185 deletions(-)
 delete mode 100644 data_plane/src/drivers/query/adapters/factory.rs

diff --git a/data_plane/src/drivers/query/adapters/factory.rs b/data_plane/src/drivers/query/adapters/factory.rs
deleted file mode 100644
index e41518ff2..000000000
--- a/data_plane/src/drivers/query/adapters/factory.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use super::config::AdapterConfig;
-use super::prometheus_http::PrometheusHttpAdapter;
-use super::traits::HttpProtocolAdapter;
-use crate::storage_engines::types::enums::QueryProtocol;
-use std::sync::Arc;
-
-/// Factory function to create appropriate HTTP adapter based on protocol
-pub fn create_http_adapter(config: AdapterConfig) -> Arc<dyn HttpProtocolAdapter> {
-    match config.protocol {
-        QueryProtocol::PrometheusHttp => Arc::new(PrometheusHttpAdapter::new(config)),
-    }
-}
diff --git a/data_plane/src/drivers/query/adapters/mod.rs b/data_plane/src/drivers/query/adapters/mod.rs
index 59f623a4a..7061c2825 100644
--- a/data_plane/src/drivers/query/adapters/mod.rs
+++ b/data_plane/src/drivers/query/adapters/mod.rs
@@ -1,15 +1,13 @@
 pub mod config;
-pub mod factory;
 pub mod prometheus_http;
 pub mod traits;
 pub mod victoriametrics_http;
 
 // Re-export main types
 pub use config::AdapterConfig;
-pub use factory::create_http_adapter;
 pub use prometheus_http::{PrometheusHttpAdapter, PrometheusResponse};
 pub use traits::{
     AdapterError, HttpProtocolAdapter, ParsedQueryRequest, ParsedRangeQueryRequest,
-    QueryExecutionResult, QueryRequestAdapter, QueryResponseAdapter,
+    QueryExecutionResult,
 };
 pub use victoriametrics_http::VictoriaMetricsHttpAdapter;
diff --git a/data_plane/src/drivers/query/adapters/prometheus_http.rs b/data_plane/src/drivers/query/adapters/prometheus_http.rs
index 76b298bd7..fb1a296bb 100644
--- a/data_plane/src/drivers/query/adapters/prometheus_http.rs
+++ b/data_plane/src/drivers/query/adapters/prometheus_http.rs
@@ -216,7 +216,7 @@ impl PrometheusHttpAdapter {
 }
 
 #[async_trait]
-impl QueryRequestAdapter for PrometheusHttpAdapter {
+impl HttpProtocolAdapter for PrometheusHttpAdapter {
     async fn parse_get_request(
         &self,
         Query(params): Query<HashMap<String, String>>,
@@ -268,10 +268,7 @@ impl QueryRequestAdapter for PrometheusHttpAdapter {
     fn get_range_query_endpoint(&self) -> &'static str {
         "/api/v1/query_range"
     }
-}
 
-#[async_trait]
-impl QueryResponseAdapter for PrometheusHttpAdapter {
     async fn format_success_response(
         &self,
         result: &QueryExecutionResult,
@@ -354,10 +351,7 @@ impl QueryResponseAdapter for PrometheusHttpAdapter {
         let response = PrometheusResponse::error("bad_data", "No result for query");
         Ok(Json(serde_json::to_value(response).unwrap()).into_response())
     }
-}
 
-#[async_trait]
-impl HttpProtocolAdapter for PrometheusHttpAdapter {
     fn query_language(&self) -> asap_types::QueryLanguage {
         asap_types::QueryLanguage::PromQl
     }
@@ -376,9 +370,7 @@ impl HttpProtocolAdapter for PrometheusHttpAdapter {
     ) -> Result<Json<Value>, StatusCode> {
         debug!("Handling runtime info request in Prometheus adapter");
 
-        // M2.3.6g — earliest timestamps now come from SketchStore's
-        // per-sid `first_seen_unix_ms` metadata. Wire field renamed
-        // accordingly below.
+        // Read first-seen timestamps from per-sid metadata for runtime diagnostics.
         let earliest_timestamps = sketch_index.earliest_timestamps_per_series_id();
 
         // Get runtime info from fallback if available
diff --git a/data_plane/src/drivers/query/adapters/traits.rs b/data_plane/src/drivers/query/adapters/traits.rs
index b96058a48..e4ac075de 100644
--- a/data_plane/src/drivers/query/adapters/traits.rs
+++ b/data_plane/src/drivers/query/adapters/traits.rs
@@ -62,10 +62,10 @@ impl std::fmt::Display for AdapterError {
 
 impl std::error::Error for AdapterError {}
 
-/// Trait for parsing incoming HTTP requests into internal query format
-/// Handles Axum extractors directly for different request types (GET/POST)
+/// HTTP query parsing, response formatting, and listener identity.
+/// Fallback transport is handled separately by `FallbackClient`.
 #[async_trait]
-pub trait QueryRequestAdapter: Send + Sync {
+pub trait HttpProtocolAdapter: Send + Sync {
     /// Parse a GET request with query parameters
     async fn parse_get_request(
         &self,
@@ -107,11 +107,7 @@ pub trait QueryRequestAdapter: Send + Sync {
 
     /// Get the HTTP path for range queries (e.g., "/api/v1/query_range")
     fn get_range_query_endpoint(&self) -> &'static str;
-}
 
-/// Trait for formatting query results into protocol-specific HTTP responses
-#[async_trait]
-pub trait QueryResponseAdapter: Send + Sync {
     /// Format a successful query result into protocol response
     async fn format_success_response(
         &self,
@@ -130,13 +126,7 @@ pub trait QueryResponseAdapter: Send + Sync {
 
     /// Format an error when query returns None (unsupported query)
     async fn format_unsupported_query_response(&self) -> Result<Response, StatusCode>;
-}
 
-/// Adapter trait for HTTP-based query protocols (Prometheus HTTP).
-///
-/// Note: Fallback logic is handled separately via FallbackClient
-#[async_trait]
-pub trait HttpProtocolAdapter: QueryRequestAdapter + QueryResponseAdapter + Send + Sync {
     /// Query language accepted at this listener boundary.
     fn query_language(&self) -> asap_types::QueryLanguage;
 
@@ -158,9 +148,6 @@ pub trait HttpProtocolAdapter: QueryRequestAdapter + QueryResponseAdapter + Send
     ///
     /// The adapter can query the SketchStore for internal metrics and
     /// optionally forward to fallback backend for additional info.
-    /// M2.3.6g — switched from `Arc<dyn Store>` to
-    /// `Arc<SketchStore>` now that SketchStore is the only data
-    /// backend.
     async fn handle_runtime_info(
         &self,
         sketch_index: std::sync::Arc<crate::storage_engines::sketch_db::index::SketchStore>,
@@ -171,7 +158,7 @@ pub trait HttpProtocolAdapter: QueryRequestAdapter + QueryResponseAdapter + Send
         sketch_index: std::sync::Arc<crate::storage_engines::sketch_db::index::SketchStore>,
         headers: HashMap<String, String>,
     ) -> Result<Json<Value>, StatusCode> {
-        // Default implementation ignores headers and calls the old method
+        // Adapters may override this to forward request headers.
         let _ = headers;
         self.handle_runtime_info(sketch_index).await
     }
diff --git a/data_plane/src/drivers/query/adapters/victoriametrics_http.rs b/data_plane/src/drivers/query/adapters/victoriametrics_http.rs
index e23cf4a9b..c2c1e756b 100644
--- a/data_plane/src/drivers/query/adapters/victoriametrics_http.rs
+++ b/data_plane/src/drivers/query/adapters/victoriametrics_http.rs
@@ -1,6 +1,6 @@
 use super::{
     AdapterConfig, AdapterError, HttpProtocolAdapter, ParsedQueryRequest, ParsedRangeQueryRequest,
-    PrometheusHttpAdapter, QueryExecutionResult, QueryRequestAdapter, QueryResponseAdapter,
+    PrometheusHttpAdapter, QueryExecutionResult,
 };
 use asap_types::KeyByLabelNames;
 use async_trait::async_trait;
@@ -30,7 +30,7 @@ impl VictoriaMetricsHttpAdapter {
 }
 
 #[async_trait]
-impl QueryRequestAdapter for VictoriaMetricsHttpAdapter {
+impl HttpProtocolAdapter for VictoriaMetricsHttpAdapter {
     async fn parse_get_request(
         &self,
         params: Query<HashMap<String, String>>,
@@ -67,10 +67,7 @@ impl QueryRequestAdapter for VictoriaMetricsHttpAdapter {
     fn get_range_query_endpoint(&self) -> &'static str {
         "/api/v1/query_range"
     }
-}
 
-#[async_trait]
-impl QueryResponseAdapter for VictoriaMetricsHttpAdapter {
     async fn format_success_response(
         &self,
         result: &QueryExecutionResult,
@@ -92,10 +89,7 @@ impl QueryResponseAdapter for VictoriaMetricsHttpAdapter {
     async fn format_unsupported_query_response(&self) -> Result<Response, StatusCode> {
         self.wire.format_unsupported_query_response().await
     }
-}
 
-#[async_trait]
-impl HttpProtocolAdapter for VictoriaMetricsHttpAdapter {
     fn query_language(&self) -> asap_types::QueryLanguage {
         asap_types::QueryLanguage::MetricsQl
     }
diff --git a/data_plane/src/drivers/query/mod.rs b/data_plane/src/drivers/query/mod.rs
index b7a0c1f9d..04f96ea91 100644
--- a/data_plane/src/drivers/query/mod.rs
+++ b/data_plane/src/drivers/query/mod.rs
@@ -3,6 +3,6 @@ pub mod fallback;
 pub mod servers;
 
 // Re-export commonly used types for convenience
-pub use adapters::{create_http_adapter, AdapterConfig, HttpProtocolAdapter};
+pub use adapters::{AdapterConfig, HttpProtocolAdapter};
 pub use fallback::FallbackClient;
 pub use servers::{HttpServer, HttpServerConfig};
diff --git a/data_plane/src/drivers/query/servers/http.rs b/data_plane/src/drivers/query/servers/http.rs
index bd4037af5..a5df79c2e 100644
--- a/data_plane/src/drivers/query/servers/http.rs
+++ b/data_plane/src/drivers/query/servers/http.rs
@@ -14,7 +14,7 @@ use std::time::{Duration, Instant};
 use tokio::net::TcpListener;
 use tracing::{debug, info, warn};
 
-use crate::drivers::query::adapters::{create_http_adapter, AdapterConfig, HttpProtocolAdapter};
+use crate::drivers::query::adapters::{AdapterConfig, HttpProtocolAdapter, PrometheusHttpAdapter};
 use crate::drivers::query::servers::metrics as srv_metrics;
 use crate::query_engines::routing::{
     AccuracyTarget, EngineRouter, EngineRouterError, FreshnessProbeCache, QueryEngine,
@@ -145,7 +145,7 @@ pub struct HttpServer {
     /// `KeyByLabelNames` Prometheus needs to populate the `metric`
     /// map. See `docs/design-gorilla-s3-cold-engine.md` §8.
     query_router: Arc<EngineRouter>,
-    /// M2.3.6g — SketchStore replaces `Arc<dyn Store>`.
+    /// Sketch storage for runtime diagnostics.
     sketch_index: Arc<crate::storage_engines::sketch_db::index::SketchStore>,
     /// Hot-reloadable `StreamingConfig` source. `None` when hot-reload
     /// is not wired up by the caller (unit tests, legacy binaries).
@@ -161,19 +161,16 @@ pub struct HttpServer {
     /// [`Self::with_backend_storage_routing`]; production deploys
     /// bootstrap from `deploy/configs/backend-storage-routing.yaml`
     /// (legacy form) or the control plane's first
-    /// `POST /api/v1/storage_routing` push (Phase α).
+    /// `POST /api/v1/storage_routing` push.
     ///
-    /// Phase α: this field is now a `HotReloadBackendStorageRouting`
+    /// `HotReloadBackendStorageRouting` is an atomic routing snapshot
     /// — an `ArcSwap`-backed wrapper that supports atomic at-runtime
     /// swap from the `POST /api/v1/storage_routing` endpoint. The
     /// existing read path snapshots the wrapper once per request
     /// (`handle.snapshot().lookup_with_shape(...)`); swap is observed
     /// by the next request without restart.
     backend_storage_routing: Option<crate::query_engines::routing::HotReloadBackendStorageRouting>,
-    /// Backfill registry (sketch DB §10). `None` until Phase 5e
-    /// wires a worker pool; in the interim, jobs created via the
-    /// HTTP endpoints stay `Queued` and are visible via the list
-    /// endpoint — useful shadow-mode testing before workers exist.
+    /// Backfill registry shared with the worker and HTTP job endpoints.
     backfill: Option<Arc<crate::storage_engines::sketch_db::BackfillRegistry>>,
     /// SketchStore data-retention horizon in millis, mirroring
     /// `--persistence-delete-older-than-secs` at the CLI. Used by the
@@ -205,9 +202,7 @@ struct AppState {
     query_engine: Arc<ASAPQueryEngine>,
     /// See [`HttpServer::query_router`].
     query_router: Arc<EngineRouter>,
-    /// Phase 5 M2.3.6g — SketchStore replaces `Arc<dyn Store>` as the
-    /// only data backend HTTP-side endpoints consult. Today the only
-    /// consumer is the runtime-info handler.
+    /// Attach sketch storage for HTTP runtime diagnostics.
     sketch_index: Arc<crate::storage_engines::sketch_db::index::SketchStore>,
     adapter: Arc<dyn HttpProtocolAdapter>,
     fallback: Option<Arc<dyn crate::drivers::query::fallback::FallbackClient>>,
@@ -333,7 +328,7 @@ impl HttpServer {
 
     /// Attach a per-metric storage-backend routing table. The table is
     /// wrapped in a hot-reload handle internally so the
-    /// `POST /api/v1/storage_routing` endpoint (Phase α) can swap it
+    /// `POST /api/v1/storage_routing` endpoint can swap it
     /// atomically without restart.
     ///
     /// Bootstrap typically comes from
@@ -357,7 +352,7 @@ impl HttpServer {
         self
     }
 
-    /// Phase α (MVP): attach a pre-built hot-reload routing handle.
+    /// Attach a pre-built hot-reload routing handle.
     /// Used by callers that want to share the same handle with other
     /// subsystems (e.g. the query-router for diagnostics) — the
     /// `with_backend_storage_routing` builder is the simpler entry
@@ -372,10 +367,8 @@ impl HttpServer {
     }
 
     /// Attach a `BackfillRegistry` so the `/api/v1/db/backfill`
-    /// HTTP endpoints (Phase 5d) can create and inspect jobs. Jobs
-    /// stay `Queued` until Phase 5e's worker pool is wired; the
-    /// endpoints are still useful for shadow-mode validation of the
-    /// control plane's REFRESH dispatch logic.
+    /// HTTP endpoints can create and inspect jobs. Jobs
+    /// remain `Queued` unless a backfill worker is enabled.
     pub fn with_backfill_registry(
         mut self,
         registry: Arc<crate::storage_engines::sketch_db::BackfillRegistry>,
@@ -412,11 +405,11 @@ impl HttpServer {
     pub async fn run(self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         srv_metrics::register_all();
 
-        // Create adapter using factory
-        let adapter = self
-            .adapter_override
-            .clone()
-            .unwrap_or_else(|| create_http_adapter(self.config.adapter_config.clone()));
+        let adapter = self.adapter_override.clone().unwrap_or_else(|| {
+            Arc::new(PrometheusHttpAdapter::new(
+                self.config.adapter_config.clone(),
+            ))
+        });
 
         let query_endpoint = adapter.get_query_endpoint();
         let runtime_info_path = adapter.get_runtime_info_path();
@@ -482,7 +475,7 @@ impl HttpServer {
                 get(handle_physical_plan_status),
             )
             .route("/api/v1/summary-inventory", get(handle_summary_inventory))
-            // Phase α (MVP): control-plane-pushed `BackendStorageRouting`
+            // control-plane-pushed `BackendStorageRouting`
             // table. POST replaces the current table atomically; GET
             // returns a JSON snapshot for operator diagnostics.
             .route(
@@ -546,11 +539,11 @@ impl HttpServer {
     /// make the testing intent explicit; production callers should use
     /// the regular `start()` method.
     pub async fn start_test_server(&self) -> Result<u16, Box<dyn std::error::Error + Send + Sync>> {
-        // Create adapter using factory
-        let adapter = self
-            .adapter_override
-            .clone()
-            .unwrap_or_else(|| create_http_adapter(self.config.adapter_config.clone()));
+        let adapter = self.adapter_override.clone().unwrap_or_else(|| {
+            Arc::new(PrometheusHttpAdapter::new(
+                self.config.adapter_config.clone(),
+            ))
+        });
 
         let query_endpoint = adapter.get_query_endpoint();
         let runtime_info_path = adapter.get_runtime_info_path();
@@ -608,7 +601,7 @@ impl HttpServer {
                 get(handle_physical_plan_status),
             )
             .route("/api/v1/summary-inventory", get(handle_summary_inventory))
-            // Phase α (MVP): control-plane-pushed `BackendStorageRouting`
+            // control-plane-pushed `BackendStorageRouting`
             // table. POST replaces the current table atomically; GET
             // returns a JSON snapshot for operator diagnostics.
             .route(
@@ -714,12 +707,6 @@ async fn process_query_request(
         }
     }
 
-    // (Phase γ: legacy in-backend query tracker removed — the
-    // ASAPCollector controller now observes queries via its own
-    // PromQL scrape side-channel and pushes plans / routing tables
-    // back to the backend. See README "post-consolidation backend
-    // scope" prose.)
-
     // Phase-6 Fix 1: per-query engine override.
     //
     // If the caller explicitly named an engine (via `X-ASAP-Engine`
@@ -883,7 +870,7 @@ fn resolve_metric_storage(state: &AppState, query: &str, tenant: &str) -> Storag
     }
 
     if let Some(routing_handle) = state.backend_storage_routing.as_ref() {
-        // Phase α: snapshot the hot-reload handle once per request,
+        // snapshot the hot-reload handle once per request,
         // scoped to this request's tenant. The snapshot resolves to
         // the named tenant's table when present, else the
         // `default` tenant's table. Concurrent per-tenant swaps from
@@ -1272,19 +1259,9 @@ fn parse_last_over_time_probe(query: &str) -> Option<(String, i64)> {
     Some((metric, range_ms))
 }
 
-/// Direct `ASAPQueryEngine::execute(&str)` dispatch — B7.5 retired
-/// the legacy `handle_query` path; this handler is now a thin
-/// wrapper around the modern `QueryEngine::execute(&str)` trait
-/// surface, which classifies via the analyzer + ASAP-tier reducer
-/// and fires capability-miss notifies natively. Adds a
-/// `data_source: asap_query` info-line at the JSON layer so Phase-6
-/// callers can byte-compare regardless of the dispatch path.
-///
-/// Trait dispatch loses `KeyByLabelNames` (the trait returns just
-/// `QueryResult`); we surface an empty `KeyByLabelNames`, identical
-/// to how `process_via_router` handles the same trait surface — the
-/// Prometheus adapter renders an empty `metric: {}` object, a valid
-/// shape that PromQL clients accept.
+/// Execute through the query-engine trait and add `data_source: asap_query`
+/// to the HTTP response. Trait results use the same label adaptation as
+/// router dispatch.
 async fn process_via_simple_engine(
     state: &AppState,
     parsed_request: &ParsedQueryRequest,
@@ -2264,9 +2241,6 @@ async fn process_range_query_request(
         };
     }
 
-    // (Phase γ: legacy in-backend query tracker removed — see
-    // companion comment in `handle_instant_query`.)
-
     // Execute range query with engine
     let query_start_time = Instant::now();
     debug!(
@@ -3652,19 +3626,11 @@ aggregations:
         assert_eq!(body["segments"].as_array().unwrap().len(), 0);
     }
 
-    // ─── Phase 5d: backfill HTTP endpoint tests ─────────────────────────────
+    // ─── backfill HTTP endpoint tests ─────────────────────────────
 
-    /// Build a test server wired with a backfill registry and a sid
-    /// catalog that pre-registers the listed sids as Active.
-    /// `POST /api/v1/db/backfill` runs `create_checked`, which after
-    /// the schema retirement final cut is expected to accept the sid
-    /// catalog (sibling slice migrates `create_checked`'s signature).
-    ///
-    /// PR 5: `active_agg_ids` is now a list of test markers used to
-    /// build per-metric configs (`metric_{marker}`). The streaming
-    /// config is keyed on each config's policy fingerprint; the
-    /// returned vector lets callers translate marker→fingerprint so
-    /// HTTP POSTs target the right agg_id on the wire.
+    /// Build a server with a backfill registry and active sid fixtures. Test
+    /// markers generate per-metric configs; the returned fingerprints let callers
+    /// target those configs through HTTP.
     async fn setup_test_server_with_backfill_and_sids(
         registry: Arc<crate::storage_engines::sketch_db::BackfillRegistry>,
         active_agg_ids: &[u64],
@@ -4007,15 +3973,8 @@ aggregations:
         assert_eq!(resp.status(), reqwest::StatusCode::CONFLICT);
     }
 
-    // ── Phase-6 follow-up: EngineRouter wired into the HTTP query path ──────
-    //
-    // These tests cover the deliverable in the
-    // `feat/http-server-wire-engine-router` PR — every query that
-    // arrives through `/api/v1/query` now consults the
-    // `StreamingConfig::storage_backend()` axis and dispatches via the
-    // `EngineRouter` for non-ASAP-tier metrics. The wire response
-    // carries a `data_source: <id>` info-line so dashboards / e2e
-    // tests can byte-compare which engine answered.
+    // HTTP routing tests verify configured engine dispatch and the response
+    // `data_source` annotation.
 
     use crate::query_engines::routing::{EngineCapabilities, QueryEngine};
     use crate::query_engines::{EngineError, QueryResult};
@@ -4391,22 +4350,8 @@ aggregations:
 
     #[tokio::test]
     async fn http_returns_503_when_no_engines_registered() {
-        // Pin `storage_backend = PrometheusRemote` but register no
-        // Prometheus forwarder (only `ASAPQueryEngine` is registered
-        // under `asap_query`). The router walks
-        // `compatible_storage_backends = [PrometheusRemote]` and bails
-        // out with `NoEngineRegistered`, which the HTTP layer surfaces
-        // as 503.
-        //
-        // ASAP-first refactor note: this test used to pin
-        // `GorillaObjectStore` and rely on the old archive-only
-        // `[GorillaObjectStore]` sequence. Under the ASAP-first policy
-        // a `GorillaObjectStore` metric now resolves to
-        // `[SketchStore, GorillaObjectStore]` — the registered
-        // ASAP engine is tried first and CapabilityMisses, yielding a
-        // 404 (`AllFailed`) rather than a 503. `PrometheusRemote` keeps
-        // its single-backend slot, so it remains the canonical "engine
-        // missing → 503" path.
+        // PrometheusRemote has one eligible backend. Without its engine registered,
+        // the router must return `NoEngineRegistered`, surfaced as HTTP 503.
         let server_port =
             setup_test_server_with_empty_router(StorageBackend::PrometheusRemote).await;
         let client = Client::new();
@@ -5071,7 +5016,7 @@ aggregations:
         assert_eq!(gorilla_calls.load(Ordering::SeqCst), 1);
     }
 
-    // ── Phase α: BackendStorageRouting hot-reload HTTP integration ────
+    // ── BackendStorageRouting hot-reload HTTP integration ────
 
     /// Standard test wiring for the `/api/v1/storage_routing` endpoint:
     /// install an empty hot-reload routing handle, hold the handle so
@@ -5985,8 +5930,7 @@ async fn handle_store_metrics(State(state): State<AppState>) -> axum::response::
     use axum::http::StatusCode;
     use axum::response::IntoResponse;
 
-    // M2.3.6g — earliest timestamps come from SketchStore's per-sid
-    // `first_seen_unix_ms` metadata. Always succeeds (no I/O).
+    // Per-sid first-seen timestamps are available without I/O.
     let timestamps = state.sketch_index.earliest_timestamps_per_series_id();
     let body = serde_json::json!({
         "status": "success",
@@ -5996,20 +5940,9 @@ async fn handle_store_metrics(State(state): State<AppState>) -> axum::response::
     (StatusCode::OK, axum::Json(body)).into_response()
 }
 
-// ─── StreamingConfig hot-reload (PR E) ───────────────────────────────────
-//
-// `GET /api/v1/streaming-config`  — return the currently active config
-//                                   as JSON (debug / verification).
-// `POST /api/v1/streaming-config` — accept a YAML body, parse, and
-//                                   atomically swap via ArcSwap.
-//
-// Phase 1 scope: the swap only takes effect for new readers that
-// snapshot after the swap. `ASAPQueryEngine`, the ingest router, and
-// in-flight precompute workers all hold startup snapshots today and
-// ignore the swap until they are rebuilt — see the module doc on
-// `HotReloadStreamingConfig` for the full contract. Tests POST a new
-// config and verify it via the GET endpoint; control plane integration
-// and per-query re-snapshot are phase 2.
+// Streaming configuration endpoints: GET returns the active snapshot; POST
+// parses a replacement and atomically publishes it to new snapshot readers.
+// In-flight operations retain their existing snapshot.
 
 async fn handle_get_streaming_config(State(state): State<AppState>) -> axum::response::Response {
     use axum::http::StatusCode;
@@ -6511,7 +6444,7 @@ fn unix_time_ms() -> u64 {
         .as_millis() as u64
 }
 
-// ── Phase α: BackendStorageRouting hot-reload endpoints ────────────
+// ── BackendStorageRouting hot-reload endpoints ────────────
 
 /// `GET /api/v1/storage_routing` — return a JSON snapshot of the
 /// currently-active per-metric `BackendStorageRouting` table.
@@ -6645,16 +6578,8 @@ async fn handle_post_storage_routing(
     (StatusCode::OK, axum::Json(body)).into_response()
 }
 
-/// §15.2 of the sketch DB design: expose the sid catalog over HTTP so
-/// operators and the control plane can inspect aggregation lifecycle
-/// state without attaching a debugger. Filter by `?status=` —
-/// `active` / `retired` / `expired` / `all` (default `all`).
-///
-/// Route is kept at the historical `/api/v1/db/schemas` path so
-/// external callers don't break; the response now surfaces the
-/// sid-level [`SketchInstanceMetadata`] entries (with field `sid`
-/// instead of `agg_id`) since the per-agg_id `SchemaRegistry` has
-/// been retired.
+/// Expose sid metadata at `/api/v1/db/schemas` for API compatibility.
+/// Filter with `status=active|retired|expired|all` (default `all`).
 async fn handle_get_schemas(
     State(state): State<AppState>,
     axum::extract::Query(params): axum::extract::Query<std::collections::HashMap<String, String>>,
@@ -6707,11 +6632,7 @@ fn status_str(s: crate::storage_engines::sketch_db::AggStatus) -> &'static str {
     }
 }
 
-/// JSON encoding of a single sid registry entry, replacing the legacy
-/// `schema_to_json(&AggSchema)`. The field set mirrors the schema
-/// shape where it makes sense — `status`, `retired_at_ms`,
-/// `expires_at_ms`, `metric_name` — and adds the sid-native fields
-/// (`sid`, `group_by_keys`, `agg_kind`, `first_seen_unix_ms`).
+/// Encode sid metadata, including identity, lifecycle timestamps, and status.
 fn sid_instance_to_json(
     m: &crate::storage_engines::sketch_db::index::SketchInstanceMetadata,
     descriptors: Option<&(
@@ -6971,18 +6892,9 @@ async fn handle_post_backfill_job(
         return (StatusCode::BAD_REQUEST, axum::Json(body)).into_response();
     }
 
-    // Schema retirement final cut: the legacy `SchemaRegistry` is
-    // gone. `create_checked` now takes the `AggregationConfig`
-    // directly + an explicit `created_at_ms`. We look up the
-    // config from the streaming-config snapshot; if it's missing
-    // we surface the same 404 `UnknownAgg` the registry used to
-    // produce. `created_at_ms` is the earliest `first_seen_unix_ms`
-    // across the sid catalog for this agg-config's signature —
-    // the post-retirement analogue of `AggSchema.created_at_ms`
-    // (which tracked wall-clock when the agg first appeared in a
-    // streaming-config swap). If no sid has ingested for this
-    // config yet, fall back to wall-clock now so the time-disjoint
-    // invariant degrades to "live ingest hasn't started".
+    // Resolve the aggregation from the current streaming-config snapshot, or
+    // return 404 `UnknownAgg`. Its earliest matching sid timestamp bounds the
+    // backfill range; with no ingested sid, use the current time.
     let Some(handle) = state.hot_reload_config.as_ref() else {
         let body = serde_json::json!({
             "status": "error",

From 236fec6b59cd8180d29db85add1a191f018fdcc4 Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Sun, 13 Sep 2026 10:30:09 -0600
Subject: [PATCH 3/4] refactor: remove unused accumulator factories

---
 data_plane/src/lib.rs                         |  7 +-
 .../operators/increase_accumulator.rs         | 42 +----------
 .../operators/min_max_accumulator.rs          | 70 +------------------
 .../operators/multiple_sum_accumulator.rs     | 34 +--------
 .../operators/sum_accumulator.rs              | 35 +---------
 .../src/storage_engines/types/traits.rs       | 30 --------
 6 files changed, 7 insertions(+), 211 deletions(-)

diff --git a/data_plane/src/lib.rs b/data_plane/src/lib.rs
index 1273bbc0a..9feffede1 100644
--- a/data_plane/src/lib.rs
+++ b/data_plane/src/lib.rs
@@ -36,10 +36,9 @@ pub mod utils;
 
 // Re-export commonly used types to avoid glob import conflicts
 pub use storage_engines::types::{
-    AccumulatorFactory, AggregateCore, AggregationConfig, KeyByLabelValues, Measurement,
-    MergeableAccumulator, MultipleSubpopulationAggregate, MultipleSubpopulationAggregateFactory,
-    PrecomputedOutput, SerializableToSink, SingleSubpopulationAggregate,
-    SingleSubpopulationAggregateFactory,
+    AggregateCore, AggregationConfig, KeyByLabelValues, Measurement, MergeableAccumulator,
+    MultipleSubpopulationAggregate, PrecomputedOutput, SerializableToSink,
+    SingleSubpopulationAggregate,
 };
 
 pub use precompute_engine::operators::{
diff --git a/data_plane/src/precompute_engine/operators/increase_accumulator.rs b/data_plane/src/precompute_engine/operators/increase_accumulator.rs
index a20d05ef5..421feaa4d 100644
--- a/data_plane/src/precompute_engine/operators/increase_accumulator.rs
+++ b/data_plane/src/precompute_engine/operators/increase_accumulator.rs
@@ -1,6 +1,6 @@
 use crate::storage_engines::types::{
     AggregateCore, AggregationType, Measurement, MergeableAccumulator, SerializableToSink,
-    SingleSubpopulationAggregate, SingleSubpopulationAggregateFactory,
+    SingleSubpopulationAggregate,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -488,46 +488,6 @@ impl IncreaseAccumulator {
     }
 }
 
-pub struct IncreaseAccumulatorFactory;
-
-impl SingleSubpopulationAggregateFactory for IncreaseAccumulatorFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn SingleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn SingleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>
-    {
-        let mut concrete_accumulators = Vec::new();
-
-        for acc in accumulators {
-            if let Some(concrete) = acc.as_any().downcast_ref::<IncreaseAccumulator>() {
-                concrete_accumulators.push(concrete.clone());
-            } else {
-                return Err("Type mismatch in merge operation".into());
-            }
-        }
-
-        if concrete_accumulators.is_empty() {
-            return Err("No accumulators to merge".into());
-        }
-
-        let merged =
-            <IncreaseAccumulator as MergeableAccumulator<IncreaseAccumulator>>::merge_accumulators(
-                concrete_accumulators,
-            )
-            .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { format!("{e}").into() })?;
-        Ok(Box::new(merged))
-    }
-
-    fn create_default(&self) -> Box<dyn SingleSubpopulationAggregate> {
-        Box::new(IncreaseAccumulator::new(
-            Measurement::new(0.0),
-            0,
-            Measurement::new(0.0),
-            0,
-        ))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/data_plane/src/precompute_engine/operators/min_max_accumulator.rs b/data_plane/src/precompute_engine/operators/min_max_accumulator.rs
index 4111f4ce9..dbf7ed92d 100644
--- a/data_plane/src/precompute_engine/operators/min_max_accumulator.rs
+++ b/data_plane/src/precompute_engine/operators/min_max_accumulator.rs
@@ -1,6 +1,6 @@
 use crate::storage_engines::types::{
     AggregateCore, AggregationType, AuxStats, MergeableAccumulator, SerializableToSink,
-    SingleSubpopulationAggregate, SingleSubpopulationAggregateFactory,
+    SingleSubpopulationAggregate,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -260,74 +260,6 @@ impl SingleSubpopulationAggregate for MinMaxAccumulator {
     }
 }
 
-// Factory implementation for merging
-pub struct MinMaxAccumulatorFactory {
-    pub sub_type: String,
-}
-
-impl MinMaxAccumulatorFactory {
-    pub fn new_min() -> Self {
-        Self {
-            sub_type: "min".to_string(),
-        }
-    }
-
-    pub fn new_max() -> Self {
-        Self {
-            sub_type: "max".to_string(),
-        }
-    }
-}
-
-impl SingleSubpopulationAggregateFactory for MinMaxAccumulatorFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn SingleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn SingleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>
-    {
-        if accumulators.is_empty() {
-            return match self.sub_type.as_str() {
-                "min" => Ok(Box::new(MinMaxAccumulator::new_min())),
-                "max" => Ok(Box::new(MinMaxAccumulator::new_max())),
-                _ => Err(format!("Unsupported sub_type: {}", self.sub_type).into()),
-            };
-        }
-
-        let mut result_value = match self.sub_type.as_str() {
-            "min" => f64::INFINITY,
-            "max" => f64::NEG_INFINITY,
-            _ => return Err(format!("Unsupported sub_type: {}", self.sub_type).into()),
-        };
-
-        for acc in accumulators {
-            let value = match self.sub_type.as_str() {
-                "min" => acc.query(Statistic::Min, None)?,
-                "max" => acc.query(Statistic::Max, None)?,
-                _ => return Err(format!("Unsupported sub_type: {}", self.sub_type).into()),
-            };
-
-            result_value = match self.sub_type.as_str() {
-                "min" => result_value.min(value),
-                "max" => result_value.max(value),
-                _ => return Err(format!("Unsupported sub_type: {}", self.sub_type).into()),
-            };
-        }
-
-        Ok(Box::new(MinMaxAccumulator::with_value(
-            result_value,
-            self.sub_type.clone(),
-        )))
-    }
-
-    fn create_default(&self) -> Box<dyn SingleSubpopulationAggregate> {
-        match self.sub_type.as_str() {
-            "min" => Box::new(MinMaxAccumulator::new_min()),
-            "max" => Box::new(MinMaxAccumulator::new_max()),
-            _ => Box::new(MinMaxAccumulator::new_min()), // Default fallback
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/data_plane/src/precompute_engine/operators/multiple_sum_accumulator.rs b/data_plane/src/precompute_engine/operators/multiple_sum_accumulator.rs
index c20a4c8f3..5b7e1011a 100644
--- a/data_plane/src/precompute_engine/operators/multiple_sum_accumulator.rs
+++ b/data_plane/src/precompute_engine/operators/multiple_sum_accumulator.rs
@@ -1,6 +1,6 @@
 use crate::storage_engines::types::{
     AggregateCore, AggregationType, KeyByLabelValues, MergeableAccumulator,
-    MultipleSubpopulationAggregate, MultipleSubpopulationAggregateFactory, SerializableToSink,
+    MultipleSubpopulationAggregate, SerializableToSink,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -250,38 +250,6 @@ impl MultipleSubpopulationAggregate for MultipleSumAccumulator {
     }
 }
 
-// Factory implementation for merging
-pub struct MultipleSumAccumulatorFactory;
-
-impl MultipleSubpopulationAggregateFactory for MultipleSumAccumulatorFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn MultipleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn MultipleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>
-    {
-        let mut merged_sums = HashMap::new();
-
-        for acc in accumulators {
-            if acc.type_name() != "MultipleSumAccumulator" {
-                return Err("Cannot merge different accumulator types".into());
-            }
-
-            // Get keys and merge values
-            let keys = acc.get_keys().unwrap();
-            for key in keys {
-                let value = acc.query(Statistic::Sum, &key, None)?;
-                *merged_sums.entry(key).or_insert(0.0) += value;
-            }
-        }
-
-        Ok(Box::new(MultipleSumAccumulator::new_with_sums(merged_sums)))
-    }
-
-    fn create_default(&self) -> Box<dyn MultipleSubpopulationAggregate> {
-        Box::new(MultipleSumAccumulator::new())
-    }
-}
-
 impl MergeableAccumulator<MultipleSumAccumulator> for MultipleSumAccumulator {
     fn merge_accumulators(
         accumulators: Vec<MultipleSumAccumulator>,
diff --git a/data_plane/src/precompute_engine/operators/sum_accumulator.rs b/data_plane/src/precompute_engine/operators/sum_accumulator.rs
index c4dcf5496..2cbe66fe5 100644
--- a/data_plane/src/precompute_engine/operators/sum_accumulator.rs
+++ b/data_plane/src/precompute_engine/operators/sum_accumulator.rs
@@ -1,6 +1,6 @@
 use crate::storage_engines::types::{
     AggregateCore, AggregationType, AuxStats, MergeableAccumulator, SerializableToSink,
-    SingleSubpopulationAggregate, SingleSubpopulationAggregateFactory,
+    SingleSubpopulationAggregate,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -207,39 +207,6 @@ impl SingleSubpopulationAggregate for SumAccumulator {
     }
 }
 
-// Factory implementation for merging
-pub struct SumAccumulatorFactory;
-
-impl SingleSubpopulationAggregateFactory for SumAccumulatorFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn SingleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn SingleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>
-    {
-        let mut total_sum = 0.0;
-        let mut observation_count = Some(0u64);
-
-        for acc in accumulators {
-            if acc.type_name() != "SumAccumulator" {
-                return Err("Cannot merge different accumulator types".into());
-            }
-            let sum_value = acc.query(Statistic::Sum, None)?;
-            total_sum += sum_value;
-            observation_count =
-                observation_count.and_then(|total| total.checked_add(acc.aux_stats().count?));
-        }
-
-        Ok(Box::new(SumAccumulator {
-            sum: total_sum,
-            observation_count,
-        }))
-    }
-
-    fn create_default(&self) -> Box<dyn SingleSubpopulationAggregate> {
-        Box::new(SumAccumulator::new())
-    }
-}
-
 impl MergeableAccumulator<SumAccumulator> for SumAccumulator {
     fn merge_accumulators(
         accumulators: Vec<SumAccumulator>,
diff --git a/data_plane/src/storage_engines/types/traits.rs b/data_plane/src/storage_engines/types/traits.rs
index f1a8b2ad7..97f2c96df 100644
--- a/data_plane/src/storage_engines/types/traits.rs
+++ b/data_plane/src/storage_engines/types/traits.rs
@@ -1,5 +1,4 @@
 use crate::storage_engines::types::KeyByLabelValues;
-use serde_json::Value;
 use std::collections::HashMap;
 
 use asap_types::AggregationType;
@@ -221,23 +220,6 @@ pub trait MultipleSubpopulationAggregate: AggregateCore {
     fn clone_boxed(&self) -> Box<dyn MultipleSubpopulationAggregate>;
 }
 
-/// Factory traits for creating and merging accumulators (object-safe)
-pub trait SingleSubpopulationAggregateFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn SingleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn SingleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>;
-    fn create_default(&self) -> Box<dyn SingleSubpopulationAggregate>;
-}
-
-pub trait MultipleSubpopulationAggregateFactory {
-    fn merge_accumulators(
-        &self,
-        accumulators: Vec<Box<dyn MultipleSubpopulationAggregate>>,
-    ) -> Result<Box<dyn MultipleSubpopulationAggregate>, Box<dyn std::error::Error + Send + Sync>>;
-    fn create_default(&self) -> Box<dyn MultipleSubpopulationAggregate>;
-}
-
 /// Trait for merging multiple accumulators of the same type
 pub trait MergeableAccumulator<T> {
     fn merge_accumulators(
@@ -266,18 +248,6 @@ impl Clone for Box<dyn MultipleSubpopulationAggregate> {
     }
 }
 
-/// Factory trait for creating accumulators from serialized data
-pub trait AccumulatorFactory {
-    fn create_from_json(
-        accumulator_type: &str,
-        data: &Value,
-    ) -> Result<Box<dyn AggregateCore>, Box<dyn std::error::Error>>;
-    fn create_from_bytes(
-        accumulator_type: &str,
-        buffer: &[u8],
-    ) -> Result<Box<dyn AggregateCore>, Box<dyn std::error::Error>>;
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

From 5702862832bdda129511add3a7bf5154fa0d42eb Mon Sep 17 00:00:00 2001
From: zz_y <zeyingz@umd.edu>
Date: Sun, 13 Sep 2026 10:30:10 -0600
Subject: [PATCH 4/4] refactor: remove disconnected control-plane modules

---
 control_plane/src/lib.rs                      |   1 -
 control_plane/src/physical/mod.rs             |   1 -
 .../src/physical/summary_reconcile.rs         | 332 ------------------
 control_plane/src/threshold_alloc.rs          |  56 ---
 4 files changed, 390 deletions(-)
 delete mode 100644 control_plane/src/physical/summary_reconcile.rs
 delete mode 100644 control_plane/src/threshold_alloc.rs

diff --git a/control_plane/src/lib.rs b/control_plane/src/lib.rs
index c61639e5c..aa0658e85 100644
--- a/control_plane/src/lib.rs
+++ b/control_plane/src/lib.rs
@@ -34,7 +34,6 @@ pub mod replan;
 pub mod runtime_samples;
 pub mod sketch_selection;
 pub mod store;
-pub mod threshold_alloc;
 pub mod types;
 pub mod types_v2;
 pub mod workload;
diff --git a/control_plane/src/physical/mod.rs b/control_plane/src/physical/mod.rs
index 3bd2411b8..02a8ec4ba 100644
--- a/control_plane/src/physical/mod.rs
+++ b/control_plane/src/physical/mod.rs
@@ -13,7 +13,6 @@ pub mod runtime_capability;
 pub mod sketch_catalog;
 pub mod stage_split;
 pub mod summary_catalog;
-pub mod summary_reconcile;
 pub mod topology;
 pub mod workload_cost;
 pub mod workload_planner;
diff --git a/control_plane/src/physical/summary_reconcile.rs b/control_plane/src/physical/summary_reconcile.rs
deleted file mode 100644
index 3a1f23c8f..000000000
--- a/control_plane/src/physical/summary_reconcile.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-//! Reconcile the control-plane desired SummaryCatalog with data-plane observed
-//! instance metadata. Summary payloads remain owned by SummaryStore.
-
-use std::collections::BTreeSet;
-
-use asap_types::sds::{
-    CatalogGeneration, InstanceLifecycle, ObservedSummaryInventory, SummaryDefinitionId,
-    SummaryInstanceId, SummaryInstanceStatus,
-};
-use serde::{Deserialize, Serialize};
-
-use super::summary_catalog::{SummaryCatalog, SummaryCatalogError};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
-pub enum SummaryReconcileAction {
-    Create {
-        summary_definition_id: SummaryDefinitionId,
-    },
-    Update {
-        instance_id: SummaryInstanceId,
-        summary_definition_id: SummaryDefinitionId,
-    },
-    Recover {
-        instance_id: SummaryInstanceId,
-        summary_definition_id: SummaryDefinitionId,
-    },
-    Retire {
-        instance_id: SummaryInstanceId,
-    },
-    GarbageCollect {
-        instance_id: SummaryInstanceId,
-    },
-    PromoteEphemeral {
-        instance_id: SummaryInstanceId,
-        summary_definition_id: SummaryDefinitionId,
-    },
-    ExpireEphemeral {
-        instance_id: SummaryInstanceId,
-    },
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum SummaryReconcileError {
-    #[error("invalid desired catalog: {0}")]
-    Catalog(#[from] SummaryCatalogError),
-    #[error("invalid observed inventory: {0}")]
-    Inventory(String),
-}
-
-pub fn reconcile_summary_inventory(
-    desired: &SummaryCatalog,
-    observed: &ObservedSummaryInventory,
-    now_ms: i64,
-    retiring_grace_ms: i64,
-) -> Result<Vec<SummaryReconcileAction>, SummaryReconcileError> {
-    desired.validate()?;
-    observed
-        .validate()
-        .map_err(|error| SummaryReconcileError::Inventory(error.to_string()))?;
-    let desired_generation = catalog_generation(desired)?;
-    let mut represented = BTreeSet::new();
-    let mut actions = Vec::new();
-
-    for instance in observed.instances.values() {
-        let desired_identity = desired
-            .materializations
-            .get(&instance.summary_definition_id);
-        match &instance.lifecycle {
-            InstanceLifecycle::Ephemeral { lease } if lease.expires_at_ms <= now_ms => {
-                actions.push(SummaryReconcileAction::ExpireEphemeral {
-                    instance_id: instance.instance_id.clone(),
-                });
-                continue;
-            }
-            InstanceLifecycle::Ephemeral { .. } => {
-                if desired_identity.is_some_and(|identity| {
-                    identity.summary_descriptor_id == instance.summary_descriptor_id
-                        && identity.data_descriptor_id == instance.data_descriptor_id
-                }) {
-                    represented.insert(instance.summary_definition_id);
-                    actions.push(SummaryReconcileAction::PromoteEphemeral {
-                        instance_id: instance.instance_id.clone(),
-                        summary_definition_id: instance.summary_definition_id,
-                    });
-                }
-                continue;
-            }
-            InstanceLifecycle::Persistent => {}
-        }
-
-        let Some(identity) = desired_identity else {
-            if instance.status == SummaryInstanceStatus::Retiring
-                && now_ms.saturating_sub(instance.observed_at_ms) >= retiring_grace_ms.max(0)
-            {
-                actions.push(SummaryReconcileAction::GarbageCollect {
-                    instance_id: instance.instance_id.clone(),
-                });
-            } else if instance.status != SummaryInstanceStatus::Retiring {
-                actions.push(SummaryReconcileAction::Retire {
-                    instance_id: instance.instance_id.clone(),
-                });
-            }
-            continue;
-        };
-        represented.insert(instance.summary_definition_id);
-
-        if matches!(
-            instance.status,
-            SummaryInstanceStatus::Failed | SummaryInstanceStatus::MissingPayload
-        ) {
-            actions.push(SummaryReconcileAction::Recover {
-                instance_id: instance.instance_id.clone(),
-                summary_definition_id: instance.summary_definition_id,
-            });
-        } else if identity.summary_descriptor_id != instance.summary_descriptor_id
-            || identity.data_descriptor_id != instance.data_descriptor_id
-            || instance.catalog_generation != desired_generation
-            || desired.summary_descriptors[&identity.summary_descriptor_id].state_schema_version
-                != instance.state_reference.state_schema_version
-            || instance.status == SummaryInstanceStatus::Retiring
-        {
-            actions.push(SummaryReconcileAction::Update {
-                instance_id: instance.instance_id.clone(),
-                summary_definition_id: instance.summary_definition_id,
-            });
-        }
-    }
-
-    for id in desired.materializations.keys() {
-        if !represented.contains(id) {
-            actions.push(SummaryReconcileAction::Create {
-                summary_definition_id: *id,
-            });
-        }
-    }
-    Ok(actions)
-}
-
-fn catalog_generation(catalog: &SummaryCatalog) -> Result<CatalogGeneration, SummaryCatalogError> {
-    let reference = catalog.reference()?;
-    Ok(CatalogGeneration {
-        schema_version: reference.schema_version,
-        plan_id: reference.plan_id,
-        plan_version: reference.plan_version,
-        snapshot_sha256: reference.snapshot_sha256,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use asap_types::sds::{
-        EphemeralLease, HalfOpenTimeRange, InstanceCompleteness, SummaryPlacement,
-        SummaryStateReference,
-    };
-    use asap_types::{AggregationType, KeyByLabelNames, PrecomputeMaterialization, WindowKind};
-    use std::collections::BTreeMap;
-
-    fn config(metric: &str) -> PrecomputeMaterialization {
-        PrecomputeMaterialization::new(
-            AggregationType::Sum,
-            String::new(),
-            Default::default(),
-            KeyByLabelNames::empty(),
-            KeyByLabelNames::empty(),
-            KeyByLabelNames::empty(),
-            String::new(),
-            60,
-            60,
-            WindowKind::Tumbling,
-            String::new(),
-            metric.into(),
-            None,
-            None,
-            None,
-        )
-    }
-
-    fn instance(
-        catalog: &SummaryCatalog,
-        id: &str,
-        lifecycle: InstanceLifecycle,
-        status: SummaryInstanceStatus,
-        observed_at_ms: i64,
-    ) -> asap_types::sds::SummaryInstance {
-        let (summary_definition_id, identity) = catalog.materializations.iter().next().unwrap();
-        asap_types::sds::SummaryInstance {
-            instance_id: SummaryInstanceId::new(id).unwrap(),
-            summary_definition_id: *summary_definition_id,
-            summary_descriptor_id: identity.summary_descriptor_id.clone(),
-            data_descriptor_id: identity.data_descriptor_id.clone(),
-            time_range: HalfOpenTimeRange {
-                start_ms: 0,
-                end_ms: 60_000,
-            },
-            group_values: BTreeMap::new(),
-            catalog_generation: catalog_generation(catalog).unwrap(),
-            placement: SummaryPlacement {
-                producer_id: "precompute-1".into(),
-                storage_node_id: "store-1".into(),
-            },
-            state_reference: SummaryStateReference {
-                store: "summary-store".into(),
-                key: id.into(),
-                state_schema_version: 1,
-                generation: 1,
-                sequence: 1,
-                checksum: None,
-            },
-            status,
-            completeness: InstanceCompleteness::Complete,
-            lifecycle,
-            observed_at_ms,
-        }
-    }
-
-    fn inventory(instance: asap_types::sds::SummaryInstance, now: i64) -> ObservedSummaryInventory {
-        ObservedSummaryInventory {
-            schema_version: 1,
-            reporter_id: "store-1".into(),
-            inventory_version: 1,
-            observed_at_ms: now,
-            instances: BTreeMap::from([(instance.instance_id.clone(), instance)]),
-        }
-    }
-
-    #[test]
-    fn creates_missing_and_updates_stale_generation() {
-        let catalog = SummaryCatalog::from_materializations(1, 2, &[config("a")]).unwrap();
-        let empty = ObservedSummaryInventory {
-            schema_version: 1,
-            reporter_id: "store-1".into(),
-            inventory_version: 1,
-            observed_at_ms: 100,
-            instances: BTreeMap::new(),
-        };
-        assert!(matches!(
-            reconcile_summary_inventory(&catalog, &empty, 100, 10).unwrap()[0],
-            SummaryReconcileAction::Create { .. }
-        ));
-        let mut value = instance(
-            &catalog,
-            "i",
-            InstanceLifecycle::Persistent,
-            SummaryInstanceStatus::Ready,
-            100,
-        );
-        value.catalog_generation.plan_version -= 1;
-        assert!(matches!(
-            reconcile_summary_inventory(&catalog, &inventory(value, 100), 100, 10).unwrap()[0],
-            SummaryReconcileAction::Update { .. }
-        ));
-    }
-
-    #[test]
-    fn recovers_missing_payload_and_retires_then_collects_removed_state() {
-        let catalog = SummaryCatalog::from_materializations(1, 2, &[config("a")]).unwrap();
-        let missing = instance(
-            &catalog,
-            "missing",
-            InstanceLifecycle::Persistent,
-            SummaryInstanceStatus::MissingPayload,
-            90,
-        );
-        assert!(matches!(
-            reconcile_summary_inventory(&catalog, &inventory(missing, 100), 100, 10).unwrap()[0],
-            SummaryReconcileAction::Recover { .. }
-        ));
-        let empty = SummaryCatalog::from_materializations(1, 3, &[]).unwrap();
-        let ready = instance(
-            &catalog,
-            "old",
-            InstanceLifecycle::Persistent,
-            SummaryInstanceStatus::Ready,
-            90,
-        );
-        assert!(matches!(
-            reconcile_summary_inventory(&empty, &inventory(ready, 100), 100, 10).unwrap()[0],
-            SummaryReconcileAction::Retire { .. }
-        ));
-        let retiring = instance(
-            &catalog,
-            "old",
-            InstanceLifecycle::Persistent,
-            SummaryInstanceStatus::Retiring,
-            80,
-        );
-        assert!(matches!(
-            reconcile_summary_inventory(&empty, &inventory(retiring, 100), 100, 10).unwrap()[0],
-            SummaryReconcileAction::GarbageCollect { .. }
-        ));
-    }
-
-    #[test]
-    fn promotes_matching_ephemeral_and_expires_lease_first() {
-        let catalog = SummaryCatalog::from_materializations(1, 2, &[config("a")]).unwrap();
-        let lease = |expires_at_ms| InstanceLifecycle::Ephemeral {
-            lease: EphemeralLease {
-                lease_id: "lease-1".into(),
-                owner_id: "fast-path".into(),
-                issued_at_ms: 10,
-                expires_at_ms,
-            },
-        };
-        let live = instance(
-            &catalog,
-            "live",
-            lease(200),
-            SummaryInstanceStatus::Ready,
-            100,
-        );
-        assert!(matches!(
-            reconcile_summary_inventory(&catalog, &inventory(live, 100), 100, 10).unwrap()[0],
-            SummaryReconcileAction::PromoteEphemeral { .. }
-        ));
-        let expired = instance(
-            &catalog,
-            "expired",
-            lease(100),
-            SummaryInstanceStatus::Ready,
-            100,
-        );
-        let actions =
-            reconcile_summary_inventory(&catalog, &inventory(expired, 100), 100, 10).unwrap();
-        assert!(matches!(
-            actions[0],
-            SummaryReconcileAction::ExpireEphemeral { .. }
-        ));
-        assert!(matches!(actions[1], SummaryReconcileAction::Create { .. }));
-    }
-}
diff --git a/control_plane/src/threshold_alloc.rs b/control_plane/src/threshold_alloc.rs
deleted file mode 100644
index 03cf98672..000000000
--- a/control_plane/src/threshold_alloc.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//! GOS isotropic threshold closed forms — the per-family formulas from the
-//! unified error/threshold/cost framework (see
-//! `ASAPCollector/docs/design-gos-unified-edge-telemetry.md` §8 /
-//! `docs/sampling-cdm-gos-derivations.md` §8).
-//!
-//! These are the UNIFORM (isotropic) case: every cell/bucket in scope shares
-//! one threshold `T`, derived in closed form from the accuracy budget with no
-//! iterative solve needed. This is what the shipped ASAPCollector edge side
-//! (the 2026-07 insert-time-GOS redesign) actually runs today.
-//!
-//! ANISOTROPIC (gradient-weighted, non-uniform `T_j` per cell) per-cell
-//! water-filling is intentionally NOT included here. It is only worked out
-//! for CountSketch (design §7), and — per the design doc's own "Open items"
-//! (§11) — its `Activity_j` input assumes a single, uniformly-timed snapshot
-//! reference, an assumption the shipped async-per-cell-reset insert-time
-//! model breaks. Whether the closed-form water-filling solution still holds
-//! under a redefined (e.g. per-cell EMA) activity input has not been checked.
-//! Add it back once that is resolved — don't wire a stale solver in the
-//! meantime.
-
-/// F2 isotropic closed form: `T = ε·‖Ĉ‖ / (2·k·√(d·w))` (design §7/§8.3).
-///
-/// The relative-error threshold for CountSketch's `F2 = ‖f‖₂²` / point-query
-/// readout when all cells are treated uniformly — it scales with the current
-/// norm `‖Ĉ‖`, so relative error stays bounded as the sketch grows. Returns
-/// `+∞` for degenerate dims (no gating).
-pub fn f2_isotropic_threshold(epsilon: f64, norm: f64, k: u32, d: usize, w: usize) -> f64 {
-    let k = k.max(1) as f64;
-    let n = (d * w) as f64;
-    if n <= 0.0 {
-        return f64::INFINITY;
-    }
-    epsilon * norm / (2.0 * k * n.sqrt())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn f2_closed_form_matches_formula() {
-        // T = ε‖Ĉ‖/(2k√(dw)); ε=0.1, ‖Ĉ‖=1000, k=4, d=5, w=256
-        let t = f2_isotropic_threshold(0.1, 1000.0, 4, 5, 256);
-        let expect = 0.1 * 1000.0 / (2.0 * 4.0 * ((5 * 256) as f64).sqrt());
-        assert!((t - expect).abs() < 1e-9, "got {t} expect {expect}");
-    }
-
-    #[test]
-    fn degenerate_dims_return_infinity() {
-        assert_eq!(
-            f2_isotropic_threshold(0.1, 1000.0, 4, 0, 256),
-            f64::INFINITY
-        );
-        assert_eq!(f2_isotropic_threshold(0.1, 1000.0, 4, 5, 0), f64::INFINITY);
-    }
-}