Update app.py

app.py

@@ -6,7 +6,7 @@ import pandas as pd
 import numpy as np
 import joblib
 
-# matplotlib only for PREVIEW modal (static thumbnails)
+# matplotlib only for PREVIEW modal
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -15,7 +15,7 @@ import plotly.graph_objects as go
 from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
 # =========================
-# Defaults / Constants
+# Constants (simple & robust)
 # =========================
 FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
 TARGET = "UCS"
@@ -25,34 +25,29 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
-# ——— Exact pixel sizes (match preview strip & square cross-plot) ———
-CROSS_W, CROSS_H = 420, 420            # square cross-plot (px)
-TRACK_W, TRACK_H = 220, 700            # match preview strip look (px)
-FONT_SIZE = 13
+# exact pixel sizes (no container stretching)
+CROSS_W = 420; CROSS_H = 420    # square cross-plot
+TRACK_W = 220; TRACK_H = 700    # match preview strip
+FONT_SZ = 13
 
 # =========================
-# Page / Theme
+# Page / CSS
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
-
-# ---- CSS ----
 st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
 st.markdown(
     """
     <style>
-    .stApp { background: #FFFFFF; }
-    section[data-testid="stSidebar"] { background: #F6F9FC; }
-    .block-container { padding-top: .5rem; padding-bottom: .5rem; }
-    /* primary buttons */
-    .stButton>button{ background:#007bff; color:#fff; font-weight:bold; border-radius:8px; border:none; padding:10px 24px; }
-    .stButton>button:hover{ background:#0056b3; }
-    /* hero */
-    .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
-    .st-hero .brand { width:110px; height:110px; object-fit:contain; }
-    .st-hero h1 { margin:0; line-height:1.05; }
-    .st-hero .tagline { margin:2px 0 0 2px; color:#6b7280; font-size:1.05rem; font-style:italic; }
-    /* tighter top margin for first block */
-    [data-testid="stBlock"]{ margin-top:0 !important; }
+      .stApp { background:#fff; }
+      section[data-testid="stSidebar"] { background:#F6F9FC; }
+      .block-container { padding-top:.5rem; padding-bottom:.5rem; }
+      .stButton>button { background:#007bff; color:#fff; font-weight:600; border-radius:8px; border:none; }
+      .stButton>button:hover { background:#0056b3; }
+      .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
+      .st-hero .brand { width:110px; height:110px; object-fit:contain; }
+      .st-hero h1 { margin:0; line-height:1.05; }
+      .st-hero .tagline { margin:2px 0 0 2px; color:#6b7280; font-size:1.05rem; font-style:italic; }
+      [data-testid="stBlock"]{ margin-top:0 !important; }
     </style>
     """,
     unsafe_allow_html=True
@@ -69,8 +64,7 @@ def inline_logo(path="logo.png") -> str:
     except Exception:
         return ""
 
-def add_password_gate() -> bool:
-    """Branded access screen until correct APP_PASSWORD in Secrets/Env is entered."""
+def add_password_gate() -> None:
     try:
         required = st.secrets.get("APP_PASSWORD", "")
     except Exception:
@@ -88,8 +82,7 @@ def add_password_gate() -> bool:
             </div>
             <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected Area</div>
             <div style="color:#6b7280;margin-bottom:14px;">
-              Admin action required: set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b> (or as an
-              environment variable) and restart the Space.
+              Set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b> (or environment) and restart.
             </div>
             """,
             unsafe_allow_html=True,
@@ -97,7 +90,7 @@ def add_password_gate() -> bool:
         st.stop()
 
     if st.session_state.get("auth_ok", False):
-        return True
+        return
 
     st.markdown(
         f"""
@@ -109,30 +102,24 @@ def add_password_gate() -> bool:
           </div>
         </div>
         <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected</div>
-        <div style="color:#6b7280;margin-bottom:14px;">
-          Please enter your access key to continue.
-        </div>
+        <div style="color:#6b7280;margin-bottom:14px;">Please enter your access key to continue.</div>
         """,
         unsafe_allow_html=True
     )
 
     pwd = st.text_input("Access key", type="password", placeholder="••••••••")
-    col1, _ = st.columns([1, 3])
-    with col1:
-        if st.button("Unlock", type="primary", use_container_width=True):
-            if pwd == required:
-                st.session_state.auth_ok = True
-                st.rerun()
-            else:
-                st.error("Incorrect key. Please try again.")
-
+    if st.button("Unlock", type="primary"):
+        if pwd == required:
+            st.session_state.auth_ok = True
+            st.rerun()
+        else:
+            st.error("Incorrect key.")
     st.stop()
 
-# call it now
 add_password_gate()
 
 # =========================
-# Helpers
+# Utilities
 # =========================
 try:
     dialog = st.dialog
@@ -145,18 +132,8 @@ except AttributeError:
             return wrapper
         return deco
 
-def _get_model_url():
-    return (os.environ.get("MODEL_URL", "") or "").strip()
-
 def rmse(y_true, y_pred): return float(np.sqrt(mean_squared_error(y_true, y_pred)))
 
-def ensure_cols(df, cols):
-    miss = [c for c in cols if c not in df.columns]
-    if miss:
-        st.error(f"Missing columns: {miss}\nFound: {list(df.columns)}")
-        return False
-    return True
-
 @st.cache_resource(show_spinner=False)
 def load_model(model_path: str):
     return joblib.load(model_path)
@@ -167,20 +144,16 @@ 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(data_bytes: bytes):
-    if not data_bytes: return {}
-    try: return parse_excel(data_bytes)
-    except Exception as e:
-        st.error(f"Failed to read Excel: {e}"); return {}
-
+def read_book_bytes(b: bytes): return parse_excel(b) if b else {}
+def ensure_cols(df, cols): return not [c for c in cols if c not in df.columns] or False
 def find_sheet(book, names):
     low2orig = {k.lower(): k for k in book.keys()}
     for nm in names:
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-# ---------- Interactive plotting (fixed sizes, full outline, crisp fonts) ----------
-def cross_plot_interactive(actual, pred):
+# ---------- Plot builders (fixed pixel sizes; full outline; crisp) ----------
+def cross_plot(actual, pred):
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
     lo = float(np.nanmin([a.min(), p.min()]))
@@ -192,7 +165,7 @@ def cross_plot_interactive(actual, pred):
     fig.add_trace(go.Scatter(
         x=a, y=p, mode="markers",
         marker=dict(size=6, color=COLORS["pred"]),
-        hovertemplate="Actual: %{x:.2f}<br>Pred: %{y:.2f}<extra></extra>",
+        hovertemplate="Actual: %{x:.0f}<br>Pred: %{y:.0f}<extra></extra>",
         showlegend=False
     ))
     fig.add_trace(go.Scatter(
@@ -200,174 +173,126 @@ def cross_plot_interactive(actual, pred):
         line=dict(color=COLORS["ref"], width=1.2, dash="dash"),
         hoverinfo="skip", showlegend=False
     ))
-
     fig.update_layout(
-        paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=64, r=16, t=10, b=48),
-        hovermode="closest", font=dict(size=FONT_SIZE),
-        width=CROSS_W, height=CROSS_H
-    )
-    fig.update_xaxes(
-        title_text="<b>Actual UCS</b>",
-        range=[x0, x1], ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
-        automargin=True
-    )
-    fig.update_yaxes(
-        title_text="<b>Predicted UCS</b>",
-        range=[x0, x1], ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
-        scaleanchor="x", scaleratio=1, automargin=True
+        width=CROSS_W, height=CROSS_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
+        margin=dict(l=64, r=18, t=10, b=48), hovermode="closest",
+        font=dict(size=FONT_SZ)
     )
+    fig.update_xaxes(title_text="<b>Actual UCS</b>", range=[x0, x1],
+                     ticks="outside", tickformat=",.0f",
+                     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="<b>Predicted UCS</b>", range=[x0, x1],
+                     ticks="outside", tickformat=",.0f",
+                     showline=True, linewidth=1.2, linecolor="#444", mirror=True, showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+                     scaleanchor="x", scaleratio=1, automargin=True)
     return fig
 
-def depth_or_index_track_interactive(df, include_actual=True):
+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 = df[depth_col]; y_label = depth_col
-        autorange = "reversed"
+        y = df[depth_col]; ylab = depth_col; autorange = "reversed"
     else:
-        y = np.arange(1, len(df) + 1); y_label = "Point Index"
-        autorange = "reversed"
+        y = np.arange(1, len(df) + 1); ylab = "Point Index"; autorange = "reversed"
 
     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:.2f}<br>"+y_label+": %{y}<extra></extra>"
+        hovertemplate="UCS_Pred: %{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:.2f}<br>"+y_label+": %{y}<extra></extra>"
+            hovertemplate="UCS (actual): %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=72, r=18, t=36, b=48),
-        hovermode="closest", font=dict(size=FONT_SIZE),
+        width=TRACK_W, height=TRACK_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
+        margin=dict(l=72, r=18, t=36, b=48), hovermode="closest",
+        font=dict(size=FONT_SZ),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(255,255,255,0.75)", bordercolor="#cccccc", borderwidth=1
+            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
         ),
-        legend_title_text="",
-        width=TRACK_W, height=TRACK_H
-    )
-    fig.update_xaxes(
-        title_text="<b>UCS</b>", side="top",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
-        automargin=True
-    )
-    fig.update_yaxes(
-        title_text=f"<b>{y_label}</b>", autorange=autorange,
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+        legend_title_text=""
     )
+    fig.update_xaxes(title_text="<b>UCS</b>", side="top",
+                     ticks="outside", tickformat=",.0f",
+                     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=f"<b>{ylab}</b>", autorange=autorange,
+                     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 helpers (matplotlib static) ----------
-def make_index_tracks(df: pd.DataFrame, cols: list[str]):
+# ---------- Preview modal (matplotlib) ----------
+def preview_tracks(df: pd.DataFrame, cols: list[str]):
     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 in sheet", ha="center", va="center")
-        ax.axis("off"); return fig
-    width_per = 2.2
-    fig_h = 7.0
-    fig, axes = plt.subplots(1, n, figsize=(width_per * n, fig_h), sharey=True, dpi=100)
+        fig, ax = plt.subplots(figsize=(4, 2)); 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)
     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()
+        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
         ax.grid(True, linestyle=":", alpha=0.3)
-        # draw full box
-        for spine in ax.spines.values(): spine.set_visible(True)
+        for s in ax.spines.values(): s.set_visible(True)
     axes[0].set_ylabel("Point Index")
     return fig
 
-def stats_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
-    cols = [c for c in cols if c in df.columns]
-    if not cols:
-        return pd.DataFrame({"Feature": [], "Min": [], "Max": [], "Mean": [], "Std": []})
-    out = df[cols].agg(['min', 'max', 'mean', 'std']).T
-    out = out.rename(columns={"min": "Min", "max": "Max", "mean": "Mean", "std": "Std"})
-    return out.reset_index().rename(columns={"index": "Feature"})
-
 @dialog("Preview data")
-def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
+def preview_modal(book: dict[str, pd.DataFrame]):
     if not book:
         st.info("No data loaded yet."); return
-    sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
-    sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
-    tabs, data = [], []
-    if sh_train: tabs.append("Train"); data.append(book[sh_train])
-    if sh_test:  tabs.append("Test");  data.append(book[sh_test])
-    if not tabs:
-        first_name = list(book.keys())[0]
-        tabs = [first_name]; data = [book[first_name]]
-    st.write("Use the tabs to switch between Train/Test views (if available).")
-    t_objs = st.tabs(tabs)
-    for t, df in zip(t_objs, data):
+    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(make_index_tracks(df, FEATURES), use_container_width=True)
-            with t2: st.dataframe(stats_table(df, FEATURES), use_container_width=True)
-
-@dialog("Preview data")
-def preview_modal_val(book: dict[str, pd.DataFrame], feature_cols: list[str]):
-    if not book:
-        st.info("No data loaded yet."); return
-    vname = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
-    df = book[vname]
-    t1, t2 = st.tabs(["Tracks", "Summary"])
-    with t1: st.pyplot(make_index_tracks(df, feature_cols), use_container_width=True)
-    with t2: st.dataframe(stats_table(df, feature_cols), use_container_width=True)
+            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"})
+                st.dataframe(tbl.reset_index(names="Feature"), use_container_width=True)
 
 # =========================
-# Model presence
+# Load model (simple)
 # =========================
-MODEL_URL = _get_model_url()
-def ensure_model_present() -> Path:
+def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
-        if p.exists() and p.stat().st_size > 0:
-            return p
-    if not MODEL_URL:
-        return None
+        if p.exists() and p.stat().st_size > 0: return p
+    url = os.environ.get("MODEL_URL", "")
+    if not url: return None
     try:
         import requests
         DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
-        with st.status("Downloading model…", expanded=False):
-            with requests.get(MODEL_URL, stream=True, timeout=30) as r:
-                r.raise_for_status()
-                with open(DEFAULT_MODEL, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=1<<20):
-                        if chunk: f.write(chunk)
+        with requests.get(url, stream=True, timeout=30) as r:
+            r.raise_for_status()
+            with open(DEFAULT_MODEL, "wb") as f:
+                for chunk in r.iter_content(1<<20):
+                    if chunk: f.write(chunk)
         return DEFAULT_MODEL
-    except Exception as e:
-        st.error(f"Failed to download model from MODEL_URL: {e}")
+    except Exception:
         return None
 
-model_path = ensure_model_present()
-if not model_path:
-    st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL in Settings → Variables).")
+mpath = ensure_model()
+if not mpath:
+    st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL).")
     st.stop()
-
 try:
-    model = load_model(str(model_path))
+    model = load_model(str(mpath))
 except Exception as e:
-    st.error(f"Failed to load model: {model_path}\n{e}")
+    st.error(f"Failed to load model: {e}")
     st.stop()
 
-# Meta override/infer
+# Try to pull features from model if provided
 meta_path = MODELS_DIR / "meta.json"
 if meta_path.exists():
     try:
@@ -375,42 +300,20 @@ if meta_path.exists():
         FEATURES = meta.get("features", FEATURES); TARGET = meta.get("target", TARGET)
     except Exception:
         pass
-else:
-    def infer_features_from_model(m):
-        try:
-            if hasattr(m, "feature_names_in_") and len(getattr(m, "feature_names_in_")):
-                return [str(x) for x in m.feature_names_in_]
-        except Exception: pass
-        try:
-            if hasattr(m, "steps") and len(m.steps):
-                last = m.steps[-1][1]
-                if hasattr(last, "feature_names_in_") and len(last.feature_names_in_):
-                    return [str(x) for x in last.feature_names_in_]
-        except Exception: pass
-        return None
-    infer = infer_features_from_model(model)
-    if infer: FEATURES = infer
 
 # =========================
 # Session state
 # =========================
-if "app_step" not in st.session_state: st.session_state.app_step = "intro"
-if "results" not in st.session_state: st.session_state.results = {}
-if "train_ranges" not in st.session_state: st.session_state.train_ranges = None
+st.session_state.setdefault("app_step", "intro")
+st.session_state.setdefault("results", {})
+st.session_state.setdefault("train_ranges", None)
 
-# Dev page file state
+# dev file state
 for k, v in {
-    "dev_ready": False,
-    "dev_file_loaded": False,
-    "dev_previewed": False,
-    "dev_file_signature": None,
-    "dev_preview_request": False,
-    "dev_file_bytes": b"",
-    "dev_file_name": "",
-    "dev_file_rows": 0,
-    "dev_file_cols": 0,
+    "dev_file_name":"", "dev_file_bytes":b"", "dev_file_loaded":False,
+    "dev_preview":False
 }.items():
-    if k not in st.session_state: st.session_state[k] = v
+    st.session_state.setdefault(k, v)
 
 # =========================
 # Hero
@@ -434,384 +337,200 @@ st.markdown(
 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.subheader("Expected Input Features (in Order)")
-    st.markdown(
-        "- Q, gpm — Flow rate (gallons per minute)  \n"
-        "- SPP(psi) — Stand pipe pressure  \n"
-        "- T (kft.lbf) — Torque (thousand foot-pounds)  \n"
-        "- WOB (klbf) — Weight on bit  \n"
-        "- ROP (ft/h) — Rate of penetration"
-    )
     st.subheader("How It Works")
     st.markdown(
-        "1. **Upload your data to build the case and preview the performance of our model.**  \n"
-        "2. Click **Run Model** to compute metrics and plots.  \n"
-        "3. Click **Proceed to Validation** to evaluate on a new dataset.  \n"
-        "4. Click **Proceed to Prediction** for prediction-only (no actual UCS).  \n"
-        "5. Export results to Excel at any time."
+        "1) **Upload your data to build the case and preview the performance of our model.**  \n"
+        "2) Click **Run Model** to compute metrics and plots.  \n"
+        "3) **Proceed to Validation** (with actual UCS) or **Proceed to Prediction** (no UCS)."
     )
-    if st.button("Start Showcase", type="primary", key="start_showcase"):
+    if st.button("Start Showcase", type="primary"):
         st.session_state.app_step = "dev"; st.rerun()
 
 # =========================
-# CASE BUILDING (Development)
+# CASE BUILDING
 # =========================
 if st.session_state.app_step == "dev":
     st.sidebar.header("Case Building (Development)")
-    dev_label = "Upload Data (Excel)" if not st.session_state.dev_file_name else "Replace data (Excel)"
-    train_test_file = st.sidebar.file_uploader(dev_label, type=["xlsx","xls"], key="dev_upload")
-
-    if train_test_file is not None:
-        try:
-            file_bytes = train_test_file.getvalue(); size = len(file_bytes)
-        except Exception:
-            file_bytes = b""; size = 0
-        sig = (train_test_file.name, size)
-        if sig != st.session_state.dev_file_signature and size > 0:
-            st.session_state.dev_file_signature = sig
-            st.session_state.dev_file_name = train_test_file.name
-            st.session_state.dev_file_bytes = file_bytes
-            _book_tmp = read_book_bytes(file_bytes)
-            if _book_tmp:
-                first_df = next(iter(_book_tmp.values()))
-                st.session_state.dev_file_rows = int(first_df.shape[0])
-                st.session_state.dev_file_cols = int(first_df.shape[1])
-                st.session_state.dev_file_loaded = True
-                st.session_state.dev_previewed = False
-                st.session_state.dev_ready = False
-
+    up = st.sidebar.file_uploader("Upload Train/Test Excel", type=["xlsx","xls"])
+    if up is not None:
+        st.session_state.dev_file_bytes = up.getvalue()
+        st.session_state.dev_file_name = up.name
+        st.session_state.dev_file_loaded = True
+        st.session_state.dev_preview = False
     if st.session_state.dev_file_loaded:
-        st.sidebar.caption(
-            f"**Data loaded:** {st.session_state.dev_file_name} • "
-            f"{st.session_state.dev_file_rows} rows × {st.session_state.dev_file_cols} cols"
-        )
+        tmp = read_book_bytes(st.session_state.dev_file_bytes)
+        if tmp:
+            df0 = next(iter(tmp.values()))
+            st.sidebar.caption(f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
-    preview_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded)
-    if preview_btn and st.session_state.dev_file_loaded:
-        st.session_state.dev_preview_request = True
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
+        preview_modal(read_book_bytes(st.session_state.dev_file_bytes))
+        st.session_state.dev_preview = True
 
-    run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
-    # Always show navigation buttons (enabled feel)
-    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()
+    run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+    # always available nav
+    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()
 
-    # helper bar at top
     st.subheader("Case Building (Development)")
-    if st.session_state.dev_ready:
-        st.success("Case has been built and results are displayed below.")
-    elif st.session_state.dev_file_loaded and st.session_state.dev_previewed:
-        st.info("Previewed ✓ — now click **Run Model** to build the case.")
+    if st.session_state.dev_file_loaded and st.session_state.dev_preview:
+        st.info("Previewed ✓ — now click **Run Model**.")
     elif st.session_state.dev_file_loaded:
         st.info("📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
     else:
         st.write("**Upload your data to build a case, then run the model to review development performance.**")
 
-    if st.session_state.dev_preview_request and st.session_state.dev_file_bytes:
-        _book = read_book_bytes(st.session_state.dev_file_bytes)
-        st.session_state.dev_previewed = True
-        st.session_state.dev_preview_request = False
-        preview_modal_dev(_book, FEATURES)
-
-    if run_btn and st.session_state.dev_file_bytes:
-        with st.status("Processing…", expanded=False) as status:
-            book = read_book_bytes(st.session_state.dev_file_bytes)
-            if not book: status.update(label="Failed to read workbook.", state="error"); st.stop()
-            status.update(label="Workbook read ✓")
-            sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
-            sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
-            if sh_train is None or sh_test is None:
-                status.update(label="Workbook must include Train/Training/training2 and Test/Testing/testing2.", state="error"); st.stop()
-            df_tr = book[sh_train].copy(); df_te = book[sh_test].copy()
-            if not (ensure_cols(df_tr, FEATURES + [TARGET]) and ensure_cols(df_te, FEATURES + [TARGET])):
-                status.update(label="Missing required columns.", state="error"); st.stop()
-            status.update(label="Columns validated ✓"); status.update(label="Predicting…")
-
-            df_tr["UCS_Pred"] = model.predict(df_tr[FEATURES])
-            df_te["UCS_Pred"] = model.predict(df_te[FEATURES])
-            st.session_state.results["Train"] = df_tr; st.session_state.results["Test"] = df_te
-
-            st.session_state.results["metrics_train"] = {
-                "R2": r2_score(df_tr[TARGET], df_tr["UCS_Pred"]),
-                "RMSE": rmse(df_tr[TARGET], df_tr["UCS_Pred"]),
-                "MAE": mean_absolute_error(df_tr[TARGET], df_tr["UCS_Pred"]),
-            }
-            st.session_state.results["metrics_test"]  = {
-                "R2": r2_score(df_te[TARGET], df_te["UCS_Pred"]),
-                "RMSE": rmse(df_te[TARGET], df_te["UCS_Pred"]),
-                "MAE": mean_absolute_error(df_te[TARGET], df_te["UCS_Pred"]),
-            }
-
-            tr_min = df_tr[FEATURES].min().to_dict(); tr_max = df_tr[FEATURES].max().to_dict()
-            st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
-
-            st.session_state.dev_ready = True
-            status.update(label="Done ✓", state="complete"); st.rerun()
-
-    # Results
-    if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
+    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"])
+        if sh_train is None or sh_test is None:
+            st.error("Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets."); st.stop()
+        tr = book[sh_train].copy(); te = book[sh_test].copy()
+        if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
+            st.error("Missing required columns."); st.stop()
+        tr["UCS_Pred"] = model.predict(tr[FEATURES])
+        te["UCS_Pred"] = model.predict(te[FEATURES])
+
+        st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
+        st.session_state.results["m_train"]={"R2":r2_score(tr[TARGET],tr["UCS_Pred"]), "RMSE":rmse(tr[TARGET],tr["UCS_Pred"]), "MAE":mean_absolute_error(tr[TARGET],tr["UCS_Pred"])}
+        st.session_state.results["m_test"] ={"R2":r2_score(te[TARGET],te["UCS_Pred"]), "RMSE":rmse(te[TARGET],te["UCS_Pred"]), "MAE":mean_absolute_error(te[TARGET],te["UCS_Pred"])}
+
+        tr_min = tr[FEATURES].min().to_dict(); tr_max = tr[FEATURES].max().to_dict()
+        st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
+        st.success("Case has been built and results are displayed below.")
+
+    if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
 
-        def dev_block(df, metrics):
+        def dev_block(df, m):
             c1,c2,c3 = st.columns(3)
-            c1.metric("R²", f"{metrics['R2']:.4f}")
-            c2.metric("RMSE", f"{metrics['RMSE']:.4f}")
-            c3.metric("MAE", f"{metrics['MAE']:.4f}")
-
-            # layout: spacer | crossplot | spacer | track
-            sp_left, col_cross, sp_mid, col_track, sp_right = st.columns([0.2, 0.6, 0.05, 0.35, 0.2])
-            with col_cross:
-                st.plotly_chart(
-                    cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
-                    use_container_width=False,
-                    config={"displayModeBar": False, "scrollZoom": True}
-                )
-            with col_track:
-                st.plotly_chart(
-                    depth_or_index_track_interactive(df, include_actual=True),
-                    use_container_width=False,
-                    config={"displayModeBar": False, "scrollZoom": True}
-                )
-
-        if "Train" in st.session_state.results:
-            with tab1:
-                dev_block(st.session_state.results["Train"], st.session_state.results["metrics_train"])
-        if "Test" in st.session_state.results:
-            with tab2:
-                dev_block(st.session_state.results["Test"], st.session_state.results["metrics_test"])
+            c1.metric("R²", f"{m['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+            col_left, col_right = st.columns(2)
+            with col_left:
+                st.plotly_chart(cross_plot(df[TARGET], df["UCS_Pred"]),
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            with col_right:
+                st.plotly_chart(track_plot(df, include_actual=True),
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
-        st.markdown("---")
-        sheets = {}; rows = []
         if "Train" in st.session_state.results:
-            sheets["Train_with_pred"] = st.session_state.results["Train"]
-            rows.append({"Split":"Train", **{k:round(v,6) for k,v in st.session_state.results["metrics_train"].items()}})
+            with tab1: dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
-            sheets["Test_with_pred"] = st.session_state.results["Test"]
-            rows.append({"Split":"Test", **{k:round(v,6) for k,v in st.session_state.results["metrics_test"].items()}})
-
-        summary_df = pd.DataFrame(rows) if rows else None
-        try:
-            buf = io.BytesIO()
-            with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                for name, frame in sheets.items():
-                    frame.to_excel(xw, sheet_name=name[:31], index=False)
-                if summary_df is not None:
-                    summary_df.to_excel(xw, sheet_name="Summary", index=False)
-            st.download_button(
-                "Export Development Results to Excel",
-                data=buf.getvalue(),
-                file_name="UCS_Dev_Results.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-        except Exception as e:
-            st.warning(str(e))
+            with tab2: dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
 
 # =========================
 # VALIDATION (with actual UCS)
 # =========================
 if st.session_state.app_step == "validate":
     st.sidebar.header("Validate the Model")
-    validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload")
-    if validation_file is not None:
-        _book_tmp = read_book_bytes(validation_file.getvalue())
-        if _book_tmp:
-            first_df = next(iter(_book_tmp.values()))
-            st.sidebar.caption(f"**Data loaded:** {validation_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
-
-    preview_val_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None))
-    if preview_val_btn and validation_file is not None:
-        _book = read_book_bytes(validation_file.getvalue())
-        preview_modal_val(_book, FEATURES)
-
-    predict_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()
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step = "predict"; st.rerun()
+    up = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"])
+    if up is not None:
+        book = read_book_bytes(up.getvalue())
+        if book:
+            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)):
+        preview_modal(read_book_bytes(up.getvalue()))
+    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()
+    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
     st.subheader("Validate the Model")
-    st.write("Upload a dataset containing the same feature columns and **UCS** to evaluate model performance.")
-
-    if predict_btn and validation_file is not None:
-        with st.status("Predicting…", expanded=False) as status:
-            vbook = read_book_bytes(validation_file.getvalue())
-            if not vbook: status.update(label="Could not read the Validation Excel.", state="error"); st.stop()
-            status.update(label="Workbook read ✓")
-            vname = find_sheet(vbook, ["Validation","Validate","validation2","Val","val"]) or list(vbook.keys())[0]
-            df_val = vbook[vname].copy()
-            if not ensure_cols(df_val, FEATURES + [TARGET]): status.update(label="Missing required columns.", state="error"); st.stop()
-            status.update(label="Columns validated ✓")
-            df_val["UCS_Pred"] = model.predict(df_val[FEATURES])
-            st.session_state.results["Validate"] = df_val
-
-            ranges = st.session_state.train_ranges; oor_table = None; oor_pct = 0.0
-            if ranges:
-                viol = {f: (df_val[f] < ranges[f][0]) | (df_val[f] > ranges[f][1]) for f in FEATURES}
-                any_viol = pd.DataFrame(viol).any(axis=1); oor_pct = float(any_viol.mean()*100.0)
-                if any_viol.any():
-                    offenders = df_val.loc[any_viol, FEATURES].copy()
-                    offenders["Violations"] = pd.DataFrame(viol).loc[any_viol].apply(lambda r: ", ".join([c for c,v in r.items() if v]), axis=1)
-                    offenders.index = offenders.index + 1; oor_table = offenders
-
-            metrics_val = {
-                "R2": r2_score(df_val[TARGET], df_val["UCS_Pred"]),
-                "RMSE": rmse(df_val[TARGET], df_val["UCS_Pred"]),
-                "MAE": mean_absolute_error(df_val[TARGET], df_val["UCS_Pred"])
-            }
-            st.session_state.results["metrics_val"] = metrics_val
-            st.session_state.results["summary_val"] = {
-                "n_points": len(df_val),
-                "pred_min": float(df_val["UCS_Pred"].min()),
-                "pred_max": float(df_val["UCS_Pred"].max()),
-                "oor_pct": oor_pct
-            }
-            st.session_state.results["oor_table"] = oor_table
-            status.update(label="Predictions ready ✓", state="complete")
+    st.write("Upload a dataset with the same **features** and **UCS** to evaluate performance.")
+
+    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.error("Missing required columns."); st.stop()
+        df["UCS_Pred"] = model.predict(df[FEATURES])
+        st.session_state.results["Validate"]=df
+
+        ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
+        if ranges:
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            oor_pct = float(any_viol.mean()*100.0)
+            if any_viol.any():
+                tbl = df.loc[any_viol, FEATURES].copy()
+                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"]={"R2":r2_score(df[TARGET],df["UCS_Pred"]), "RMSE":rmse(df[TARGET],df["UCS_Pred"]), "MAE":mean_absolute_error(df[TARGET],df["UCS_Pred"])}
+        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["oor_tbl"]=tbl
 
     if "Validate" in st.session_state.results:
-        metrics_val = st.session_state.results.get("metrics_val", {})
-        c1, c2, c3 = st.columns(3)
-        c1.metric("R²",   f"{metrics_val.get('R2',0):.4f}")
-        c2.metric("RMSE", f"{metrics_val.get('RMSE',0):.4f}")
-        c3.metric("MAE",  f"{metrics_val.get('MAE',0):.4f}")
-
-        left_sp, col_cross, sp_mid, col_track, sp_right = st.columns([0.2, 0.6, 0.05, 0.35, 0.2])
-        with col_cross:
-            st.plotly_chart(
-                cross_plot_interactive(
-                    st.session_state.results["Validate"][TARGET],
-                    st.session_state.results["Validate"]["UCS_Pred"]),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
-        with col_track:
-            st.plotly_chart(
-                depth_or_index_track_interactive(
-                    st.session_state.results["Validate"], include_actual=True),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
-
-        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
-        if sv["oor_pct"] > 0:
-            st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
-        if oor_table is not None:
+        m = st.session_state.results["m_val"]; sv = st.session_state.results["sv_val"]
+        c1,c2,c3 = st.columns(3)
+        c1.metric("R²", f"{m['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+
+        col_left, col_right = st.columns(2)
+        with col_left:
+            st.plotly_chart(cross_plot(st.session_state.results["Validate"][TARGET],
+                                       st.session_state.results["Validate"]["UCS_Pred"]),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+        with col_right:
+            st.plotly_chart(track_plot(st.session_state.results["Validate"], include_actual=True),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+
+        if sv["oor"] > 0: st.warning("Some inputs fall outside **training min–max** ranges.")
+        if st.session_state.results["oor_tbl"] is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
-            st.dataframe(oor_table, use_container_width=True)
-
-        st.markdown("---")
-        sheets = {"Validate_with_pred": st.session_state.results["Validate"]}
-        rows = []
-        for name, key in [("Train","metrics_train"), ("Test","metrics_test"), ("Validate","metrics_val")]:
-            m = st.session_state.results.get(key)
-            if m: rows.append({"Split": name, **{k: round(v,6) for k,v in m.items()}})
-        summary_df = pd.DataFrame(rows) if rows else None
-        try:
-            buf = io.BytesIO()
-            with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                for name, frame in sheets.items():
-                    frame.to_excel(xw, sheet_name=name[:31], index=False)
-                if summary_df is not None:
-                    summary_df.to_excel(xw, sheet_name="Summary", index=False)
-            st.download_button(
-                "Export Validation Results to Excel",
-                data=buf.getvalue(),
-                file_name="UCS_Validation_Results.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-        except Exception as e:
-            st.warning(str(e))
+            st.dataframe(st.session_state.results["oor_tbl"], use_container_width=True)
 
 # =========================
-# PREDICTION-ONLY (no actual UCS)
+# PREDICTION (no actual UCS)
 # =========================
 if st.session_state.app_step == "predict":
     st.sidebar.header("Prediction (No Actual UCS)")
-    pred_file = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"], key="pred_upload")
-    if pred_file is not None:
-        _book_tmp = read_book_bytes(pred_file.getvalue())
-        if _book_tmp:
-            first_df = next(iter(_book_tmp.values()))
-            st.sidebar.caption(f"**Data loaded:** {pred_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
-
-    preview_pred_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=(pred_file is None))
-    if preview_pred_btn and pred_file is not None:
-        _book = read_book_bytes(pred_file.getvalue())
-        preview_modal_val(_book, FEATURES)
-
-    do_pred = 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()
+    up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
+    if up is not None:
+        book = read_book_bytes(up.getvalue())
+        if book:
+            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)):
+        preview_modal(read_book_bytes(up.getvalue()))
+    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()
 
     st.subheader("Prediction")
-    st.write("Upload a dataset with the feature columns (no **UCS**). You’ll get predicted UCS, a UCS track, and a compact summary.")
-
-    if do_pred and pred_file is not None:
-        with st.status("Predicting…", expanded=False) as status:
-            pbook = read_book_bytes(pred_file.getvalue())
-            if not pbook: status.update(label="Could not read the Excel.", state="error"); st.stop()
-            status.update(label="Workbook read ✓")
-            pname = list(pbook.keys())[0]
-            dfp = pbook[pname].copy()
-            if not ensure_cols(dfp, FEATURES): status.update(label="Missing required columns.", state="error"); st.stop()
-            status.update(label="Columns validated ✓")
-            dfp["UCS_Pred"] = model.predict(dfp[FEATURES])
-            st.session_state.results["PredictOnly"] = dfp
-
-            ranges = st.session_state.train_ranges; oor_pct = 0.0
-            if ranges:
-                any_viol = pd.DataFrame({f: (dfp[f] < ranges[f][0]) | (dfp[f] > ranges[f][1]) for f in FEATURES}).any(axis=1)
-                oor_pct = float(any_viol.mean()*100.0)
-
-            st.session_state.results["summary_predonly"] = {
-                "n_points": len(dfp),
-                "pred_min": float(dfp["UCS_Pred"].min()),
-                "pred_max": float(dfp["UCS_Pred"].max()),
-                "pred_mean": float(dfp["UCS_Pred"].mean()),
-                "pred_std": float(dfp["UCS_Pred"].std(ddof=0)),
-                "oor_pct": oor_pct,
-            }
-            status.update(label="Predictions ready ✓", state="complete")
+    st.write("Upload a dataset with the feature columns (no **UCS**).")
+
+    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.error("Missing required columns."); st.stop()
+        df["UCS_Pred"] = model.predict(df[FEATURES])
+        st.session_state.results["PredictOnly"]=df
+
+        ranges = st.session_state.train_ranges; oor_pct = 0.0
+        if ranges:
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            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)),
+            "oor":oor_pct
+        }
 
     if "PredictOnly" in st.session_state.results:
-        dfp = st.session_state.results["PredictOnly"]
-        sv = st.session_state.results["summary_predonly"]
-
-        # Left summary table (in place of cross-plot), right UCS track
-        left_sp, col_summary, sp_mid, col_track, sp_right = st.columns([0.18, 0.42, 0.05, 0.35, 0.2])
+        df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
 
-        with col_summary:
-            tbl = pd.DataFrame({
+        col_left, col_right = st.columns(2)
+        with col_left:
+            table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "Value":  [sv["n_points"], sv["pred_min"], sv["pred_max"], sv["pred_mean"], sv["pred_std"], f'{sv["oor_pct"]:.1f}%']
+                "Value":  [sv["n"], sv["pred_min"], sv["pred_max"], sv["pred_mean"], sv["pred_std"], f'{sv["oor"]:.1f}%']
             })
             st.success("Predictions ready ✓")
-            st.dataframe(tbl, use_container_width=True, hide_index=True)
-
-            st.caption("**★ OOR** = percentage of rows whose input features fall outside the training min–max range.")
-
-        with col_track:
-            st.plotly_chart(
-                depth_or_index_track_interactive(dfp, include_actual=False),
-                use_container_width=False,
-                config={"displayModeBar": False, "scrollZoom": True}
-            )
-
-        st.markdown("---")
-        try:
-            buf = io.BytesIO()
-            with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                dfp.to_excel(xw, sheet_name="Predictions", index=False)
-                pd.DataFrame([sv]).to_excel(xw, sheet_name="Summary", index=False)
-            st.download_button(
-                "Export Prediction Results to Excel",
-                data=buf.getvalue(),
-                file_name="UCS_Prediction_Results.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-        except Exception as e:
-            st.warning(str(e))
+            st.dataframe(table, use_container_width=True, 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})
 
 # =========================
 # Footer