Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py — ST_Sonic_Ts (Shear Slowness Ts)
+# app.py — ST_GeoMech_SMW
 
 import io, json, os, base64, math
 from pathlib import Path
@@ -8,7 +8,7 @@ import numpy as np
 import joblib
 from datetime import datetime
 
-# Matplotlib (static plots)
+# Matplotlib (static)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -18,13 +18,13 @@ import plotly.graph_objects as go
 from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
-# Constants (Ts variant)
+# Constants / Config
 # =========================
-APP_NAME = "ST_Log_Sonic (Ts)"
-TAGLINE  = "Real-Time Shear Slowness (Ts) Prediction"
+APP_NAME = "ST_GeoMech_SMW"
+TAGLINE  = "Real-Time Upper/Lower Mud Weight (MW) Limits For Safe Drilling"
 
-# Defaults (overridden by ts_meta.json if present)
-FEATURES  = [
+# Defaults (can be overridden by meta files)
+FEATURES_DEFAULT = [
     "WOB (klbf)",
     "Torque (kft.lbf)",
     "SPP (psi)",
@@ -32,18 +32,31 @@ FEATURES  = [
     "ROP (ft/h)",
     "Flow Rate (gpm)",
 ]
-TARGET    = "Ts (us/ft_Actual)"
-PRED_COL  = "Ts_Pred"
+
+TARGET_BO_DEFAULT = "Breakout MW"
+TARGET_BD_DEFAULT = "Breakdown MW"
+PRED_BO = "BO_Pred"
+PRED_BD = "BD_Pred"
+X_UNITS = "MW (ppg)"         # x-axis title for MW tracks/cross-plots
 
 MODELS_DIR = Path("models")
-DEFAULT_MODEL = MODELS_DIR / "ts_model.joblib"
+BO_MODEL_PATH = MODELS_DIR / "bo_model.joblib"
+BD_MODEL_PATH = MODELS_DIR / "bd_model.joblib"
+BO_META_PATH  = MODELS_DIR / "bo_meta.json"
+BD_META_PATH  = MODELS_DIR / "bd_meta.json"
+
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
-COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
+COLORS = {
+    "pred_bo": "#1f77b4",  # blue
+    "pred_bd": "#d62728",  # red
+    "actual_bo": "#f2b702",# amber
+    "actual_bd": "#2ca02c",# green
+    "ref": "#5a5a5a"
+}
 
-# Optional env banner from meta
 STRICT_VERSION_CHECK = False
 
-# ---- Plot sizing ----
+# Plot sizing
 CROSS_W = 350
 CROSS_H = 350
 TRACK_H = 1000
@@ -58,11 +71,11 @@ 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; }
- .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; }
+ .centered-container { display:flex; flex-direction:column; align-items:center; text-align:center; }
+ .st-message-box { background:#f0f2f6; color:#333; padding:10px; border-radius:10px; border:1px solid #e6e9ef; }
+ .st-message-box.st-success { background:#d4edda; color:#155724; border-color:#c3e6cb; }
+ .st-message-box.st-warning { background:#fff3cd; color:#856404; border-color:#ffeeba; }
+ .st-message-box.st-error   { background:#f8d7da; color:#721c24; border-color:#f5c6cb; }
  .main .block-container { overflow: unset !important; }
  div[data-testid="stVerticalBlock"] { overflow: unset !important; }
  div[data-testid="stExpander"] > details > summary {
@@ -75,8 +88,8 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 TABLE_CENTER_CSS = [
-    dict(selector="th", props=[("text-align", "center")]),
-    dict(selector="td", props=[("text-align", "center")]),
+    dict(selector="th", props=[("text-align","center")]),
+    dict(selector="td", props=[("text-align","center")]),
 ]
 
 # =========================
@@ -105,8 +118,8 @@ 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;'>{APP_NAME}</div>
+            <img src="{inline_logo('logo.png')}" class="brand-logo">
+            <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
@@ -148,12 +161,29 @@ def parse_excel(data_bytes: bytes):
 def read_book_bytes(b: bytes):
     return parse_excel(b) if b else {}
 
-# ---- Canonical feature aliasing ------------------------------------------
-def _build_alias_map(canonical_features: list[str], target_name: str) -> dict:
-    """
-    Map common header variants -> the *canonical* names in canonical_features.
-    Whatever appears in canonical_features (from ts_meta.json) wins.
-    """
+def _nice_tick0(xmin: float, step: float = 0.1) -> float:
+    return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
+
+def df_centered_rounded(df: pd.DataFrame, hide_index=True, ndigits=2):
+    out = df.copy()
+    numcols = out.select_dtypes(include=[np.number]).columns
+    styler = (
+        out.style
+           .format({c: f"{{:.{ndigits}f}}" 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)
+
+# ---------- 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 X.columns:
+        X[c] = pd.to_numeric(X[c], errors="coerce")
+    return X
+
+# ---- Column name normalization (aliases) ----
+def _build_alias_map(canonical_features: list[str], tgt_bo: str, tgt_bd: str) -> dict:
     def pick(expected_list, variants):
         for v in variants:
             if v in expected_list:
@@ -165,36 +195,28 @@ def _build_alias_map(canonical_features: list[str], target_name: str) -> dict:
     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)", "Flow Rate, gpm", "Flow Rate,gpm", "Flow Rate , gpm", "Fow Rate, gpm", "Fow Rate, gpm "])
+    can_FR     = pick(canonical_features, ["Flow Rate (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, "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, "Flow Rate, gpm": can_FR, "Flow Rate,gpm": can_FR, "Flow Rate , gpm": can_FR,
-        "Fow Rate, gpm": can_FR, "Fow Rate, gpm ": can_FR,
-
-        # Depth (plot only)
         "Depth (ft)": can_DEPTH, "Depth, ft": can_DEPTH, "Depth(ft)": can_DEPTH, "DEPTH, ft": can_DEPTH,
 
-        # Target family
-        "Ts (us/ft_Actual)": target_name,
-        "Ts,us/ft_Actual":   target_name,
-        "Ts, us/ft_Actual":  target_name,
-        "Ts":                target_name,
-        "TS_Actual":         target_name,
-        "Ts (us/ft)_Actual": target_name,
+        # Targets aliases
+        "Breakout MW": tgt_bo, "BOMW": tgt_bo, "BO MW": tgt_bo,
+        "Breakdown MW": tgt_bd, "BDMW": tgt_bd, "BD MW": tgt_bd,
     }
     return alias
 
-def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], target_name: str) -> pd.DataFrame:
+def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], tgt_bo: str, tgt_bd: 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)
+    alias = _build_alias_map(canonical_features, tgt_bo, tgt_bd)
     actual = {k: v for k, v in alias.items() if k in out.columns and k != v}
     return out.rename(columns=actual)
 
@@ -211,31 +233,6 @@ def find_sheet(book, names):
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-def _nice_tick0(xmin: float, step: float = 0.1) -> float:
-    return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
-
-def df_centered_rounded(df: pd.DataFrame, hide_index=True):
-    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)
-    )
-    st.dataframe(styler, use_container_width=True, hide_index=hide_index)
-
-# ---------- Build X exactly as trained ----------
-def _make_X(df: pd.DataFrame, features: list[str]) -> pd.DataFrame:
-    """
-    Reindex columns to the exact training feature order and coerce to numeric.
-    Prevents scikit-learn 'feature names should match' errors.
-    """
-    X = df.reindex(columns=features, copy=False)
-    for c in X.columns:
-        X[c] = pd.to_numeric(X[c], errors="coerce")
-    return X
-
 # === Excel export helpers =================================================
 def _excel_engine() -> str:
     try:
@@ -258,8 +255,7 @@ def _round_numeric(df: pd.DataFrame, ndigits: int = 3) -> pd.DataFrame:
 
 def _summary_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()
+    if not cols: return pd.DataFrame()
     tbl = (df[cols]
             .agg(['min','max','mean','std'])
             .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
@@ -293,9 +289,9 @@ def _add_sheet(sheets: dict, order: list, name: str, df: pd.DataFrame, ndigits:
 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 "Train" in res:        sections += ["Training","Training_Metrics_BO","Training_Metrics_BD","Training_Summary"]
+    if "Test" in res:         sections += ["Testing","Testing_Metrics_BO","Testing_Metrics_BD","Testing_Summary"]
+    if "Validate" in res:     sections += ["Validation","Validation_Metrics_BO","Validation_Metrics_BD","Validation_Summary","Validation_OOR"]
     if "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary"]
     if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
     sections += ["Info"]
@@ -310,24 +306,30 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
 
     if "Training" in selected and "Train" in res:
         _add_sheet(sheets, order, "Training", res["Train"], ndigits)
-    if "Training_Metrics" in selected and res.get("m_train"):
-        _add_sheet(sheets, order, "Training_Metrics", pd.DataFrame([res["m_train"]]), ndigits)
+    if "Training_Metrics_BO" in selected and res.get("m_train_bo"):
+        _add_sheet(sheets, order, "Training_Metrics_BO", pd.DataFrame([res["m_train_bo"]]), ndigits)
+    if "Training_Metrics_BD" in selected and res.get("m_train_bd"):
+        _add_sheet(sheets, order, "Training_Metrics_BD", pd.DataFrame([res["m_train_bd"]]), ndigits)
     if "Training_Summary" in selected and "Train" in res:
-        tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Train"].columns]
+        tr_cols = st.session_state["FEATURES"] + [c for c in [st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], PRED_BO, PRED_BD] if c in res["Train"].columns]
         _add_sheet(sheets, order, "Training_Summary", _summary_table(res["Train"], tr_cols), ndigits)
 
     if "Testing" in selected and "Test" in res:
         _add_sheet(sheets, order, "Testing", res["Test"], ndigits)
-    if "Testing_Metrics" in selected and res.get("m_test"):
-        _add_sheet(sheets, order, "Testing_Metrics", pd.DataFrame([res["m_test"]]), ndigits)
+    if "Testing_Metrics_BO" in selected and res.get("m_test_bo"):
+        _add_sheet(sheets, order, "Testing_Metrics_BO", pd.DataFrame([res["m_test_bo"]]), ndigits)
+    if "Testing_Metrics_BD" in selected and res.get("m_test_bd"):
+        _add_sheet(sheets, order, "Testing_Metrics_BD", pd.DataFrame([res["m_test_bd"]]), ndigits)
     if "Testing_Summary" in selected and "Test" in res:
-        te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Test"].columns]
+        te_cols = st.session_state["FEATURES"] + [c for c in [st.session_state["TARGET_BO"], st.session_state["TARGET_BD"], PRED_BO, PRED_BD] if c in res["Test"].columns]
         _add_sheet(sheets, order, "Testing_Summary", _summary_table(res["Test"], te_cols), ndigits)
 
     if "Validation" in selected and "Validate" in res:
         _add_sheet(sheets, order, "Validation", res["Validate"], ndigits)
-    if "Validation_Metrics" in selected and res.get("m_val"):
-        _add_sheet(sheets, order, "Validation_Metrics", pd.DataFrame([res["m_val"]]), ndigits)
+    if "Validation_Metrics_BO" in selected and res.get("m_val_bo"):
+        _add_sheet(sheets, order, "Validation_Metrics_BO", pd.DataFrame([res["m_val_bo"]]), ndigits)
+    if "Validation_Metrics_BD" in selected and res.get("m_val_bd"):
+        _add_sheet(sheets, order, "Validation_Metrics_BD", pd.DataFrame([res["m_val_bd"]]), ndigits)
     if "Validation_Summary" in selected and res.get("sv_val"):
         _add_sheet(sheets, order, "Validation_Summary", pd.DataFrame([res["sv_val"]]), ndigits)
     if "Validation_OOR" in selected and isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
@@ -346,9 +348,9 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
         info = pd.DataFrame([
             {"Key": "AppName",    "Value": APP_NAME},
             {"Key": "Tagline",    "Value": TAGLINE},
-            {"Key": "Target",     "Value": TARGET},
-            {"Key": "PredColumn", "Value": PRED_COL},
-            {"Key": "Features",   "Value": ", ".join(FEATURES)},
+            {"Key": "Targets",    "Value": f'{st.session_state["TARGET_BO"]}, {st.session_state["TARGET_BD"]}'},
+            {"Key": "PredColumns","Value": f'{PRED_BO}, {PRED_BD}'},
+            {"Key": "Features",   "Value": ", ".join(st.session_state["FEATURES"])},
             {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
         ])
         _add_sheet(sheets, order, "Info", info, ndigits)
@@ -365,10 +367,9 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
             if do_autofit:
                 _excel_autofit(writer, sheet, df)
     bio.seek(0)
-    fname = f"TS_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+    fname = f"MW_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
-# --------- SIMPLE export UI ----------
 def render_export_button(phase_key: str) -> None:
     res = st.session_state.get("results", {})
     if not res: return
@@ -381,7 +382,6 @@ def render_export_button(phase_key: str) -> None:
         options=options,
         default=[],
         placeholder="Choose option(s)",
-        help="Pick the sheets you want to include in the Excel export.",
         key=f"sheets_{phase_key}",
     )
 
@@ -390,7 +390,7 @@ def render_export_button(phase_key: str) -> None:
         st.download_button(
             label="⬇️ Export Excel",
             data=b"",
-            file_name="TS_Export.xlsx",
+            file_name="MW_Export.xlsx",
             mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
             disabled=True,
             key=f"download_{phase_key}",
@@ -403,16 +403,16 @@ def render_export_button(phase_key: str) -> None:
     st.download_button(
         "⬇️ Export Excel",
         data=(data or b""),
-        file_name=(fname or "TS_Export.xlsx"),
+        file_name=(fname or "MW_Export.xlsx"),
         mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
         disabled=(data is None),
         key=f"download_{phase_key}",
     )
 
 # =========================
-# Cross plot (Matplotlib)
+# Cross plots (Matplotlib)
 # =========================
-def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predicted Ts (µs/ft)"):
+def cross_plot_static(actual, pred, xlabel, ylabel, color="#1f77b4"):
     a = pd.Series(actual, dtype=float)
     p = pd.Series(pred, dtype=float)
 
@@ -420,204 +420,227 @@ def cross_plot_static(actual, pred, xlabel="Actual Ts (µs/ft)", ylabel="Predict
     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)
-
-    ax.scatter(a, p, s=14, c=COLORS["pred"], alpha=0.9, linewidths=0)
+    fig, ax = plt.subplots(figsize=(CROSS_W/dpi, CROSS_H/dpi), dpi=dpi, constrained_layout=False)
+    ax.scatter(a, p, s=14, c=color, alpha=0.9, linewidths=0)
     ax.plot([lo2, hi2], [lo2, hi2], linestyle="--", linewidth=1.2, color=COLORS["ref"])
 
-    ax.set_xlim(lo2, hi2)
-    ax.set_ylim(lo2, hi2)
+    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"{x:.2f}")
     ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
-
     ax.set_xlabel(xlabel, fontweight="bold", fontsize=10, color="black")
     ax.set_ylabel(ylabel, fontweight="bold", fontsize=10, color="black")
     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")
-
+    for s in ax.spines.values(): s.set_linewidth(1.1); s.set_color("#444")
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
 
 # =========================
-# Track plot (Plotly)
+# Track plots (Plotly)
 # =========================
-def track_plot(df, include_actual=True):
+def _depth_series(df):
     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())]
