@@ -324,7 +324,7 @@ async fn handle_instant_query_post(
         .and_then(|v| v.to_str().ok())
         .unwrap_or("");
 
-    debug!("Content-Type: {}", content_type);
+    debug!("POST content-type: '{}'", content_type);
 
     let parsed_request = if content_type.contains("application/json") {
         // Handle JSON POST (Elasticsearch)
@@ -369,11 +369,24 @@ async fn handle_instant_query_post(
             }
         };
 
-        // Parse form parameters
-        let params: HashMap<String, String> = form_urlencoded::parse(body_str.as_bytes())
+        debug!(
+            "POST body prefix (first 200 chars): '{}'",
+            &body_str.chars().take(200).collect::<String>()
+        );
+
+        // Parse form parameters, falling back to treating the raw body as the
+        // SQL query if no "query" key is found (ClickHouse native HTTP style).
+        let mut params: HashMap<String, String> = form_urlencoded::parse(body_str.as_bytes())
             .into_owned()
             .collect();
-        debug!("Form params extracted: {:?}", params);
+        if !params.contains_key("query") && !body_str.is_empty() {
+            params.clear();
+            params.insert("query".to_string(), body_str.clone());
+        }
+        debug!(
+            "POST form params keys: {:?}",
+            params.keys().collect::<Vec<_>>()
+        );
 
         // Use adapter to parse POST request (handles form-encoded parameters)
         match state.adapter.parse_post_request(Form(params)).await {
@@ -385,7 +398,7 @@ async fn handle_instant_query_post(
                 req
             }
             Err(parse_error) => {
-                debug!("Failed to parse POST request: {:?}", parse_error);
+                debug!("POST parse failed: {}", parse_error);
                 return match state.adapter.format_error_response(&parse_error).await {
                     Ok(json) => json.into_response(),
                     Err(status) => status.into_response(),
 
@@ -4,8 +4,10 @@ use crate::precompute_engine::worker::{extract_metric_name, parse_labels_from_se
 use arc_swap::ArcSwap;
 use asap_types::aggregation_config::AggregationConfig;
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::Instant;
+use tracing::{debug, warn};
 
 /// Everything a source needs to push decoded samples into the worker pool.
 #[derive(Clone)]
@@ -89,15 +91,42 @@ pub(crate) async fn route_decoded_samples(
 
     // Load agg_configs once per request (lock-free ArcSwap read).
     let agg_configs = ctx.agg_configs.load();
+
+    // On first batch: log config metrics vs sample metric to diagnose mismatches.
+    static FIRST_BATCH_LOGGED: AtomicBool = AtomicBool::new(false);
+    if !FIRST_BATCH_LOGGED.swap(true, Ordering::Relaxed) {
+        if let Some(first) = samples.first() {
+            let sample_metric = extract_metric_name(&first.labels);
+            warn!(
+                sample_metric,
+                sample_labels = %first.labels,
+                num_agg_configs = agg_configs.len(),
+                "routing: first batch diagnostic"
+            );
+            for cfg in agg_configs.iter() {
+                warn!(
+                    agg_id = cfg.aggregation_id,
+                    config_metric = %cfg.metric,
+                    config_spatial_filter = %cfg.spatial_filter,
+                    table_name = ?cfg.table_name,
+                    "routing: agg config metric"
+                );
+            }
+        }
+    }
+
+    let mut matched_samples: usize = 0;
     for s in &samples {
         let metric_name = extract_metric_name(&s.labels);
         for config in agg_configs.iter() {
             if config.metric != metric_name
                 && config.spatial_filter_normalized != metric_name
                 && config.spatial_filter != metric_name
+                && config.table_name.as_deref() != Some(metric_name)
             {
                 continue;
             }
+            matched_samples += 1;
             let group_key = extract_group_key(&s.labels, config);
             by_group
                 .entry((config.aggregation_id, group_key))
@@ -106,6 +135,13 @@ pub(crate) async fn route_decoded_samples(
         }
     }
 
+    debug!(
+        total_samples = samples.len(),
+        matched_samples,
+        groups_formed = by_group.len(),
+        "routing: batch match summary"
+    );
+
     let messages: Vec<WorkerMessage> = by_group
         .into_iter()
         .map(
 
@@ -1,5 +1,6 @@
 use crate::drivers::ingest::prometheus_remote_write::DecodedSample;
 use crate::precompute_engine::ingest_source::{route_decoded_samples, IngestContext, IngestSource};
+use chrono::NaiveDateTime;
 use std::time::Instant;
 use tracing::info;
 
@@ -110,23 +111,38 @@ impl IngestSource for JsonFileIngestSource {
                             .into()
                         })?;
 
-                    let raw_ts: i64 = obj
-                        .get(&config.timestamp_col)
-                        .ok_or_else(|| -> Box<dyn std::error::Error + Send + Sync> {
+                    let ts_val = obj.get(&config.timestamp_col).ok_or_else(
+                        || -> Box<dyn std::error::Error + Send + Sync> {
                             std::io::Error::other(format!(
                                 "timestamp column '{}' not found in JSON object",
                                 config.timestamp_col
                             ))
                             .into()
-                        })?
-                        .as_i64()
-                        .ok_or_else(|| -> Box<dyn std::error::Error + Send + Sync> {
-                            std::io::Error::other(format!(
-                                "timestamp column '{}' is not an integer",
-                                config.timestamp_col
-                            ))
-                            .into()
-                        })?;
+                        },
+                    )?;
+
+                    // Accept integer (Unix epoch) or string datetime "YYYY-MM-DD HH:MM:SS".
+                    let raw_ts: i64 = if let Some(i) = ts_val.as_i64() {
+                        i
+                    } else if let Some(s) = ts_val.as_str() {
+                        NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
+                            .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> {
+                                std::io::Error::other(format!(
+                                    "timestamp column '{}' value {:?} is not an integer or \
+                                     a parseable datetime string: {}",
+                                    config.timestamp_col, s, e
+                                ))
+                                .into()
+                            })?
+                            .and_utc()
+                            .timestamp()
+                    } else {
+                        return Err(std::io::Error::other(format!(
+                            "timestamp column '{}' is not an integer or string",
+                            config.timestamp_col
+                        ))
+                        .into());
+                    };
 
                     let timestamp_ms = config.timestamp_unit.to_ms(raw_ts);
 
@@ -140,7 +156,20 @@ impl IngestSource for JsonFileIngestSource {
                             if i > 0 {
                                 s.push(',');
                             }
-                            let val = obj.get(col).and_then(|v| v.as_str()).unwrap_or("");
+                            let val_owned;
+                            let val = if let Some(s) = obj.get(col).and_then(|v| v.as_str()) {
+                                s
+                            } else if let Some(v) = obj.get(col) {
+                                val_owned = v.to_string();
+                                val_owned.as_str()
+                            } else {
+                                return Err(std::io::Error::other(format!(
+                                    "label column '{}' not found in JSON object (row {})",
+                                    col,
+                                    row_count + 1
+                                ))
+                                .into());
+                            };
                             s.push_str(col);
                             s.push_str("=\"");
                             s.push_str(val);
 
@@ -240,15 +240,12 @@ def generate_sql_file(
         start_str = (end_ts - timedelta(seconds=window_size)).strftime(
             "%Y-%m-%d %H:%M:%S"
         )
-        label = f"T{i:03d}"
-
         if window_form == "dateadd":
             where = f"{ts_column} BETWEEN DATEADD(s, -{window_size}, '{end_str}') AND '{end_str}'"
         else:
             where = f"{ts_column} BETWEEN '{start_str}' AND '{end_str}'"
 
         lines.append(
-            f"-- {label}: quantile window ending at {end_str}\n"
             f"SELECT quantile({quantile})({value_column}) FROM {table_name} "
             f"WHERE {where} GROUP BY {group_by_clause};"
         )
 
@@ -93,6 +93,7 @@
 from urllib.parse import urlparse
 
 import hydra
+import yaml
 from omegaconf import DictConfig, OmegaConf
 
 import constants
@@ -106,6 +107,39 @@
 from experiment_utils.services.misc import ControllerService
 from experiment_utils.services.query_engine import QueryEngineRustService
 
+
+def _inline_sql_queries_in_experiment_config(local_experiment_root_dir: str) -> None:
+    """Enrich the saved experiment_params.yaml by inlining SQL from sql_file references.
+
+    Downstream analysis scripts expect query_groups[i]["queries"] to be a list
+    of query strings.  The clickhouse config stores sql_file paths instead, so
+    we read each file and add the queries in-place before the scripts run.
+    """
+    config_path = os.path.join(
+        local_experiment_root_dir, "experiment_config", "experiment_params.yaml"
+    )
+    if not os.path.exists(config_path):
+        return
+    with open(config_path) as f:
+        data = yaml.safe_load(f)
+
+    def _expand_groups(groups):
+        if not groups:
+            return
+        for group in groups:
+            sql_file = group.get("sql_file")
+            if sql_file and "queries" not in group:
+                with open(sql_file) as fq:
+                    content = fq.read()
+                group["queries"] = [s.strip() for s in content.split(";") if s.strip()]
+
+    _expand_groups(data.get("query_groups"))
+    _expand_groups(data.get("sketchdb_query_groups"))
+
+    with open(config_path, "w") as f:
+        yaml.dump(data, f, allow_unicode=True)
+
+
 # Register resolvers used by config.yaml interpolation.
 OmegaConf.register_new_resolver(
     "local_experiment_dir", lambda: constants.LOCAL_EXPERIMENT_DIR
@@ -234,6 +268,7 @@ def main(cfg: DictConfig) -> None:
     )
 
     sync.copy_experiment_config(cfg.experiment_params, local_experiment_root_dir)
+    _inline_sql_queries_in_experiment_config(local_experiment_root_dir)
 
     # --- dataset config ---
     ep = cfg.experiment_params
@@ -339,6 +374,11 @@ def main(cfg: DictConfig) -> None:
 
         if experiment_mode == constants.SKETCHDB_EXPERIMENT_NAME:
             # --- sketchdb mode: precompute engine + JSON ingest + ClickHouse fallback ---
+            # Kill any leftover query_engine_rust from a previous run (mirrors
+            # query_engine_service.stop() at the top of the e2e mode loop).
+            QueryEngineRustService(
+                provider=provider, use_container=False, node_offset=node_offset
+            ).stop()
             # Mirrors experiment_run_e2e.py: planner runs first and generates
             # streaming_config.yaml + inference_config.yaml into controller_output_dir,
             # then the query engine starts reading from that same directory.
@@ -438,7 +478,9 @@ def main(cfg: DictConfig) -> None:
                     provider=provider,
                     node_offset=node_offset,
                     config_file=controller_client_config,
-                    output_dir=experiment_output_dir,
+                    output_dir=os.path.join(
+                        experiment_output_dir, "prometheus_client_output"
+                    ),
                     use_container=use_container,
                     parallel=parallel,
                 )
@@ -465,7 +507,9 @@ def main(cfg: DictConfig) -> None:
                     provider=provider,
                     node_offset=node_offset,
                     config_file=controller_client_config,
-                    output_dir=experiment_output_dir,
+                    output_dir=os.path.join(
+                        experiment_output_dir, "prometheus_client_output"
+                    ),
                     use_container=use_container,
                     parallel=parallel,
                 )