Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py — ST_Sonic_Ts (mirrors your Ym GUI, adapted for Shear Slowness Ts)
+# app.py — ST_Sonic_Ts (Shear Slowness Ts)
 import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
@@ -7,7 +7,7 @@ import numpy as np
 import joblib
 from datetime import datetime
 
-# Matplotlib for PREVIEW modal and the CROSS-PLOT (static)
+# Matplotlib (static plots)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -19,14 +19,12 @@ from sklearn.metrics import mean_squared_error, mean_absolute_error
 # =========================
 # Constants (Ts variant)
 # =========================
-APP_NAME = "ST_Log_Sonic(Ts)"
+APP_NAME = "ST_Log_Sonic (Ts)"
 TAGLINE  = "Real-Time Shear Slowness (Ts) Prediction"
 
-# Keep your drilling features the same (we'll normalize header variants below)
+# Defaults (will be overridden by meta if present)
 FEATURES  = ["WOB(klbf)", "TORQUE(kft.lbf)", "SPP(psi)", "RPM(1/min)", "ROP(ft/h)", "Flow Rate, gpm"]
-
-# Target and pred column for Ts
-TARGET    = "Ts"          # we'll map your file's "Ts,us/ft_Actual" → "Ts"
+TARGET    = "Ts"
 PRED_COL  = "Ts_Pred"
 
 MODELS_DIR = Path("models")
@@ -34,8 +32,10 @@ DEFAULT_MODEL = MODELS_DIR / "ts_model.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
+# Toggle to show strict version banner from meta
+STRICT_VERSION_CHECK = False
 
-# ---- Plot sizing controls ----
+# ---- Plot sizing ----
 CROSS_W = 350
 CROSS_H = 350
 TRACK_H = 1000
@@ -47,7 +47,6 @@ BOLD_FONT = "Arial Black, Arial, sans-serif"
 # Page / CSS
 # =========================
 st.set_page_config(page_title=APP_NAME, page_icon="logo.png", layout="wide")