+        y = pd.to_numeric(df[depth_col], errors="coerce"); ylab = depth_col
+        rng = [float(y.max()), float(y.min())]  # reversed
     else:
         y = pd.Series(np.arange(1, len(df) + 1)); ylab = "Point Index"
-        y_range = [float(y.max()), float(y.min())]
+        rng = [float(y.max()), float(y.min())]
+    return y, ylab, rng
 
-    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)
+def _x_range_for_tracks(df, cols):
+    x_series = pd.concat([pd.to_numeric(df[c], errors="coerce") for c in cols if c in df], ignore_index=True)
     x_lo, x_hi = float(x_series.min()), float(x_series.max())
-    x_pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
-    xmin, xmax = x_lo - x_pad, x_hi + x_pad
-    tick0 = _nice_tick0(xmin, step=max((xmax - xmin) / 10.0, 0.1))
+    pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
+    xmin, xmax = x_lo - pad, x_hi + pad
+    tick0 = _nice_tick0(xmin, step=max((xmax - xmin)/10.0, 0.1))
+    return xmin, xmax, tick0
+
+def track_plot_single(df, pred_col, actual_col=None, title_suffix=""):
+    y, ylab, y_range = _depth_series(df)
+    cols = [pred_col] + ([actual_col] if actual_col and actual_col in df.columns else [])
+    xmin, xmax, tick0 = _x_range_for_tracks(df, cols)
 
     fig = go.Figure()
