Update app.py

app.py

@@ -1,3 +1,5 @@
+# app_ucs.py — ST_GeoMech_UCS (Unified workflow like Tc)
+
 import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
@@ -6,7 +8,7 @@ import numpy as np
 import joblib
 from datetime import datetime
 
-# Matplotlib for PREVIEW modal and for the CROSS-PLOT (static)
+# Matplotlib (preview + cross-plot)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -16,128 +18,70 @@ import plotly.graph_objects as go
 from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
-# Constants
+# Constants / Defaults
 # =========================
-FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
-TARGET = "UCS"
+APP_NAME = "ST_GeoMech_UCS"
+TAGLINE  = "Real-Time UCS Tracking While Drilling"
+
+# Default features standardized to match Ts/Tc apps.
+# (Older headers are still accepted via alias map below.)
+FEATURES = [
+    "WOB (klbf)",
+    "Torque (kft.lbf)",
+    "SPP (psi)",
+    "RPM (1/min)",
+    "ROP (ft/h)",
+    "Flow Rate (gpm)",
+]
+TARGET    = "UCS"
+PRED_COL  = "UCS_Pred"
+
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
-# ---- Plot sizing controls ----
-CROSS_W = 350 # px (matplotlib figure size; Streamlit will still scale)
+STRICT_VERSION_CHECK = False  # optional env banner
+
+# ---- Plot sizing ----
+CROSS_W = 350
 CROSS_H = 350
-TRACK_H = 1000 # px (plotly height; width auto-fits column)
-# NEW: Add a TRACK_W variable to control the width
-TRACK_W = 500 # px (plotly width)
+TRACK_H = 1000
+TRACK_W = 500
 FONT_SZ = 13
-BOLD_FONT = "Arial Black, Arial, sans-serif" # used for bold axis titles & ticks
+BOLD_FONT = "Arial Black, Arial, sans-serif"
 
 # =========================
 # Page / CSS
 # =========================
-st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
-
-# General CSS (logo helpers etc.)
+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; }
- .sidebar-header { display:flex; align-items:center; gap:12px; }
- .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;
+ .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; }
+
+ /* Sticky expander & tab header inside preview modal */
+ 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)
 
-# CSS to make sticky headers work correctly by overriding Streamlit's overflow property
-st.markdown("""
-<style>
-/* This targets the main content area */
-.main .block-container {
-    overflow: unset !important;
-}
-
-/* This targets the vertical block that holds all your elements */
-div[data-testid="stVerticalBlock"] {
-    overflow: unset !important;
-}
-</style>
-""", unsafe_allow_html=True)
-
-# Hide uploader helper text ("Drag and drop file here", limits, etc.)
-st.markdown("""
-<style>
-/* Older builds (helper wrapped in a Markdown container) */
-section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
-/* 1.31–1.34: helper is the first child in the dropzone */
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
-/* 1.35+: explicit helper container */
-section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
-/* Fallback: any paragraph/small text inside the uploader */
-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;    /* adjust if your expander header height differs */
- z-index: 9;
- background: #fff;
- padding-top: 6px;
-}
-</style>
-""", unsafe_allow_html=True)
-
-# Center text in all pandas Styler tables (headers + cells)
 TABLE_CENTER_CSS = [
     dict(selector="th", props=[("text-align", "center")]),
     dict(selector="td", props=[("text-align", "center")]),
 ]
 