-
 st.markdown("""
 <style>
  .brand-logo { width: 200px; height: auto; object-fit: contain; }
@@ -55,55 +54,26 @@ st.markdown("""
  .sidebar-header .text h1 { font-size: 1.05rem; margin:0; line-height:1.1; }
  .sidebar-header .text .tag { font-size: .85rem; color:#6b7280; margin:2px 0 0; }
  .centered-container { display: flex; flex-direction: column; align-items: center; text-align: center; }
+ .st-message-box { background-color: #f0f2f6; color: #333; padding: 10px; border-radius: 10px; border: 1px solid #e6e9ef; }
+ .st-message-box.st-success { background-color: #d4edda; color: #155724; border-color: #c3e6cb; }
+ .st-message-box.st-warning { background-color: #fff3cd; color: #856404; border-color: #ffeeba; }
+ .st-message-box.st-error { background-color: #f8d7da; color: #721c24; border-color: #f5c6cb; }
+ .main .block-container { overflow: unset !important; }
+ div[data-testid="stVerticalBlock"] { overflow: unset !important; }
+ div[data-testid="stExpander"] > details > summary {
+   position: sticky; top: 0; z-index: 10; background: #fff; border-bottom: 1px solid #eee;
+ }
+ div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
+   position: sticky; top: 42px; z-index: 9; background: #fff; padding-top: 6px;
+ }
 </style>
 """, unsafe_allow_html=True)
 
-# Sticky helpers
-st.markdown("""
-<style>
-.main .block-container { overflow: unset !important; }
-div[data-testid="stVerticalBlock"] { overflow: unset !important; }
-</style>
-""", unsafe_allow_html=True)
-
-# Hide uploader helper text
-st.markdown("""
-<style>
-section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
-section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] small{display:none !important;}
-</style>
-""", unsafe_allow_html=True)
-
-# Make the Preview expander title & tabs sticky (pinned to the top)
-st.markdown("""
-<style>
-div[data-testid="stExpander"] > details > summary {
- position: sticky; top: 0; z-index: 10; background: #fff; border-bottom: 1px solid #eee;
-}
-div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
- position: sticky; top: 42px; z-index: 9; background: #fff; padding-top: 6px;
-}
-</style>
-""", unsafe_allow_html=True)
-
-# Center text in all pandas Styler tables
 TABLE_CENTER_CSS = [
     dict(selector="th", props=[("text-align", "center")]),
     dict(selector="td", props=[("text-align", "center")]),
 ]
 
-# Message box CSS
-st.markdown("""
-<style>
-.st-message-box { background-color: #f0f2f6; color: #333; padding: 10px; border-radius: 10px; border: 1px solid #e6e9ef; }
-.st-message-box.st-success { background-color: #d4edda; color: #155724; border-color: #c3e6cb; }
-.st-message-box.st-warning { background-color: #fff3cd; color: #856404; border-color: #ffeeba; }
-.st-message-box.st-error { background-color: #f8d7da; color: #721c24; border-color: #f5c6cb; }
-</style>
-""", unsafe_allow_html=True)
-
 # =========================
 # Password gate
 # =========================
@@ -157,7 +127,6 @@ def pearson_r(y_true, y_pred) -> float:
     a = np.asarray(y_true, dtype=float)
     p = np.asarray(y_pred, dtype=float)
     if a.size < 2: return float("nan")
-    # Guard constant series
     if np.all(a == a[0]) or np.all(p == p[0]): return float("nan")
     return float(np.corrcoef(a, p)[0, 1])
 
@@ -171,17 +140,57 @@ def parse_excel(data_bytes: bytes):
     xl = pd.ExcelFile(bio)
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
-def read_book_bytes(b: bytes): return parse_excel(b) if b else {}
+def read_book_bytes(b: bytes): 
+    return parse_excel(b) if b else {}
+
+# ---- Canonical feature aliasing ------------------------------------------
+def _build_alias_map(canonical_features: list[str], target_name: str) -> dict:
+    """
+    Returns a dict of common header variants -> canonical names as per the model's FEATURES.
+    We choose the canonical for each family by checking which string exists in canonical_features.
+    """
+    def pick(expected_list, family_variants):
+        # pick the first variant that exists in expected_list, else fall back to first in family_variants
+        for v in family_variants:
+            if v in expected_list:
+                return v
+        return family_variants[0]
+
+    can_WOB    = pick(canonical_features, ["WOB, klbf","WOB(klbf)","WOB (klbf)"])
+    can_TORQUE = pick(canonical_features, ["Torque(kft.lbf)","TORQUE(kft.lbf)"])
+    can_SPP    = pick(canonical_features, ["SPP(psi)"])
+    can_RPM    = pick(canonical_features, ["RPM(1/min)","RPM (1/min)"])
+    can_ROP    = pick(canonical_features, ["ROP(ft/h)","ROP (ft/h)"])
+    can_FR     = pick(canonical_features, ["Flow Rate, gpm","Flow Rate , gpm","Flow Rate,gpm"])
+
+    alias = {
+        # WOB
+        "WOB, klbf": can_WOB, "WOB(klbf)": can_WOB, "WOB (klbf)": can_WOB, "WOB( klbf)": can_WOB, "WOB , klbf": can_WOB,
+        # Torque
+        "Torque(kft.lbf)": can_TORQUE, "TORQUE(kft.lbf)": can_TORQUE,
+        # SPP
+        "SPP(psi)": can_SPP,
+        # RPM
+        "RPM(1/min)": can_RPM, "RPM (1/min)": can_RPM,
+        # ROP
+        "ROP(ft/h)": can_ROP, "ROP (ft/h)": can_ROP,
+        # Flow
+        "Flow Rate, gpm": can_FR, "Fow Rate, gpm": can_FR, "Fow Rate, gpm ": can_FR, "Flow Rate , gpm": can_FR, "Flow Rate,gpm": can_FR,
+        # Depth (for plotting only)
+        "Depth, ft": "Depth, ft", "Depth(ft)": "Depth, ft", "DEPTH, ft": "Depth, ft",
+        # Ts targets (map all to the chosen TARGET)
+        "Ts": target_name, "Ts,us/ft_Actual": target_name, "Ts, us/ft_Actual": target_name,
+        "TS_Actual": target_name, "Ts (us/ft)_Actual": target_name
+    }
+    return alias
 
-def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], target_name: str) -> pd.DataFrame:
     out = df.copy()
-    out.columns = [c.strip() for c in out.columns]
-    # Fix flow-rate typo variants
-    out = out.rename(columns={
-        "Fow Rate, gpm": "Flow Rate, gpm",
-        "Fow Rate, gpm ": "Flow Rate, gpm"
-    })
-    return out
+    out.columns = [str(c).strip().replace(" ,", ",").replace(",  ", ", ").replace("  ", " ") for c in out.columns]
+    alias = _build_alias_map(canonical_features, target_name)
+    # only rename keys that actually exist
+    actual = {k: v for k, v in alias.items() if k in out.columns and k != v}
+    return out.rename(columns=actual)
 
 def ensure_cols(df: pd.DataFrame, cols: list[str]) -> bool:
     miss = [c for c in cols if c not in df.columns]
@@ -197,7 +206,6 @@ def find_sheet(book, names):
     return None
 
 def _nice_tick0(xmin: float, step: float = 0.1) -> float:
-    # Rounded start tick for continuous Ts scales (unit-agnostic)
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
 def df_centered_rounded(df: pd.DataFrame, hide_index=True):
@@ -219,51 +227,6 @@ def _excel_engine() -> str:
     except Exception:
         return "openpyxl"
 
-def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
-    out = df.copy()
-
-    # Trim and collapse inner spaces like ", " → ", " consistently
-    out.columns = [str(c).strip().replace(" ,", ",").replace(",  ", ", ").replace("  ", " ") for c in out.columns]
-
-    # Canonical rename map: map what you have → what the app expects
-    rename_map = {
-        # Drilling features
-        "WOB, klbf":        "WOB(klbf)",
-        "WOB (klbf)":       "WOB(klbf)",
-        "WOB( klbf)":       "WOB(klbf)",
-        "WOB(klbf)":        "WOB(klbf)",
-
-        "Torque(kft.lbf)":  "TORQUE(kft.lbf)",
-        "TORQUE(kft.lbf)":  "TORQUE(kft.lbf)",
-
-        "SPP(psi)":         "SPP(psi)",
-        "RPM(1/min)":       "RPM(1/min)",
-        "ROP(ft/h)":        "ROP(ft/h)",
-        "Flow Rate, gpm":   "Flow Rate, gpm",
-
-        # Target column variants coming from your file
-        "Ts,us/ft_Actual":  "Ts",
-        "Ts, us/ft_Actual": "Ts",
-        "TS_Actual":        "Ts",
-        "Ts (us/ft)_Actual":"Ts",
-    }
-
-    # Also keep Depth variants tidy (used for Y axis only)
-    depth_variants = {
-        "Depth, ft": "Depth, ft",
-        "Depth(ft)": "Depth, ft",
-        "DEPTH, ft": "Depth, ft",
-    }
-
-    # Build final mapping
-    final_map = {**depth_variants}
-    # Only add keys that actually exist to avoid KeyErrors
-    final_map.update({k: v for k, v in rename_map.items() if k in out.columns})
-
-    out = out.rename(columns=final_map)
-    return out
-
-
 def _excel_safe_name(name: str) -> str:
     bad = '[]:*?/\\'
     safe = ''.join('_' if ch in bad else ch for ch in str(name))
@@ -294,7 +257,6 @@ def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
     return _round_numeric(df, 3)
 
 def _excel_autofit(writer, sheet_name: str, df: pd.DataFrame, min_w: int = 8, max_w: int = 40):
-    """Auto-fit columns when using xlsxwriter."""
     try:
         import xlsxwriter  # noqa: F401
     except Exception:
@@ -307,13 +269,11 @@ def _excel_autofit(writer, sheet_name: str, df: pd.DataFrame, min_w: int = 8, ma
     ws.freeze_panes(1, 0)
 
 def _add_sheet(sheets: dict, order: list, name: str, df: pd.DataFrame, ndigits: int):
-    if df is None or df.empty:
-        return
+    if df is None or df.empty: return
     sheets[name] = _round_numeric(df, ndigits)
     order.append(name)
 
 def _available_sections() -> list[str]:
-    """Compute which sections exist (offered in the export dropdown)."""
     res = st.session_state.get("results", {})
     sections = []
     if "Train" in res:        sections += ["Training","Training_Metrics","Training_Summary"]
@@ -325,15 +285,12 @@ def _available_sections() -> list[str]:
     return sections
 
 def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: bool = True) -> tuple[bytes|None, str|None, list[str]]:
-    """Builds an in-memory Excel workbook for selected sheets; fixed rounding to 3 decimals."""
     res = st.session_state.get("results", {})
-    if not res:
-        return None, None, []
+    if not res: return None, None, []
 
     sheets: dict[str, pd.DataFrame] = {}
     order: list[str] = []
 
-    # Training
     if "Training" in selected and "Train" in res:
         _add_sheet(sheets, order, "Training", res["Train"], ndigits)
     if "Training_Metrics" in selected and res.get("m_train"):
@@ -342,7 +299,6 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
         tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Train"].columns]
         _add_sheet(sheets, order, "Training_Summary", _summary_table(res["Train"], tr_cols), ndigits)
 
-    # Testing
     if "Testing" in selected and "Test" in res:
         _add_sheet(sheets, order, "Testing", res["Test"], ndigits)
     if "Testing_Metrics" in selected and res.get("m_test"):
@@ -351,7 +307,6 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
         te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Test"].columns]
         _add_sheet(sheets, order, "Testing_Summary", _summary_table(res["Test"], te_cols), ndigits)
 
-    # Validation
     if "Validation" in selected and "Validate" in res:
         _add_sheet(sheets, order, "Validation", res["Validate"], ndigits)
     if "Validation_Metrics" in selected and res.get("m_val"):
@@ -361,18 +316,15 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
     if "Validation_OOR" in selected and isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
         _add_sheet(sheets, order, "Validation_OOR", res["oor_tbl"].reset_index(drop=True), ndigits)
 
-    # Prediction
     if "Prediction" in selected and "PredictOnly" in res:
         _add_sheet(sheets, order, "Prediction", res["PredictOnly"], ndigits)
     if "Prediction_Summary" in selected and res.get("sv_pred"):
         _add_sheet(sheets, order, "Prediction_Summary", pd.DataFrame([res["sv_pred"]]), ndigits)
 
-    # Training ranges
     if "Training_Ranges" in selected and st.session_state.get("train_ranges"):
         rr = _train_ranges_df(st.session_state["train_ranges"])
         _add_sheet(sheets, order, "Training_Ranges", rr, ndigits)
 
-    # Info
     if "Info" in selected:
         info = pd.DataFrame([
             {"Key": "AppName",    "Value": APP_NAME},
@@ -384,8 +336,7 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
         ])
         _add_sheet(sheets, order, "Info", info, ndigits)
 
-    if not order:
-        return None, None, []
+    if not order: return None, None, []
 
     bio = io.BytesIO()
     engine = _excel_engine()
@@ -397,24 +348,17 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
             if do_autofit:
                 _excel_autofit(writer, sheet, df)
     bio.seek(0)
-
     fname = f"TS_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
-# --------- SIMPLE export UI (dropdown checklist, starts empty) ----------
+# --------- SIMPLE export UI ----------
 def render_export_button(phase_key: str) -> None:
-    """
-    Export UI — one multiselect dropdown that starts EMPTY.
-    The download button is disabled until at least one sheet is selected.
-    """
     res = st.session_state.get("results", {})
-    if not res:
-        return
-
+    if not res: return
     st.divider()
     st.markdown("### Export to Excel")
 
-    options = _available_sections()  # only what exists right now
+    options = _available_sections()
     selected_sheets = st.multiselect(
         "Sheets to include",
         options=options,
@@ -439,7 +383,6 @@ def render_export_button(phase_key: str) -> None:
     data, fname, names = build_export_workbook(selected=selected_sheets, ndigits=3, do_autofit=True)
     if names:
         st.caption("Will include: " + ", ".join(names))
-
     st.download_button(
         "⬇️ Export Excel",
         data=(data or b""),
@@ -450,7 +393,7 @@ def render_export_button(phase_key: str) -> None:
     )
 
 # =========================
-# Cross plot (Matplotlib) — auto-scaled for Ts
+# Cross plot (Matplotlib)
 # =========================
 def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predicted Ts (µs/ft)"):
     a = pd.Series(actual, dtype=float)
@@ -471,14 +414,11 @@ def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predict
 
     ax.set_xlim(lo2, hi2)
     ax.set_ylim(lo2, hi2)
-    ax.set_xticks(ticks)
-    ax.set_yticks(ticks)
+    ax.set_xticks(ticks); ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")
 
-    # Generic numeric formatting (2 decimals) in plot; export uses 3 decimals
     fmt = FuncFormatter(lambda x, _: f"{x:.2f}")
-    ax.xaxis.set_major_formatter(fmt)
-    ax.yaxis.set_major_formatter(fmt)
+    ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
 
     ax.set_xlabel(xlabel, fontweight="bold", fontsize=10, color="black")
     ax.set_ylabel(ylabel, fontweight="bold", fontsize=10, color="black")
@@ -486,8 +426,7 @@ def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predict
 
     ax.grid(True, linestyle=":", alpha=0.3)
     for spine in ax.spines.values():
-        spine.set_linewidth(1.1)
-        spine.set_color("#444")
+        spine.set_linewidth(1.1); spine.set_color("#444")
 
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
@@ -496,18 +435,14 @@ def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predict
 # Track plot (Plotly)
 # =========================
 def track_plot(df, include_actual=True):
-    # Depth (or index) on Y
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     if depth_col is not None:
-        y = pd.Series(df[depth_col]).astype(float)
-        ylab = depth_col
-        y_range = [float(y.max()), float(y.min())]  # reverse
+        y = pd.Series(df[depth_col]).astype(float); ylab = depth_col
+        y_range = [float(y.max()), float(y.min())]
     else:
-        y = pd.Series(np.arange(1, len(df) + 1))
-        ylab = "Point Index"
+        y = pd.Series(np.arange(1, len(df) + 1)); ylab = "Point Index"
         y_range = [float(y.max()), float(y.min())]
 
-    # X range from prediction/actual
     x_series = pd.Series(df.get(PRED_COL, pd.Series(dtype=float))).astype(float)
     if include_actual and TARGET in df.columns:
         x_series = pd.concat([x_series, pd.Series(df[TARGET]).astype(float)], ignore_index=True)
@@ -533,9 +468,7 @@ def track_plot(df, include_actual=True):
         ))
 
     fig.update_layout(
-        height=TRACK_H,
-        width=TRACK_W,
-        autosize=False,
+        height=TRACK_H, width=TRACK_W, autosize=False,
         paper_bgcolor="#fff", plot_bgcolor="#fff",
         margin=dict(l=64, r=16, t=36, b=48), hovermode="closest",
         font=dict(size=FONT_SZ, color="#000"),
@@ -543,34 +476,26 @@ def track_plot(df, include_actual=True):
                     bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text=""
     )
-
-    # X axis with NO decimals (Ts is in µs/ft; typically integer-like)
     fig.update_xaxes(
-    title_text="Ts (μs/ft)",
-    title_font=dict(size=20, family=BOLD_FONT, color="#000"),
-    tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-    side="top",
-    range=[xmin, xmax],
-    ticks="outside",
-    tickformat=",.0f",   # ← integers; change to ",.1f" if you want one decimal
-    tickmode="auto",
-    tick0=tick0,
-    showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-    showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
-)
-
+        title_text="Ts (μs/ft)",
+        title_font=dict(size=20, family=BOLD_FONT, color="#000"),
+        tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
+        side="top", range=[xmin, xmax],
+        ticks="outside", tickformat=",.0f", tickmode="auto", tick0=tick0,
+        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+    )
     fig.update_yaxes(
         title_text=ylab,
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-        range=y_range,
-        ticks="outside",
+        range=y_range, ticks="outside",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
     return fig
 
-# ---------- Preview modal (matplotlib) ----------
+# ---------- Preview (matplotlib) ----------
 def preview_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
@@ -582,52 +507,22 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     if n == 1: axes = [axes]
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     if depth_col is not None:
-        idx = pd.to_numeric(df[depth_col], errors="coerce")
+        idx = pd.to_numeric(df[depth_col], errors="coerce"); y_label = depth_col
     else:
-        idx = pd.Series(np.arange(1, len(df) + 1))
-    for ax, col in zip(axes, cols):
-        ax.plot(pd.to_numeric(df[col], errors="coerce"), idx, '-', lw=1.4, color="#333")
-        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+        idx = pd.Series(np.arange(1, len(df) + 1)); y_label = "Point Index"
+    for i, (ax, col) in enumerate(zip(axes, cols)):
+        ax.plot(pd.to_numeric(df[col], errors="coerce"), idx, '-', lw=1.6, color="#333")
+        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
+        ax.set_ylim(float(idx.max()), float(idx.min()))
         ax.grid(True, linestyle=":", alpha=0.3)
-        for s in ax.spines.values(): s.set_visible(True)
-    axes[0].set_ylabel(depth_col if depth_col else "Point Index")
+        if i == 0: ax.set_ylabel(y_label)
+        else:
+            ax.tick_params(labelleft=False); ax.set_ylabel("")
+    fig.tight_layout()
     return fig
 
-# Modal wrapper
-try:
-    dialog = st.dialog
-except AttributeError:
-    def dialog(title):
-        def deco(fn):
-            def wrapper(*args, **kwargs):
-                with st.expander(title, expanded=True):
-                    return fn(*args, **kwargs)
-            return wrapper
-        return deco
-
-def preview_modal(book: dict[str, pd.DataFrame]):
-    if not book:
-        st.info("No data loaded yet."); return
-    names = list(book.keys())
-    tabs = st.tabs(names)
-    for t, name in zip(tabs, names):
-        with t:
-            df = _normalize_columns(book[name])
-            t1, t2 = st.tabs(["Tracks", "Summary"])
-            with t1:
-                st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
-            with t2:
-                present = [c for c in FEATURES if c in df.columns]
-                if present:
-                    tbl = (df[present]
-                            .agg(['min','max','mean','std'])
-                            .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
-                    df_centered_rounded(tbl.reset_index(names="Feature"))
-                else:
-                    st.info("No expected feature columns found to summarize.")
-
 # =========================
-# Load model
+# Load model + meta
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
@@ -656,30 +551,23 @@ except Exception as e:
     st.error(f"Failed to load model: {e}")
     st.stop()
 
-# ---------- Load meta (optional) ----------
+# Prefer Ts meta
 meta = {}
-# Prefer a Ts-specific meta, fall back to a generic one if present
-meta_candidates = [
-    MODELS_DIR / "ts_meta.json",   # ← add this
-    MODELS_DIR / "meta.json",
-    MODELS_DIR / "ym_meta.json",
-]
+meta_candidates = [MODELS_DIR / "ts_meta.json", MODELS_DIR / "meta.json", MODELS_DIR / "ym_meta.json"]
 meta_path = next((p for p in meta_candidates if p.exists()), None)
 if meta_path:
     try:
         meta = json.loads(meta_path.read_text(encoding="utf-8"))
         FEATURES = meta.get("features", FEATURES)
         TARGET   = meta.get("target", TARGET)
-        # If meta provides a custom pred column, respect it
         PRED_COL = meta.get("pred_col", PRED_COL)
     except Exception as e:
         st.warning(f"Could not parse meta file ({meta_path.name}): {e}")
 
-# Optional: version mismatch warning
-import numpy as _np, sklearn as _skl
-mv = meta.get("versions", {})
-if mv:
-    msg = []
+# Optional: version banner (silenced by default)
+if STRICT_VERSION_CHECK and meta.get("versions"):
+    import numpy as _np, sklearn as _skl
+    mv = meta["versions"]; msg=[]
     if mv.get("numpy") and mv["numpy"] != _np.__version__:
         msg.append(f"NumPy {mv['numpy']} expected, running {_np.__version__}")
     if mv.get("scikit_learn") and mv["scikit_learn"] != _skl.__version__:
@@ -700,7 +588,7 @@ st.session_state.setdefault("dev_preview",False)
 st.session_state.setdefault("show_preview_modal", False)
 
 # =========================
-# Branding in Sidebar
+# Sidebar branding
 # =========================
 st.sidebar.markdown(f"""
     <div class="centered-container">
@@ -711,9 +599,6 @@ st.sidebar.markdown(f"""
     """, unsafe_allow_html=True
 )
 
-# =========================
-# Reusable Sticky Header Function
-# =========================
 def sticky_header(title, message):
     st.markdown(
         f"""
@@ -785,13 +670,16 @@ if st.session_state.app_step == "dev":
         if sh_train is None or sh_test is None:
             st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets.</div>', unsafe_allow_html=True)
             st.stop()
-        tr = _normalize_columns(book[sh_train].copy())
-        te = _normalize_columns(book[sh_test].copy())
+
+        # Use meta FEATURES as canonical when normalizing
+        tr = _normalize_columns(book[sh_train].copy(), FEATURES, TARGET)
+        te = _normalize_columns(book[sh_test].copy(),  FEATURES, TARGET)
 
         if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True)
             st.stop()
 
+        # Predict with exactly the columns the model was trained on
         tr[PRED_COL] = model.predict(tr[FEATURES])
         te[PRED_COL] = model.predict(te[FEATURES])
 
@@ -813,10 +701,7 @@ if st.session_state.app_step == "dev":
 
     def _dev_block(df, m):
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
-
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
         st.markdown("""
             <div style='text-align: left; font-size: 0.8em; color: #6b7280; margin-top: -16px; margin-bottom: 8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
@@ -824,27 +709,18 @@ if st.session_state.app_step == "dev":
                 <strong>MAE:</strong> Mean Absolute Error
             </div>
         """, unsafe_allow_html=True)
-
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
-            st.plotly_chart(
-                track_plot(df, include_actual=True),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
+            st.plotly_chart(track_plot(df, include_actual=True), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
         with col_cross:
             st.pyplot(cross_plot_static(df[TARGET], df[PRED_COL]), use_container_width=False)
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
         if "Train" in st.session_state.results:
-            with tab1:
-                _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
+            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
-            with tab2:
-                _dev_block(st.session_state.results["Test"], st.session_state.results["m_test"])
-
-        # Export UI for this phase (dropdown checklist starts empty)
+            with tab2: _dev_block(st.session_state.results["Test"], st.session_state.results["m_test"])
         render_export_button(phase_key="dev")
 
 # =========================
@@ -869,7 +745,7 @@ if st.session_state.app_step == "validate":
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue())
         name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
-        df = _normalize_columns(book[name].copy())
+        df = _normalize_columns(book[name].copy(), FEATURES, TARGET)
         if not ensure_cols(df, FEATURES+[TARGET]): 
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
         df[PRED_COL] = model.predict(df[FEATURES])
@@ -895,10 +771,7 @@ if st.session_state.app_step == "validate":
     if "Validate" in st.session_state.results:
         m = st.session_state.results["m_val"]
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
-
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
         st.markdown("""
             <div style='text-align: left; font-size: 0.8em; color: #6b7280; margin-top: -16px; margin-bottom: 8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
@@ -909,19 +782,13 @@ if st.session_state.app_step == "validate":
 
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
-            st.plotly_chart(
-                track_plot(st.session_state.results["Validate"], include_actual=True),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
+            st.plotly_chart(track_plot(st.session_state.results["Validate"], include_actual=True),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
         with col_cross:
-            st.pyplot(
-                cross_plot_static(st.session_state.results["Validate"][TARGET],
-                                  st.session_state.results["Validate"][PRED_COL]),
-                use_container_width=False
-            )
+            st.pyplot(cross_plot_static(st.session_state.results["Validate"][TARGET],
+                                        st.session_state.results["Validate"][PRED_COL]),
+                      use_container_width=False)
 
-        # Export UI for this phase (dropdown checklist starts empty)
         render_export_button(phase_key="validate")
 
         sv = st.session_state.results["sv_val"]
@@ -950,7 +817,7 @@ if st.session_state.app_step == "predict":
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
-        df = _normalize_columns(book[name].copy())
+        df = _normalize_columns(book[name].copy(), FEATURES, TARGET)
         if not ensure_cols(df, FEATURES): 
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
         df[PRED_COL] = model.predict(df[FEATURES])
@@ -976,31 +843,22 @@ if st.session_state.app_step == "predict":
         with col_left:
             table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "Value": [sv["n"],
-                          round(sv["pred_min"],3),
-                          round(sv["pred_max"],3),
-                          round(sv["pred_mean"],3),
-                          round(sv["pred_std"],3),
-                          f'{sv["oor"]:.1f}%']
+                "Value": [sv["n"], round(sv["pred_min"],3), round(sv["pred_max"],3),
+                          round(sv["pred_mean"],3), round(sv["pred_std"],3), f'{sv["oor"]:.1f}%']
             })
             st.markdown('<div class="st-message-box st-success">Predictions ready ✓</div>', unsafe_allow_html=True)
             df_centered_rounded(table, hide_index=True)
             st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
         with col_right:
-            st.plotly_chart(
-                track_plot(df, include_actual=False),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
+            st.plotly_chart(track_plot(df, include_actual=False),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
-        # Export UI for this phase (dropdown checklist starts empty)
         render_export_button(phase_key="predict")
 
 # =========================
-# Run preview modal after all other elements
+# Preview modal
 # =========================
 if st.session_state.show_preview_modal:
-    # Select the correct workbook bytes for this step
     book_to_preview = {}
     if st.session_state.app_step == "dev":
         book_to_preview = read_book_bytes(st.session_state.dev_file_bytes)
@@ -1015,7 +873,7 @@ if st.session_state.show_preview_modal:
             tabs = st.tabs(names)
             for t, name in zip(tabs, names):
                 with t:
-                    df = _normalize_columns(book_to_preview[name])
+                    df = _normalize_columns(book_to_preview[name], FEATURES, TARGET)
                     t1, t2 = st.tabs(["Tracks", "Summary"])
                     with t1:
                         st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)