-    if PRED_COL in df.columns:
+    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>"
+            x=df[pred_col], y=y, mode="lines",
+            line=dict(color=COLORS["pred_bo"] if pred_col==PRED_BO else COLORS["pred_bd"], width=1.8),
+            name=pred_col,
+            hovertemplate=f"{pred_col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
         ))
-    if include_actual and TARGET in df.columns:
+    if actual_col and actual_col 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=f"{TARGET} (actual)",
-            hovertemplate=f"{TARGET}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
+            x=df[actual_col], y=y, mode="lines",
+            line=dict(color=COLORS["actual_bo"] if actual_col==st.session_state["TARGET_BO"] else COLORS["actual_bd"],
+                      width=2.0, dash="dot"),
+            name=f"{actual_col} (actual)",
+            hovertemplate=f"{actual_col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        height=TRACK_H, width=TRACK_W, autosize=False,
-        paper_bgcolor="#fff", plot_bgcolor="#fff",
+        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_title_text=""
+        legend_title_text="",
+        title=title_suffix
     )
     fig.update_xaxes(
-        title_text="Ts (μs/ft)",
-        title_font=dict(size=20, family=BOLD_FONT, color="#000"),
-        tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-        side="top", range=[xmin, xmax],
-        ticks="outside", tickformat=",.0f", tickmode="auto", tick0=tick0,
+        title_text=X_UNITS, 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=",.2f", tickmode="auto", tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
     fig.update_yaxes(
-        title_text=ylab,
-        title_font=dict(size=20, family=BOLD_FONT, color="#000"),
+        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",
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        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
 
+def track_plot_combined(df):
+    """Overlay BO & BD predictions (+ actuals if present) on same depth axis."""
+    y, ylab, y_range = _depth_series(df)
+    cols = [c for c in [PRED_BO, PRED_BD, st.session_state["TARGET_BO"], st.session_state["TARGET_BD"]] if c in df]
+    xmin, xmax, tick0 = _x_range_for_tracks(df, cols)
+    fig = go.Figure()
+
+    if PRED_BO in df.columns:
+        fig.add_trace(go.Scatter(x=df[PRED_BO], y=y, mode="lines",
+            line=dict(color=COLORS["pred_bo"], width=1.8), name=PRED_BO,
+            hovertemplate=f"{PRED_BO}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+    if st.session_state["TARGET_BO"] in df.columns:
+        col = st.session_state["TARGET_BO"]
+        fig.add_trace(go.Scatter(x=df[col], y=y, mode="lines",
+            line=dict(color=COLORS["actual_bo"], width=2.0, dash="dot"), name=f"{col} (actual)",
+            hovertemplate=f"{col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+
+    if PRED_BD in df.columns:
+        fig.add_trace(go.Scatter(x=df[PRED_BD], y=y, mode="lines",
+            line=dict(color=COLORS["pred_bd"], width=1.8), name=PRED_BD,
+            hovertemplate=f"{PRED_BD}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+    if st.session_state["TARGET_BD"] in df.columns:
+        col = st.session_state["TARGET_BD"]
+        fig.add_trace(go.Scatter(x=df[col], y=y, mode="lines",
+            line=dict(color=COLORS["actual_bd"], width=2.0, dash="dot"), name=f"{col} (actual)",
+            hovertemplate=f"{col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"))
+
+    fig.update_layout(
+        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_title_text="", title="Combined (Breakout / Breakdown)"
+    )
+    fig.update_xaxes(title_text=X_UNITS, 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=",.2f", tickmode="auto", tick0=tick0,
+                     showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+                     showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True)
+    fig.update_yaxes(title_text=ylab, title_font=dict(size=20, family=BOLD_FONT, color="#000"),
+                     tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
+                     range=y_range, ticks="outside", showline=True, linewidth=1.2, linecolor="#444",
+                     mirror=True, showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True)
+    return fig
+
 # ---------- Preview (matplotlib) ----------
 def preview_tracks(df: pd.DataFrame, cols: list[str]):
-    """
-    Quick-look multi-track preview:
-      - one subplot per selected column
-      - distinct stable colors per column
-      - shared & reversed Y-axis (Depth downwards)
-    """
     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
 
-    # Depth or fallback to index
     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
+        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"
+        idx = pd.Series(np.arange(1, len(df) + 1)); y_label = "Point Index"
 
-    y_min, y_max = float(idx.min()), float(idx.max())
-
-    # Stable qualitative palette
     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]
-
+    if n == 1: axes = [axes]
     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 Y (Depth down)
+        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
+        ax.set_ylim(float(idx.max()), float(idx.min()))
         ax.grid(True, linestyle=":", alpha=0.3)
-
-        if i == 0:
-            ax.set_ylabel(y_label)
-        else:
-            ax.tick_params(labelleft=False)
-            ax.set_ylabel("")
-
+        if i == 0: ax.set_ylabel(y_label)
+        else: ax.tick_params(labelleft=False); ax.set_ylabel("")
     fig.tight_layout()
     return fig
 
 # =========================
-# Load model + meta
+# Load models + metas
 # =========================
-def ensure_model() -> Path|None:
-    for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
-        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 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:
-        return None
+def _ensure_file(p: Path) -> Path|None:
+    return p if (p.exists() and p.stat().st_size > 0) else None
+
+bo_model_path = _ensure_file(BO_MODEL_PATH)
+bd_model_path = _ensure_file(BD_MODEL_PATH)
+if not (bo_model_path and bd_model_path):
+    st.error("Models not found. Place bo_model.joblib and bd_model.joblib in models/"); st.stop()
 
-mpath = ensure_model()
-if not mpath:
-    st.error("Model not found. Upload models/ts_model.joblib (or set MODEL_URL).")
-    st.stop()
 try:
-    model = load_model(str(mpath))
+    model_bo = load_model(str(bo_model_path))
+    model_bd = load_model(str(bd_model_path))
 except Exception as e:
-    st.error(f"Failed to load model: {e}")
-    st.stop()
+    st.error(f"Failed to load models: {e}"); st.stop()
 
-# Load meta (prefer Ts-specific)
-meta = {}
-meta_candidates = [MODELS_DIR / "ts_meta.json", MODELS_DIR / "meta.json", MODELS_DIR / "ym_meta.json"]
-meta_path = next((p for p in meta_candidates if p.exists()), None)
-if meta_path:
+# Defaults
+FEATURES = FEATURES_DEFAULT[:]
+TARGET_BO = TARGET_BO_DEFAULT
+TARGET_BD = TARGET_BD_DEFAULT
+
+# Meta overrides
+def _load_meta(p: Path):
+    if not p.exists(): return {}
     try:
-        meta = json.loads(meta_path.read_text(encoding="utf-8"))
-        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"):
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+meta_bo = _load_meta(BO_META_PATH)
+meta_bd = _load_meta(BD_META_PATH)
+
+# Use BO meta as primary feature source (or BD if BO missing metas)
+if meta_bo.get("features"): FEATURES = meta_bo["features"]
+elif meta_bd.get("features"): FEATURES = meta_bd["features"]
+
+if meta_bo.get("target"): TARGET_BO = meta_bo["target"]
+if meta_bd.get("target"): TARGET_BD = meta_bd["target"]
+
+# Session constants for easy access elsewhere
+st.session_state["FEATURES"]  = FEATURES
+st.session_state["TARGET_BO"] = TARGET_BO
+st.session_state["TARGET_BD"] = TARGET_BD
+
+# Optional: strict version banner
+if STRICT_VERSION_CHECK:
     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))
+    msgs=[]
+    for nm, meta in [("BO", meta_bo), ("BD", meta_bd)]:
+        v = meta.get("versions", {})
+        if v.get("numpy") and v["numpy"] != _np.__version__:
+            msgs.append(f"[{nm}] NumPy {v['numpy']} expected, running {_np.__version__}")
+        if v.get("scikit_learn") and v["scikit_learn"] != _skl.__version__:
+            msgs.append(f"[{nm}] scikit-learn {v['scikit_learn']} expected, running {_skl.__version__}")
+    if msgs: st.warning("Environment mismatch: " + " | ".join(msgs))
 
 # =========================
 # Session state
@@ -636,7 +659,7 @@ st.session_state.setdefault("show_preview_modal", False)
 # =========================
 st.sidebar.markdown(f"""
     <div class="centered-container">
-        <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
+        <img src="{inline_logo('logo.png')}" class="brand-logo">
         <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
         <div style='color:#667085;'>{TAGLINE}</div>
     </div>
@@ -665,12 +688,13 @@ 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 **Shear Slowness (Ts)** from drilling data.")
+    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate **Breakout** and **Breakdown** mud weight limits from drilling data.")
     st.subheader("How It Works")
     st.markdown(
-        "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 Ts) or **Proceed to Prediction** (no Ts)."
+        "1) **Upload your data** and preview.\n"
+        "2) Click **Run Model** to compute metrics and plots (Train/Test).\n"
+        "3) Proceed to **Validation** (with actual BO/BD) or **Prediction** (no actuals).\n"
+        "4) Use the **Combined** tab to see both limits on one track."
     )
     if st.button("Start Showcase", type="primary"):
         st.session_state.app_step = "dev"; st.rerun()
@@ -715,62 +739,67 @@ if st.session_state.app_step == "dev":
             st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets.</div>', unsafe_allow_html=True)
             st.stop()
 
-        tr = _normalize_columns(book[sh_train].copy(), 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()
+        # Normalize + ensure cols
+        tr = _normalize_columns(book[sh_train].copy(), FEATURES, TARGET_BO, TARGET_BD)
+        te = _normalize_columns(book[sh_test].copy(),  FEATURES, TARGET_BO, TARGET_BD)
+        need = FEATURES + [TARGET_BO, TARGET_BD]
+        if not (ensure_cols(tr, need) and ensure_cols(te, need)):
+            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
 
-        # Predict with exactly the training feature order
-        tr[PRED_COL] = model.predict(_make_X(tr, FEATURES))
-        te[PRED_COL] = model.predict(_make_X(te, FEATURES))
+        # Predict with exact training feature order
+        tr[PRED_BO] = model_bo.predict(_make_X(tr, FEATURES))
+        tr[PRED_BD] = model_bd.predict(_make_X(tr, FEATURES))
+        te[PRED_BO] = model_bo.predict(_make_X(te, FEATURES))
+        te[PRED_BD] = model_bd.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[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[PRED_COL]),
-            "RMSE": rmse(te[TARGET], te[PRED_COL]),
-            "MAE":  mean_absolute_error(te[TARGET], te[PRED_COL])
-        }
+        st.session_state.results["m_train_bo"]={"R": pearson_r(tr[TARGET_BO], tr[PRED_BO]), "RMSE": rmse(tr[TARGET_BO], tr[PRED_BO]), "MAE": mean_absolute_error(tr[TARGET_BO], tr[PRED_BO])}
+        st.session_state.results["m_train_bd"]={"R": pearson_r(tr[TARGET_BD], tr[PRED_BD]), "RMSE": rmse(tr[TARGET_BD], tr[PRED_BD]), "MAE": mean_absolute_error(tr[TARGET_BD], tr[PRED_BD])}
+        st.session_state.results["m_test_bo"] ={"R": pearson_r(te[TARGET_BO], te[PRED_BO]), "RMSE": rmse(te[TARGET_BO], te[PRED_BO]), "MAE": mean_absolute_error(te[TARGET_BO], te[PRED_BO])}
+        st.session_state.results["m_test_bd"] ={"R": pearson_r(te[TARGET_BD], te[PRED_BD]), "RMSE": rmse(te[TARGET_BD], te[PRED_BD]), "MAE": mean_absolute_error(te[TARGET_BD], te[PRED_BD])}
 
         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.markdown('<div class="st-message-box st-success">Case has been built and results are displayed below.</div>', unsafe_allow_html=True)
 
-    def _dev_block(df, m):
+    def _metrics_block(lbl, m):
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.3f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1.metric(f"R ({lbl})",    f"{m['R']:.3f}")
+        c2.metric(f"RMSE ({lbl})", f"{m['RMSE']:.2f}")
+        c3.metric(f"MAE ({lbl})",  f"{m['MAE']:.2f}")
+
+    def _dev_block(df, mbo, mbd):
+        _metrics_block("BO", mbo); _metrics_block("BD", mbd)
         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>
-                <strong>RMSE:</strong> Root Mean Square Error<br>
-                <strong>MAE:</strong> Mean Absolute Error
+            <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
+                <strong>R:</strong> Pearson correlation • <strong>RMSE</strong> / <strong>MAE</strong> in MW units
             </div>
         """, unsafe_allow_html=True)
-        col_track, col_cross = st.columns([2, 3], gap="large")
-        with col_track:
-            st.plotly_chart(track_plot(df, include_actual=True), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
-        with col_cross:
-            st.pyplot(cross_plot_static(df[TARGET], df[PRED_COL]), use_container_width=False)
+        t1, t2, t3 = st.tabs(["Breakout", "Breakdown", "Combined"])
+        with t1:
+            st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=TARGET_BO, title_suffix="Breakout"), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[TARGET_BO], df[PRED_BO], xlabel=f"Actual {TARGET_BO}", ylabel=f"Predicted {TARGET_BO}", color=COLORS["pred_bo"]), use_container_width=False)
+        with t2:
+            st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=TARGET_BD, title_suffix="Breakdown"), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[TARGET_BD], df[PRED_BD], xlabel=f"Actual {TARGET_BD}", ylabel=f"Predicted {TARGET_BD}", color=COLORS["pred_bd"]), use_container_width=False)
+        with t3:
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
         if "Train" in st.session_state.results:
-            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
+            with tab1:
+                _dev_block(st.session_state.results["Train"], st.session_state.results["m_train_bo"], st.session_state.results["m_train_bd"])
         if "Test" in st.session_state.results:
-            with tab2: _dev_block(st.session_state.results["Test"], st.session_state.results["m_test"])
+            with tab2:
+                _dev_block(st.session_state.results["Test"], st.session_state.results["m_test_bo"], st.session_state.results["m_test_bd"])
         render_export_button(phase_key="dev")
 
 # =========================
-# VALIDATION (with actual Ts)
+# VALIDATION (with actual BO/BD)
 # =========================
 if st.session_state.app_step == "validate":
-    st.sidebar.header("Validate the Model")
+    st.sidebar.header("Validate the Models")
     up = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
@@ -783,15 +812,18 @@ if st.session_state.app_step == "validate":
     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()
 
-    sticky_header("Validate the Model", "Upload a dataset with the same **features** and **Ts** to evaluate performance.")
+    sticky_header("Validate the Models", "Upload a dataset with the same **features** and **BO/BD MW** 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 = _normalize_columns(book[name].copy(), FEATURES, TARGET)
-        if not ensure_cols(df, FEATURES+[TARGET]):
+        df = _normalize_columns(book[name].copy(), FEATURES, TARGET_BO, TARGET_BD)
+        need = FEATURES + [TARGET_BO, TARGET_BD]
+        if not ensure_cols(df, need):
             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))