-# NEW: CSS for the message box
-st.markdown("""
-<style>
-.st-message-box {
-    background-color: #f0f2f6;
-    color: #333333;
-    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
 # =========================
@@ -165,7 +109,7 @@ def add_password_gate() -> None:
     st.sidebar.markdown(f"""
         <div class="centered-container">
             <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-            <div style='font-weight:800;font-size:1.2rem; margin-top: 10px;'>ST_GeoMech_UCS</div>
+            <div style='font-weight:800;font-size:1.2rem; margin-top: 10px;'>{APP_NAME}</div>
             <div style='color:#667085;'>Smart Thinking • Secure Access</div>
         </div>
         """, unsafe_allow_html=True
@@ -191,6 +135,7 @@ 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")
+    if np.all(a == a[0]) or np.all(p == p[0]): return float("nan")
     return float(np.corrcoef(a, p)[0, 1])
 
 @st.cache_resource(show_spinner=False)
@@ -203,9 +148,55 @@ 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 (accept legacy headers) ----
+def _build_alias_map(canonical_features: list[str], target_name: str) -> dict:
+    """
+    Map common header variants -> canonical names (from meta FEATURES).
+    """
+    def pick(expected_list, variants):
+        for v in variants:
+            if v in expected_list:
+                return v
+        return variants[0]
+
+    can_WOB    = pick(canonical_features, ["WOB (klbf)", "WOB, klbf", "WOB(klbf)", "WOB( klbf)"])
+    can_TORQUE = pick(canonical_features, ["Torque (kft.lbf)", "Torque(kft.lbf)", "T (kft.lbf)", "TORQUE(kft.lbf)"])
+    can_SPP    = pick(canonical_features, ["SPP (psi)", "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)", "Q, gpm", "Flow Rate, gpm", "Flow Rate,gpm", "Flow Rate , gpm"])
+    can_DEPTH  = "Depth (ft)"
+
+    alias = {
+        # Features
+        "WOB (klbf)": can_WOB, "WOB, klbf": can_WOB, "WOB(klbf)": can_WOB, "WOB( klbf)": can_WOB,
+        "Torque (kft.lbf)": can_TORQUE, "Torque(kft.lbf)": can_TORQUE, "T (kft.lbf)": can_TORQUE, "TORQUE(kft.lbf)": can_TORQUE,
+        "SPP (psi)": can_SPP, "SPP(psi)": can_SPP,
+        "RPM (1/min)": can_RPM, "RPM(1/min)": can_RPM,
+        "ROP (ft/h)": can_ROP, "ROP(ft/h)": can_ROP,
+        "Flow Rate (gpm)": can_FR, "Q, gpm": can_FR, "Flow Rate, gpm": can_FR, "Flow Rate,gpm": can_FR, "Flow Rate , gpm": can_FR,
+
+        # Depth (plot only)
+        "Depth (ft)": can_DEPTH, "Depth, ft": can_DEPTH, "Depth(ft)": can_DEPTH, "DEPTH, ft": can_DEPTH,
+
+        # Target aliases
+        "UCS": target_name,
+        "UCS (psi)": target_name,
+        "UCS_Actual": target_name,
+    }
+    return alias
+
+def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], target_name: str) -> pd.DataFrame:
+    out = df.copy()
+    out.columns = [str(c).strip().replace(" ,", ",").replace(",  ", ", ").replace("  ", " ") for c in out.columns]
+    alias = _build_alias_map(canonical_features, target_name)
+    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, cols):
+def ensure_cols(df: pd.DataFrame, cols: list[str]) -> bool:
     miss = [c for c in cols if c not in df.columns]
     if miss:
         st.error(f"Missing columns: {miss}\nFound: {list(df.columns)}")
@@ -222,20 +213,25 @@ def _nice_tick0(xmin: float, step: int = 100) -> float:
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
 def df_centered_rounded(df: pd.DataFrame, hide_index=True):
-    """Center headers & cells; format numeric columns to 2 decimals."""
     out = df.copy()
     numcols = out.select_dtypes(include=[np.number]).columns
     styler = (
         out.style
-            .format({c: "{:.2f}" for c in numcols})
-            .set_properties(**{"text-align": "center"})
-            .set_table_styles(TABLE_CENTER_CSS)
+           .format({c: "{:.2f}" for c in numcols})
+           .set_properties(**{"text-align": "center"})
+           .set_table_styles(TABLE_CENTER_CSS)
     )
     st.dataframe(styler, use_container_width=True, hide_index=hide_index)
-# === NEW: Excel export helpers =================================================
 
+# ---------- Build X exactly as trained ----------
+def _make_X(df: pd.DataFrame, features: list[str]) -> pd.DataFrame:
+    X = df.reindex(columns=features, copy=False)
+    for c in features:
+        X[c] = pd.to_numeric(X[c], errors="coerce")
+    return X
+
+# === Excel export helpers =================================================
 def _excel_engine() -> str:
-    """Prefer xlsxwriter for better formatting; fall back to openpyxl if missing."""
     try:
         import xlsxwriter  # noqa: F401
         return "xlsxwriter"
@@ -243,7 +239,6 @@ def _excel_engine() -> str:
         return "openpyxl"
 
 def _excel_safe_name(name: str) -> str:
-    """Excel sheet names: max 31 chars, no []:*?/\\."""
     bad = '[]:*?/\\'
     safe = ''.join('_' if ch in bad else ch for ch in str(name))
     return safe[:31]
@@ -272,44 +267,50 @@ def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
     df.columns = ["Feature", "Min", "Max"]
     return _round_numeric(df)
 
-def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
-    """
-    Build a multi-sheet Excel workbook (as bytes) from what's currently in session state.
-    Returns: (bytes_or_None, filename_or_None, [sheet_names])
-    """
+def _available_sections() -> list[str]:
+    res = st.session_state.get("results", {})
+    sections = []
+    if "Train" in res:        sections += ["Training","Training_Metrics","Training_Summary"]
+    if "Test" in res:         sections += ["Testing","Testing_Metrics","Testing_Summary"]
+    if "Validate" in res:     sections += ["Validation","Validation_Metrics","Validation_Summary","Validation_OOR"]
+    if "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary"]
+    if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
+    sections += ["Info"]
+    return sections
+
+def build_export_workbook(selected: list[str] | None = None) -> tuple[bytes|None, str|None, list[str]]:
     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 "Train" in res:
+    if ("Training" in (selected or _available_sections())) and "Train" in res:
         tr = _round_numeric(res["Train"])
         sheets["Training"] = tr; order.append("Training")
         m = res.get("m_train", {})
         if m:
             sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Training_Metrics")
-        tr_cols = FEATURES + ([TARGET] if TARGET in tr.columns else []) + (["UCS_Pred"] if "UCS_Pred" in tr.columns else [])
+        tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in tr.columns]
         s = _summary_table(tr, tr_cols)
         if not s.empty:
             sheets["Training_Summary"] = s; order.append("Training_Summary")
 
     # Testing
-    if "Test" in res:
+    if ("Testing" in (selected or _available_sections())) and "Test" in res:
         te = _round_numeric(res["Test"])
         sheets["Testing"] = te; order.append("Testing")
         m = res.get("m_test", {})
         if m:
             sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Testing_Metrics")
-        te_cols = FEATURES + ([TARGET] if TARGET in te.columns else []) + (["UCS_Pred"] if "UCS_Pred" in te.columns else [])
+        te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in te.columns]
         s = _summary_table(te, te_cols)
         if not s.empty:
             sheets["Testing_Summary"] = s; order.append("Testing_Summary")
 
     # Validation
-    if "Validate" in res:
+    if ("Validation" in (selected or _available_sections())) and "Validate" in res:
         va = _round_numeric(res["Validate"])
         sheets["Validation"] = va; order.append("Validation")
         m = res.get("m_val", {})
@@ -320,32 +321,34 @@ def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
             sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Validation_Summary")
         oor_tbl = res.get("oor_tbl")
         if oor_tbl is not None and isinstance(oor_tbl, pd.DataFrame) and not oor_tbl.empty:
-            sheets["Validation_OOR"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_OOR")
+            sheets["Validation_ORE"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_ORE")
 
-    # Prediction (no actual)
-    if "PredictOnly" in res:
+    # Prediction
+    if ("Prediction" in (selected or _available_sections())) and "PredictOnly" in res:
         pr = _round_numeric(res["PredictOnly"])
         sheets["Prediction"] = pr; order.append("Prediction")
         sv = res.get("sv_pred", {})
         if sv:
             sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Prediction_Summary")
 
-    # Training ranges (from dev step)
+    # Ranges
     tr_ranges = st.session_state.get("train_ranges")
-    if tr_ranges:
+    if ("Training_Ranges" in (selected or _available_sections())) and tr_ranges:
         rr = _train_ranges_df(tr_ranges)
         if not rr.empty:
             sheets["Training_Ranges"] = rr; order.append("Training_Ranges")
 
-    # Info sheet
+    # Info
     info = pd.DataFrame([
-        {"Key": "Target", "Value": TARGET},
-        {"Key": "Features", "Value": ", ".join(FEATURES)},
+        {"Key": "AppName",    "Value": APP_NAME},
+        {"Key": "Tagline",    "Value": TAGLINE},
+        {"Key": "Target",     "Value": TARGET},
+        {"Key": "PredColumn", "Value": PRED_COL},
+        {"Key": "Features",   "Value": ", ".join(FEATURES)},
         {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
     ])
     sheets["Info"] = info; order.append("Info")
 
-    # Write workbook to memory
     bio = io.BytesIO()
     with pd.ExcelWriter(bio, engine=_excel_engine()) as writer:
         for name in order:
@@ -356,63 +359,80 @@ def build_export_workbook() -> tuple[bytes|None, str|None, list[str]]:
     fname = f"UCS_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
-def render_export_button(key: str = "export_main") -> None:
-    """Bottom-of-page export button (main content area)."""
-    data, fname, names = build_export_workbook()
+def render_export_button(phase_key: str) -> None:
+    res = st.session_state.get("results", {})
+    if not res: return
     st.divider()
     st.markdown("### Export to Excel")
+
+    options = _available_sections()
+    selected_sheets = st.multiselect(
+        "Sheets to include",
+        options=options,
+        default=[],
+        placeholder="Choose option(s)",
+        help="Pick the sheets you want to include in the Excel export.",
+        key=f"sheets_{phase_key}",
+    )
+
+    if not selected_sheets:
+        st.caption("Select one or more sheets above to enable the export.")
+        st.download_button(
+            label="⬇️ Export Excel",
+            data=b"",
+            file_name="UCS_Export.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            disabled=True,
+            key=f"download_{phase_key}",
+        )
+        return
+
+    data, fname, names = build_export_workbook(selected=selected_sheets)
     if names:
-        st.caption("Includes sheets: " + ", ".join(names))
+        st.caption("Will include: " + ", ".join(names))
     st.download_button(
-        label="⬇️ Export Excel",
+        "⬇️ Export Excel",
         data=(data or b""),
         file_name=(fname or "UCS_Export.xlsx"),
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         disabled=(data is None),
-        help="Exports all available results, metrics, summaries, OOR, training ranges, and info.",
-        key=key,
+        key=f"download_{phase_key}",
     )
-# ================================================================================
 
 # =========================
-# Cross plot (Matplotlib, fixed limits & ticks)
+# Cross plot (Matplotlib)
 # =========================
 def cross_plot_static(actual, pred):
     a = pd.Series(actual, dtype=float)
     p = pd.Series(pred, dtype=float)
 
-    fixed_min, fixed_max = 6000, 10000
-    ticks = np.arange(fixed_min, fixed_max + 1, 1000)
+    # Use data-driven limits with a small pad (or keep your fixed 6000–10000 if you prefer)
+    lo = float(min(a.min(), p.min()))
+    hi = float(max(a.max(), p.max()))
+    pad = 0.03 * (hi - lo if hi > lo else 1.0)
+    lo2, hi2 = lo - pad, hi + pad
+    ticks = np.linspace(lo2, hi2, 5)
 
     dpi = 110
-    fig, ax = plt.subplots(
-        figsize=(CROSS_W / dpi, CROSS_H / dpi),
-        dpi=dpi,
-        constrained_layout=False
-    )
+    fig, ax = plt.subplots(figsize=(CROSS_W / dpi, CROSS_H / dpi), dpi=dpi, constrained_layout=False)
 
     ax.scatter(a, p, s=14, c=COLORS["pred"], alpha=0.9, linewidths=0)
-    ax.plot([fixed_min, fixed_max], [fixed_min, fixed_max],
-            linestyle="--", linewidth=1.2, color=COLORS["ref"])
+    ax.plot([lo2, hi2], [lo2, hi2], linestyle="--", linewidth=1.2, color=COLORS["ref"])
 
-    ax.set_xlim(fixed_min, fixed_max)
-    ax.set_ylim(fixed_min, fixed_max)
-    ax.set_xticks(ticks)
-    ax.set_yticks(ticks)
-    ax.set_aspect("equal", adjustable="box") # true 45°
+    ax.set_xlim(lo2, hi2); ax.set_ylim(lo2, hi2)
+    ax.set_xticks(ticks);  ax.set_yticks(ticks)
+    ax.set_aspect("equal", adjustable="box")
 
-    fmt = FuncFormatter(lambda x, _: f"{int(x):,}")
-    ax.xaxis.set_major_formatter(fmt)
-    ax.yaxis.set_major_formatter(fmt)
+    fmt = FuncFormatter(lambda x, _: f"{x:,.0f}")
+    ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
 
-    ax.set_xlabel("Actual UCS (psi)", fontweight="bold", fontsize=10, color="black")
+    ax.set_xlabel("Actual UCS (psi)",    fontweight="bold", fontsize=10, color="black")
     ax.set_ylabel("Predicted UCS (psi)", fontweight="bold", fontsize=10, color="black")
     ax.tick_params(labelsize=6, colors="black")
 
     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
@@ -423,16 +443,13 @@ def cross_plot_static(actual, pred):
 def track_plot(df, include_actual=True):
     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())]  # reversed
     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 (UCS) range & ticks
-    x_series = pd.Series(df.get("UCS_Pred", pd.Series(dtype=float))).astype(float)
+    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)
     x_lo, x_hi = float(x_series.min()), float(x_series.max())
@@ -441,45 +458,36 @@ def track_plot(df, include_actual=True):
     tick0 = _nice_tick0(xmin, step=100)
 
     fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=df["UCS_Pred"], y=y, mode="lines",
-        line=dict(color=COLORS["pred"], width=1.8),
-        name="UCS_Pred",
-        hovertemplate="UCS_Pred: %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
-    ))
+    if PRED_COL in df.columns:
+        fig.add_trace(go.Scatter(
+            x=df[PRED_COL], y=y, mode="lines",
+            line=dict(color=COLORS["pred"], width=1.8),
+            name=PRED_COL,
+            hovertemplate=f"{PRED_COL}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
+        ))
     if include_actual and TARGET in df.columns:
         fig.add_trace(go.Scatter(
             x=df[TARGET], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
-            name="UCS (actual)",
-            hovertemplate="UCS (actual): %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
+            name=f"{TARGET} (actual)",
+            hovertemplate=f"{TARGET}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        height=TRACK_H,
-        width=TRACK_W, # Set the width here
-        autosize=False, # Disable autosizing to respect the width
+        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"),
-        legend=dict(
-            x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
-        ),
+        legend=dict(x=0.98, y=0.05, xanchor="right", yanchor="bottom",
+                    bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text=""
     )
-
-    # Bold, black axis titles & ticks
     fig.update_xaxes(
         title_text="UCS (psi)",
         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,
+        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
     )
@@ -487,64 +495,58 @@ def track_plot(df, include_actual=True):
         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]):
+    """
+    Multi-track quick-look:
+      - distinct color per input (stable tab20 palette)
+      - shared Y & reversed (Depth down if available)
+    """
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
     if n == 0:
         fig, ax = plt.subplots(figsize=(4, 2))
-        ax.text(0.5,0.5,"No selected columns",ha="center",va="center"); ax.axis("off")
+        ax.text(0.5, 0.5, "No selected columns", ha="center", va="center"); ax.axis("off")
         return fig
-    fig, axes = plt.subplots(1, n, figsize=(2.2*n, 7.0), sharey=True, dpi=100)
+
+    # Depth or fallback
+    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")
+        y_label = depth_col
+    else:
+        idx = pd.Series(np.arange(1, len(df) + 1))
+        y_label = "Point Index"
+
+    cmap = plt.get_cmap("tab20")
+    col_colors = {col: cmap(i % cmap.N) for i, col in enumerate(cols)}
+
+    fig, axes = plt.subplots(1, n, figsize=(2.3 * n, 7.0), sharey=True, dpi=100)
     if n == 1: axes = [axes]
-    idx = np.arange(1, len(df) + 1)
-    for ax, col in zip(axes, cols):
-        ax.plot(df[col], idx, '-', lw=1.4, color="#333")
-        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+
+    y_min, y_max = float(idx.min()), float(idx.max())
+    for i, (ax, col) in enumerate(zip(axes, cols)):
+        x = pd.to_numeric(df[col], errors="coerce")
+        ax.plot(x, idx, '-', lw=1.8, color=col_colors[col])
+        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
+        ax.set_ylim(y_max, y_min)  # reversed
         ax.grid(True, linestyle=":", alpha=0.3)
-        for s in ax.spines.values(): s.set_visible(True)
-    axes[0].set_ylabel("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 (Streamlit compatibility)
-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 = book[name]
-            t1, t2 = st.tabs(["Tracks", "Summary"])
-            with t1:
-                st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
-            with t2:
-                tbl = (df[FEATURES]
-                        .agg(['min','max','mean','std'])
-                        .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
-                df_centered_rounded(tbl.reset_index(names="Feature"))
-
 # =========================
-# Load model
+# Load model + meta
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
@@ -573,13 +575,29 @@ except Exception as e:
     st.error(f"Failed to load model: {e}")
     st.stop()
 
-meta_path = MODELS_DIR / "meta.json"
-if meta_path.exists():
+# Prefer UCS-specific meta
+meta = {}
+meta_candidates = [MODELS_DIR / "ucs_meta.json", MODELS_DIR / "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)
-    except Exception:
-        pass
+        FEATURES = meta.get("features", FEATURES)
+        TARGET   = meta.get("target", TARGET)
+        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 banner
+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__:
+        msg.append(f"scikit-learn {mv['scikit_learn']} expected, running {_skl.__version__}")
+    if msg:
+        st.warning("Environment mismatch: " + " | ".join(msg))
 
 # =========================
 # Session state
@@ -591,35 +609,27 @@ st.session_state.setdefault("dev_file_name","")
 st.session_state.setdefault("dev_file_bytes",b"")
 st.session_state.setdefault("dev_file_loaded",False)
 st.session_state.setdefault("dev_preview",False)
-st.session_state.setdefault("show_preview_modal", False) # New state variable
+st.session_state.setdefault("show_preview_modal", False)
 
 # =========================
-# Branding in Sidebar
+# Sidebar branding
 # =========================
 st.sidebar.markdown(f"""
     <div class="centered-container">
         <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-        <div style='font-weight:800;font-size:1.2rem;'>ST_GeoMech_UCS</div>
-        <div style='color:#667085;'>Real-Time UCS Tracking While Drilling</div>
+        <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
+        <div style='color:#667085;'>{TAGLINE}</div>
     </div>
     """, unsafe_allow_html=True
 )
 
-# =========================
-# Reusable Sticky Header Function
-# =========================
 def sticky_header(title, message):
     st.markdown(
         f"""
         <style>
         .sticky-container {{
-            position: sticky;
-            top: 0;
-            background-color: white;
-            z-index: 100;
-            padding-top: 10px;
-            padding-bottom: 10px;
-            border-bottom: 1px solid #eee;
+            position: sticky; top: 0; background-color: white; z-index: 100;
+            padding-top: 10px; padding-bottom: 10px; border-bottom: 1px solid #eee;
         }}
         </style>
         <div class="sticky-container">
@@ -635,10 +645,10 @@ def sticky_header(title, message):
 # =========================
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data.")
+    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate **UCS** from drilling data.")
     st.subheader("How It Works")
     st.markdown(
-        "1) **Upload your data to build the case and preview the performance of our model.** \n"
+        "1) **Upload your data to build the case and preview the model performance.** \n"
         "2) Click **Run Model** to compute metrics and plots. \n"
         "3) **Proceed to Validation** (with actual UCS) or **Proceed to Prediction** (no UCS)."
     )
@@ -663,14 +673,13 @@ if st.session_state.app_step == "dev":
             st.sidebar.caption(f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
     if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
         st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
     if st.sidebar.button("Proceed to Validation ▶", use_container_width=True): st.session_state.app_step="validate"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
-    # Apply sticky header
     if st.session_state.dev_file_loaded and st.session_state.dev_preview:
         sticky_header("Case Building", "Previewed ✓ — now click **Run Model**.")
     elif st.session_state.dev_file_loaded:
@@ -681,27 +690,31 @@ if st.session_state.app_step == "dev":
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
         sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
-        sh_test = find_sheet(book, ["Test","Testing","testing2","test","testing"])
+        sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
         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 = book[sh_train].copy(); te = book[sh_test].copy()
+
+        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()
-        tr["UCS_Pred"] = model.predict(tr[FEATURES])
-        te["UCS_Pred"] = model.predict(te[FEATURES])
+
+        tr[PRED_COL] = model.predict(_make_X(tr, FEATURES))
+        te[PRED_COL] = model.predict(_make_X(te, FEATURES))
 
         st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
         st.session_state.results["m_train"]={
-            "R": pearson_r(tr[TARGET], tr["UCS_Pred"]),
-            "RMSE": rmse(tr[TARGET], tr["UCS_Pred"]),
-            "MAE": mean_absolute_error(tr[TARGET], tr["UCS_Pred"])
+            "R":   pearson_r(tr[TARGET], tr[PRED_COL]),
+            "RMSE": rmse(tr[TARGET], tr[PRED_COL]),
+            "MAE":  mean_absolute_error(tr[TARGET], tr[PRED_COL])
         }
         st.session_state.results["m_test"]={
-            "R": pearson_r(te[TARGET], te["UCS_Pred"]),
-            "RMSE": rmse(te[TARGET], te["UCS_Pred"]),
-            "MAE": mean_absolute_error(te[TARGET], te["UCS_Pred"])
+            "R":   pearson_r(te[TARGET], te[PRED_COL]),
+            "RMSE": rmse(te[TARGET], te[PRED_COL]),
+            "MAE":  mean_absolute_error(te[TARGET], te[PRED_COL])
         }
 
         tr_min = tr[FEATURES].min().to_dict(); tr_max = tr[FEATURES].max().to_dict()
@@ -710,11 +723,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}")
-
-        # NEW: Footer for metric abbreviations
+        c1.metric("R", f"{m['R']:.3f}"); 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>
@@ -722,18 +731,11 @@ if st.session_state.app_step == "dev":
                 <strong>MAE:</strong> Mean Absolute Error
             </div>
         """, unsafe_allow_html=True)
-
-        # 2-column layout, big gap (prevents overlap)
         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, # Set to False to honor the width in track_plot()
-                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["UCS_Pred"]), use_container_width=False)
-
+            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"])
@@ -741,6 +743,7 @@ if st.session_state.app_step == "dev":
             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"])
+        render_export_button(phase_key="dev")
 
 # =========================
 # VALIDATION (with actual UCS)
@@ -754,7 +757,7 @@ if st.session_state.app_step == "validate":
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
     go_btn = st.sidebar.button("Predict & Validate", type="primary", use_container_width=True)
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
@@ -764,9 +767,10 @@ 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 = book[name].copy()
-        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["UCS_Pred"] = model.predict(df[FEATURES])
+        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(_make_X(df, FEATURES))
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
@@ -777,23 +781,21 @@ if st.session_state.app_step == "validate":
                 tbl = df.loc[any_viol, FEATURES].copy()
                 for c in FEATURES:
                     if pd.api.types.is_numeric_dtype(tbl[c]): tbl[c] = tbl[c].round(2)
-                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
+                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(
+                    lambda r:", ".join([c for c,v in r.items() if v]), axis=1
+                )
         st.session_state.results["m_val"]={
-            "R": pearson_r(df[TARGET], df["UCS_Pred"]),
-            "RMSE": rmse(df[TARGET], df["UCS_Pred"]),
-            "MAE": mean_absolute_error(df[TARGET], df["UCS_Pred"])
+            "R": pearson_r(df[TARGET], df[PRED_COL]),
+            "RMSE": rmse(df[TARGET], df[PRED_COL]),
+            "MAE": mean_absolute_error(df[TARGET], df[PRED_COL])
         }
-        st.session_state.results["sv_val"]={"n":len(df),"pred_min":float(df["UCS_Pred"].min()),"pred_max":float(df["UCS_Pred"].max()),"oor":oor_pct}
+        st.session_state.results["sv_val"]={"n":len(df), "pred_min":float(df[PRED_COL].min()), "pred_max":float(df[PRED_COL].max()), "oor":oor_pct}
         st.session_state.results["oor_tbl"]=tbl
 
     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}")
-
-        # NEW: Footer for metric abbreviations
+        c1.metric("R", f"{m['R']:.3f}"); 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>
@@ -801,20 +803,17 @@ if st.session_state.app_step == "validate":
                 <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(st.session_state.results["Validate"], include_actual=True),
-                use_container_width=False, # Set to False to honor the width in track_plot()
-                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"]["UCS_Pred"]),
-                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)
+
+        render_export_button(phase_key="validate")
 
         sv = st.session_state.results["sv_val"]
         if sv["oor"] > 0: st.markdown('<div class="st-message-box st-warning">Some inputs fall outside **training min–max** ranges.</div>', unsafe_allow_html=True)
@@ -834,7 +833,7 @@ if st.session_state.app_step == "predict":
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
     go_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
 
@@ -842,9 +841,10 @@ 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 = book[name].copy()
-        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["UCS_Pred"] = model.predict(df[FEATURES])
+        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(_make_X(df, FEATURES))
         st.session_state.results["PredictOnly"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0
@@ -853,10 +853,10 @@ if st.session_state.app_step == "predict":
             oor_pct = float(any_viol.mean()*100.0)
         st.session_state.results["sv_pred"]={
             "n":len(df),
-            "pred_min":float(df["UCS_Pred"].min()),
-            "pred_max":float(df["UCS_Pred"].max()),
-            "pred_mean":float(df["UCS_Pred"].mean()),
-            "pred_std":float(df["UCS_Pred"].std(ddof=0)),
+            "pred_min":float(df[PRED_COL].min()),
+            "pred_max":float(df[PRED_COL].max()),
+            "pred_mean":float(df[PRED_COL].mean()),
+            "pred_std":float(df[PRED_COL].std(ddof=0)),
             "oor":oor_pct
         }
 
@@ -867,28 +867,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"],2),
-                          round(sv["pred_max"],2),
-                          round(sv["pred_mean"],2),
-                          round(sv["pred_std"],2),
-                          f'{sv["oor"]:.1f}%']
+                "Value": [sv["n"], round(sv["pred_min"],2), round(sv["pred_max"],2),
+                          round(sv["pred_mean"],2), round(sv["pred_std"],2), 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, # Set to False to honor the width in track_plot()
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
+            st.plotly_chart(track_plot(df, include_actual=False),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+
+        render_export_button(phase_key="predict")
 
 # =========================
-# Run preview modal after all other elements
+# Preview modal
 # =========================
 if st.session_state.show_preview_modal:
-    # Get the correct book based on the current app step
     book_to_preview = {}
     if st.session_state.app_step == "dev":
         book_to_preview = read_book_bytes(st.session_state.dev_file_bytes)
@@ -903,28 +897,25 @@ if st.session_state.show_preview_modal:
             tabs = st.tabs(names)
             for t, name in zip(tabs, names):
                 with t:
-                    df = 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)
                     with t2:
-                        tbl = (df[FEATURES]
-                                 .agg(['min','max','mean','std'])
-                                 .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
-                        df_centered_rounded(tbl.reset_index(names="Feature"))
-    # Reset the state variable after the modal is displayed
+                        feat_present = [c for c in FEATURES if c in df.columns]
+                        if not feat_present:
+                            st.info("No feature columns found to summarize.")
+                        else:
+                            tbl = (
+                                df[feat_present]
+                                  .agg(['min','max','mean','std'])
+                                  .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+                                  .reset_index(names="Feature")
+                            )
+                            df_centered_rounded(tbl)
+
     st.session_state.show_preview_modal = False
 
-# === Bottom-of-page Export (per step) =========================================
-if st.session_state.app_step in ("dev", "validate", "predict"):
-    has_results = any(
-        k in st.session_state.results
-        for k in ("Train", "Test", "Validate", "PredictOnly")
-    )
-    if has_results:
-        # Unique key per step avoids duplicate-widget clashes when switching steps
-        render_export_button(key=f"export_{st.session_state.app_step}")
-# ==============================================================================
 # =========================
 # Footer
 # =========================