+
+        df[PRED_BO] = model_bo.predict(_make_X(df, FEATURES))
+        df[PRED_BD] = model_bd.predict(_make_X(df, FEATURES))
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
@@ -805,48 +837,48 @@ if st.session_state.app_step == "validate":
                 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[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[PRED_COL].min()), "pred_max":float(df[PRED_COL].max()), "oor":oor_pct}
+
+        st.session_state.results["m_val_bo"]={"R": pearson_r(df[TARGET_BO], df[PRED_BO]), "RMSE": rmse(df[TARGET_BO], df[PRED_BO]), "MAE": mean_absolute_error(df[TARGET_BO], df[PRED_BO])}
+        st.session_state.results["m_val_bd"]={"R": pearson_r(df[TARGET_BD], df[PRED_BD]), "RMSE": rmse(df[TARGET_BD], df[PRED_BD]), "MAE": mean_absolute_error(df[TARGET_BD], df[PRED_BD])}
+        st.session_state.results["sv_val"]={"n":len(df), "bo_min":float(df[PRED_BO].min()), "bo_max":float(df[PRED_BO].max()),
+                                            "bd_min":float(df[PRED_BD].min()), "bd_max":float(df[PRED_BD].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"]
+        df = st.session_state.results["Validate"]
+        m_bo, m_bd = st.session_state.results["m_val_bo"], st.session_state.results["m_val_bd"]
         c1,c2,c3 = st.columns(3)
-        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>
-                <strong>RMSE:</strong> Root Mean Square Error<br>
-                <strong>MAE:</strong> Mean Absolute Error
-            </div>
-        """, unsafe_allow_html=True)
+        c1.metric("R (BO)", f"{m_bo['R']:.3f}"); c2.metric("RMSE (BO)", f"{m_bo['RMSE']:.2f}"); c3.metric("MAE (BO)", f"{m_bo['MAE']:.2f}")
+        c1,c2,c3 = st.columns(3)
+        c1.metric("R (BD)", f"{m_bd['R']:.3f}"); c2.metric("RMSE (BD)", f"{m_bd['RMSE']:.2f}"); c3.metric("MAE (BD)", f"{m_bd['MAE']:.2f}")
+        st.markdown("<div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>R = Pearson correlation</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),
+        t1, t2, t3 = st.tabs(["Breakout", "Breakdown", "Combined"])
+        with t1:
+            st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=TARGET_BO, title_suffix="Breakout"),
                             use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
-        with col_cross:
-            st.pyplot(cross_plot_static(st.session_state.results["Validate"][TARGET],
-                                        st.session_state.results["Validate"][PRED_COL]),
+            st.pyplot(cross_plot_static(df[TARGET_BO], df[PRED_BO], f"Actual {TARGET_BO}", f"Predicted {TARGET_BO}", COLORS["pred_bo"]),
                       use_container_width=False)
+        with t2:
+            st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=TARGET_BD, title_suffix="Breakdown"),
+                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.pyplot(cross_plot_static(df[TARGET_BD], df[PRED_BD], f"Actual {TARGET_BD}", f"Predicted {TARGET_BD}", COLORS["pred_bd"]),
+                      use_container_width=False)
+        with t3:
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
         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)
         if st.session_state.results["oor_tbl"] is not None:
-            st.write("*Out-of-range rows (vs. Training min–max):*")
-            df_centered_rounded(st.session_state.results["oor_tbl"])
+            st.write("*Out-of-range rows (vs. Training min–max):*"); df_centered_rounded(st.session_state.results["oor_tbl"])
 
 # =========================
-# PREDICTION (no actual Ts)
+# PREDICTION (no actuals)
 # =========================
 if st.session_state.app_step == "predict":
-    st.sidebar.header("Prediction (No Actual Ts)")
+    st.sidebar.header("Prediction (No Actual BO/BD)")
     up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
@@ -858,14 +890,15 @@ if st.session_state.app_step == "predict":
     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()
 
-    sticky_header("Prediction", "Upload a dataset with the feature columns (no **Ts**).")
+    sticky_header("Prediction", "Upload a dataset with **feature columns only** (no BO/BD actuals).")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
-        df = _normalize_columns(book[name].copy(), FEATURES, TARGET)
+        df = _normalize_columns(book[name].copy(), FEATURES, TARGET_BO, TARGET_BD)
         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))
+        df[PRED_BO] = model_bo.predict(_make_X(df, FEATURES))
+        df[PRED_BD] = model_bd.predict(_make_X(df, FEATURES))
         st.session_state.results["PredictOnly"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0
@@ -874,10 +907,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[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)),
+            "bo_min":float(df[PRED_BO].min()), "bo_max":float(df[PRED_BO].max()),
+            "bd_min":float(df[PRED_BD].min()), "bd_max":float(df[PRED_BD].max()),
+            "bo_mean":float(df[PRED_BO].mean()), "bo_std":float(df[PRED_BO].std(ddof=0)),
+            "bd_mean":float(df[PRED_BD].mean()), "bd_std":float(df[PRED_BD].std(ddof=0)),
             "oor":oor_pct
         }
 
@@ -887,16 +920,22 @@ if st.session_state.app_step == "predict":
         col_left, col_right = st.columns([2,3], gap="large")
         with col_left:
             table = pd.DataFrame({
-                "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "Value": [sv["n"], round(sv["pred_min"],3), round(sv["pred_max"],3),
-                          round(sv["pred_mean"],3), round(sv["pred_std"],3), f'{sv["oor"]:.1f}%']
+                "Metric": ["# points","BO min","BO max","BO mean","BO std","BD min","BD max","BD mean","BD std","OOR %"],
+                "Value": [sv["n"], round(sv["bo_min"],2), round(sv["bo_max"],2), round(sv["bo_mean"],2), round(sv["bo_std"],2),
+                          round(sv["bd_min"],2), round(sv["bd_max"],2), round(sv["bd_mean"],2), round(sv["bd_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, config={"displayModeBar": False, "scrollZoom": True})
+            t1, t2 = st.tabs(["Breakout", "Breakdown"])
+            with t1:
+                st.plotly_chart(track_plot_single(df, PRED_BO, actual_col=None, title_suffix="Breakout"),
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            with t2:
+                st.plotly_chart(track_plot_single(df, PRED_BD, actual_col=None, title_suffix="Breakdown"),
+                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.plotly_chart(track_plot_combined(df), use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
         render_export_button(phase_key="predict")
 
@@ -918,7 +957,7 @@ if st.session_state.show_preview_modal:
             tabs = st.tabs(names)
             for t, name in zip(tabs, names):
                 with t:
-                    df = _normalize_columns(book_to_preview[name], FEATURES, TARGET)
+                    df = _normalize_columns(book_to_preview[name], FEATURES, TARGET_BO, TARGET_BD)
                     t1, t2 = st.tabs(["Tracks", "Summary"])
                     with t1:
                         st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)