Update app.py

app.py

@@ -1,250 +1,334 @@
+# app.py
 import streamlit as st
 import pandas as pd
 import numpy as np
 from pathlib import Path
 import matplotlib.pyplot as plt
+import seaborn as sns
 
-# ---------- Page config ----------
-st.set_page_config(page_title="Getaround — Delay Buffer Decision", layout="wide")
+# ------- Page setup -------
+st.set_page_config(page_title="Getaround — Threshold & Scope Decision", layout="wide")
+sns.set_style("whitegrid")
 
-# ---------- Data loading ----------
+# ------- Data loading -------
 @st.cache_data(show_spinner=False)
 def load_data():
-    # Try common locations (local / sandbox)
-    candidates = [
-        "get_around_delay_analysis.csv",
-        "/mnt/data/get_around_delay_analysis.csv"
-    ]
-    path = next((p for p in candidates if Path(p).exists()), None)
-    if path is None:
-        st.error("CSV not found. Place 'get_around_delay_analysis.csv' next to the app or in /mnt/data.")
+    for p in ["/mnt/data/get_around_delay_analysis.csv", "get_around_delay_analysis.csv"]:
+        if Path(p).exists():
+            df = pd.read_csv(p)
+            break
+    else:
+        st.error("CSV not found. Put 'get_around_delay_analysis.csv' in the app folder or /mnt/data.")
         st.stop()
 
-    df = pd.read_csv(path)
-    # Drop unnamed columns if any
+    # drop unnamed artifacts
     df = df.drop(columns=[c for c in df.columns if c.lower().startswith("unnamed")], errors="ignore")
 
-    # Standard helper flags
+    # helpers
     df["has_gap"] = df["time_delta_with_previous_rental_in_minutes"].notnull()
-    df["has_delay"] = df["delay_at_checkout_in_minutes"].notnull()
-
-    # Clean improbable huge early/late returns (+/- 12h hard cap) -> set to NaN
     clean = df["delay_at_checkout_in_minutes"].copy()
-    clean = clean.where(clean.between(-720, 720))
+    clean = clean.where(clean.between(-720, 720))  # cap to +/-12h
     df["clean_delay"] = clean
 
-    # For rows with a previous rental gap and known delay, compute:
-    # overlap_problem: a late return exceeds the previous gap -> next renter is impacted
-    # wait_for_next_minutes: how many minutes the next renter would wait (>=0)
-    gap = df["time_delta_with_previous_rental_in_minutes"]
+    # overlap & wait for next
     cond = df["has_gap"] & df["clean_delay"].notnull()
     df["overlap_problem"] = False
     df.loc[cond, "overlap_problem"] = df.loc[cond, "clean_delay"] > df.loc[cond, "time_delta_with_previous_rental_in_minutes"]
     df["wait_for_next_minutes"] = 0.0
     df.loc[cond, "wait_for_next_minutes"] = (df.loc[cond, "clean_delay"] - df.loc[cond, "time_delta_with_previous_rental_in_minutes"]).clip(lower=0)
 
-    # Try to find a revenue column if present
-    revenue_cols = [c for c in df.columns if c.lower() in {"owner_revenue","rental_price","price","revenue","price_eur"}]
-    df.attrs["revenue_col"] = revenue_cols[0] if revenue_cols else None
-
+    # detect a revenue column if available
+    candidates = {"owner_revenue","rental_price","price","price_eur","revenue"}
+    rev_col = next((c for c in df.columns if c.lower() in candidates), None)
+    df.attrs["revenue_col"] = rev_col
     return df
 
 df = load_data()
-REVENUE_COL = df.attrs.get("revenue_col", None)
+REVENUE_COL = df.attrs.get("revenue_col")
 
-# ---------- Scope filter ----------
-def filter_scope(data: pd.DataFrame, scope: str) -> pd.DataFrame:
-    if scope == "Connect only":
+# ------- Helpers -------
+def filter_scope(data, scope):
+    if scope == "connect":
         return data[data["checkin_type"].str.lower() == "connect"]
-    return data  # All cars
-
-# ---------- Core metrics for a given threshold & scope ----------
-def metrics_for_threshold(data: pd.DataFrame, threshold_minutes: int):
-    """
-    Definitions (applied only on rows with a previous-rental gap):
-      • blocked: time_delta_with_previous_rental_in_minutes < threshold
-        -> This rental would be hidden from search to respect the buffer.
-
-      • overlap_problem: clean_delay > gap
-        -> Next renter is impacted (today, without buffer).
+    return data
 
-      • solved_by_buffer: overlap_problem & blocked
-        -> The buffer would have hidden this case, avoiding the next-renter wait.
-
-      • wait_for_next_minutes: max(clean_delay - gap, 0)
-        -> Actual minutes the next renter waits in impacted cases (diagnostic only).
-
-    Revenue affected (if revenue column exists):
-      share_of_revenue_blocked = sum(revenue for blocked rentals) / sum(revenue all rentals in scope)
-    Otherwise we report share_of_rentals_blocked as proxy.
-    """
+def metrics_for(data, threshold):
+    """Compute all decision metrics for given data scope + threshold."""
     d = data.copy()
-    mask_gap = d["has_gap"]
-
-    d_gap = d[mask_gap].copy()
+    d_gap = d[d["has_gap"]].copy()
     if d_gap.empty:
         return dict(
-            total_with_gap=0, blocked=0, blocked_rate=0.0,
-            problems_today=0, overlap_rate=0.0,
-            solved=0, solve_rate_given_blocked=0.0,
-            avg_wait_minutes_among_problems=np.nan,
-            revenue_blocked=0.0, revenue_total=0.0,
-            revenue_share_blocked=np.nan
+            rentals_with_gap=0, blocked=0, blocked_rate=0.0,
+            problems_today=0, overlap_rate=0.0, solved=0, solve_rate=0.0,
+            avg_wait=np.nan, revenue_share_blocked=np.nan
         )
+    d_gap["blocked"] = d_gap["time_delta_with_previous_rental_in_minutes"] < threshold
+    d_gap["solved"]  = d_gap["overlap_problem"] & d_gap["blocked"]
 
-    d_gap["blocked"] = d_gap["time_delta_with_previous_rental_in_minutes"] < threshold_minutes
-    d_gap["solved_by_buffer"] = d_gap["overlap_problem"] & d_gap["blocked"]
-
-    total_with_gap = len(d_gap)
+    rentals_with_gap = len(d_gap)
     blocked = int(d_gap["blocked"].sum())
-    blocked_rate = blocked / total_with_gap
-
+    blocked_rate = blocked / rentals_with_gap
     problems_today = int(d_gap["overlap_problem"].sum())
-    overlap_rate = problems_today / total_with_gap
-
-    solved = int(d_gap["solved_by_buffer"].sum())
-    solve_rate_given_blocked = solved / blocked if blocked > 0 else 0.0
-
+    overlap_rate = problems_today / rentals_with_gap
+    solved = int(d_gap["solved"].sum())
+    solve_rate = solved / blocked if blocked > 0 else 0.0
     avg_wait = d_gap.loc[d_gap["overlap_problem"], "wait_for_next_minutes"].mean()
 
-    # Revenue (if available)
-    if REVENUE_COL and REVENUE_COL in d.columns:
-        # For safety, coerce to numeric
+    # revenue share blocked
+    if REVENUE_COL:
         rev = pd.to_numeric(d[REVENUE_COL], errors="coerce")
         rev_total = rev.sum(skipna=True)
         rev_blocked = pd.to_numeric(d_gap.loc[d_gap["blocked"], REVENUE_COL], errors="coerce").sum(skipna=True)
-        rev_share_blocked = (rev_blocked / rev_total) if rev_total > 0 else np.nan
+        revenue_share_blocked = (rev_blocked / rev_total) if rev_total > 0 else np.nan
     else:
-        rev_total = 0.0
-        rev_blocked = 0.0
-        rev_share_blocked = np.nan
+        revenue_share_blocked = np.nan
 
     return dict(
-        total_with_gap=total_with_gap,
+        rentals_with_gap=rentals_with_gap,
         blocked=blocked,
         blocked_rate=blocked_rate,
         problems_today=problems_today,
         overlap_rate=overlap_rate,
         solved=solved,
-        solve_rate_given_blocked=solve_rate_given_blocked,
-        avg_wait_minutes_among_problems=avg_wait,
-        revenue_blocked=rev_blocked,
-        revenue_total=rev_total,
-        revenue_share_blocked=rev_share_blocked
+        solve_rate=solve_rate,
+        avg_wait=avg_wait,
+        revenue_share_blocked=revenue_share_blocked
     )
 
-# ---------- Sidebar controls ----------
-st.sidebar.header("Controls")
-threshold = st.sidebar.slider("Minimum delay (buffer) in minutes", min_value=15, max_value=180, step=15, value=90)
-scope = st.sidebar.radio("Scope", ["All cars", "Connect only"], horizontal=True)
+def sweep_thresholds(data, thresholds):
+    rows = []
+    for t in thresholds:
+        m = metrics_for(data, t)
+        rows.append({"threshold": t, **m})
+    return pd.DataFrame(rows)
 
+# ------- Sidebar controls -------
+st.sidebar.header("Controls")
+threshold = st.sidebar.slider("Minimum delay (minutes)", 15, 180, step=15, value=90)
+scope = st.sidebar.radio("Scope", options=["all", "connect"], format_func=lambda s: "All cars" if s=="all" else "Connect only", horizontal=True)
+thresholds = list(range(15, 181, 15))
 df_scope = filter_scope(df, scope)
 
-# ---------- Overview KPIs ----------
-st.title("Getaround — Delay Buffer Decision Support")
+# =========================================================
+# SECTION 1 — THRESHOLD DECISION
+# =========================================================
+st.title("Decision 1 — Threshold (minimum delay between rentals)")
 
-with st.expander("How we compute each metric (click to expand)"):
-    st.markdown("""
-- **Has previous gap:** `has_gap = time_delta_with_previous_rental_in_minutes not null`  
-- **Overlap problem (today):** `clean_delay > gap`  
-- **Next-driver wait (minutes):** `max(clean_delay - gap, 0)`  
-- **Blocked by buffer:** `gap < threshold`  
-- **Solved by buffer:** `overlap_problem AND blocked` (hidden rental avoids the clash)  
-- **Blocked rate:** `blocked / rentals_with_gap`  
-- **Overlap rate:** `overlap_problems / rentals_with_gap`  
-- **Solve rate (given blocked):** `solved / blocked`  
-- **Share of revenue affected:** `sum(revenue for blocked rentals) / sum(revenue all rentals)` *(shown only if a revenue column exists)*  
-""")
+# Current-threshold KPIs
+m_now = metrics_for(df_scope, threshold)
+k1,k2,k3,k4,k5 = st.columns(5)
+k1.metric("Rentals with gap", f"{m_now['rentals_with_gap']:,}")
+k2.metric("Blocked rentals", f"{m_now['blocked']:,}")
+k3.metric("Blocked rate", f"{m_now['blocked_rate']:.1%}")
+k4.metric("Problems solved", f"{m_now['solved']:,}")
+k5.metric("Solve rate (given blocked)", f"{m_now['solve_rate']:.1%}")
 
-colA, colB, colC, colD = st.columns(4)
-with colA:
-    total_rentals = len(df_scope)
-    st.metric("Total rentals (scope)", f"{total_rentals:,}")
-with colB:
-    with_gap = int(df_scope["has_gap"].sum())
-    st.metric("Rentals with previous gap", f"{with_gap:,}")
-with colC:
-    overlap_now = int(df_scope["overlap_problem"].sum())
-    st.metric("Overlap problems (today)", f"{overlap_now:,}")
-with colD:
-    avg_wait_now = df_scope.loc[df_scope["overlap_problem"], "wait_for_next_minutes"].mean()
-    st.metric("Avg wait (impacted, min)", f"{(avg_wait_now or 0):.1f}")
-
-# ---------- Threshold & Scope Impact ----------
-m = metrics_for_threshold(df_scope, threshold)
-
-st.subheader("Impact at selected buffer & scope")
-k1, k2, k3, k4, k5 = st.columns(5)
-k1.metric("Rentals blocked", f"{m['blocked']:,}")
-k2.metric("Blocked rate (of with-gap)", f"{m['blocked_rate']:.1%}")
-k3.metric("Problems today", f"{m['problems_today']:,}")
-k4.metric("Solved by buffer", f"{m['solved']:,}")
-k5.metric("Solve rate (given blocked)", f"{m['solve_rate_given_blocked']:.1%}")
-
-k6, k7 = st.columns(2)
-k6.metric("Avg wait among problems (min)", f"{(m['avg_wait_minutes_among_problems'] or 0):.1f}")
+k6,k7 = st.columns(2)
+k6.metric("Overlap problems today", f"{m_now['problems_today']:,}")
+k7.metric("Avg wait among impacted (min)", f"{(m_now['avg_wait'] or 0):.1f}")
 
 if REVENUE_COL:
-    share_txt = f"{(m['revenue_share_blocked'] or 0):.1%}"
-    k7.metric("Share of owner revenue affected", share_txt)
+    st.caption(f"Revenue field detected: **{REVENUE_COL}**")
+    st.metric("Share of owner revenue blocked", f"{(m_now['revenue_share_blocked'] or 0):.1%}")
 else:
-    k7.metric("Share of revenue affected", "N/A")
-    st.info("No revenue column detected; reporting revenue share is not possible. We use **rental share** as a proxy in charts below.")
+    st.info("No revenue column found. Revenue impact graphs will use **% of rentals blocked** as a proxy.")
 
-# ---------- Threshold Sweep (for decision curves) ----------
-st.subheader("Decision curves by threshold")
-thresholds = list(range(15, 181, 15))
-rows = []
-for t in thresholds:
-    mt = metrics_for_threshold(df_scope, t)
-    proxy_rev_share = mt["blocked_rate"]  # proxy if no revenue
-    rows.append({
-        "Threshold (min)": t,
-        "Blocked rate (of with-gap)": mt["blocked_rate"],
-        "Solved (count)": mt["solved"],
-        "Solve rate (given blocked)": mt["solve_rate_given_blocked"],
-        "Overlap problems today": mt["problems_today"],
-        "Revenue share blocked": mt["revenue_share_blocked"] if REVENUE_COL else np.nan,
-        "Proxy: rental share blocked": proxy_rev_share if not REVENUE_COL else np.nan
-    })
-curve_df = pd.DataFrame(rows)
+# Threshold sweep (current scope)
+st.subheader("How metrics evolve with the threshold (current scope)")
+sweep_df = sweep_thresholds(df_scope, thresholds)
 
 c1, c2 = st.columns(2)
 with c1:
-    st.markdown("**Blocked vs Solved**")
-    fig1, ax1 = plt.subplots(figsize=(5,4))
-    ax1.plot(curve_df["Threshold (min)"], curve_df["Blocked rate (of with-gap)"], marker="o", label="Blocked rate")
-    ax1.plot(curve_df["Threshold (min)"], curve_df["Solve rate (given blocked)"], marker="o", label="Solve rate (given blocked)")
-    ax1.set_xlabel("Threshold (minutes)")
-    ax1.set_ylabel("Rate")
-    ax1.legend()
-    st.pyplot(fig1, clear_figure=True)
+    fig, ax = plt.subplots(figsize=(6,4))
+    ax.plot(sweep_df["threshold"], sweep_df["blocked_rate"], marker="o", label="Blocked rate (of with-gap)")
+    ax.plot(sweep_df["threshold"], sweep_df["solve_rate"], marker="o", label="Solve rate (given blocked)")
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Rate")
+    ax.legend()
+    st.pyplot(fig, clear_figure=True)
 
 with c2:
-    st.markdown("**Problems solved (count)**")
-    fig2, ax2 = plt.subplots(figsize=(5,4))
-    ax2.plot(curve_df["Threshold (min)"], curve_df["Solved (count)"], marker="o")
-    ax2.set_xlabel("Threshold (minutes)")
-    ax2.set_ylabel("Solved (count)")
-    st.pyplot(fig2, clear_figure=True)
+    fig, ax = plt.subplots(figsize=(6,4))
+    ax.plot(sweep_df["threshold"], sweep_df["solved"], marker="o")
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Problems solved (count)")
+    ax.set_title("Problems solved vs threshold")
+    st.pyplot(fig, clear_figure=True)
+
+# Required analysis: How often late & impact next driver
+st.subheader("How often are drivers late, and how much does it impact the next driver?")
+d_lat = df_scope[df_scope["overlap_problem"]]
+colA, colB = st.columns(2)
+with colA:
+    rate = (len(d_lat) / max(1, df_scope["has_gap"].sum()))
+    st.metric("Overlap (late beyond gap) rate", f"{rate:.1%}")
+with colB:
+    st.metric("Avg wait for impacted next driver (min)", f"{d_lat['wait_for_next_minutes'].mean():.1f}")
+
+fig, ax = plt.subplots(figsize=(6,4))
+ax.hist(d_lat["wait_for_next_minutes"].dropna(), bins=30)
+ax.set_xlabel("Wait for next driver (minutes)")
+ax.set_ylabel("Count of rentals")
+ax.set_title("Distribution of wait time when overlaps occur")
+st.pyplot(fig, clear_figure=True)
+
+# Required analysis: Share of owner revenue affected (or proxy)
+st.subheader("Which share of owner revenue would be affected?")
+if REVENUE_COL:
+    tmp = []
+    for t in thresholds:
+        m = metrics_for(df_scope, t)
+        tmp.append((t, m["revenue_share_blocked"]))
+    rev_df = pd.DataFrame(tmp, columns=["threshold","revenue_share_blocked"]).dropna()
+    fig, ax = plt.subplots(figsize=(6,4))
+    ax.plot(rev_df["threshold"], rev_df["revenue_share_blocked"], marker="o")
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Revenue share blocked")
+    st.pyplot(fig, clear_figure=True)
+else:
+    fig, ax = plt.subplots(figsize=(6,4))
+    ax.plot(sweep_df["threshold"], sweep_df["blocked_rate"], marker="o")
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Share of rentals blocked (proxy)")
+    st.pyplot(fig, clear_figure=True)
+
+# ---- Automatic, data-driven threshold suggestion (transparent rule)
+# Rule: choose threshold maximizing "problems solved" while keeping blocked_rate <= cap.
+# You can tweak cap below; default 15% of with-gap rentals.
+BLOCKED_RATE_CAP = 0.15
+candidates = sweep_df[sweep_df["blocked_rate"] <= BLOCKED_RATE_CAP]
+if not candidates.empty:
+    best_row = candidates.sort_values(["solved","solve_rate","threshold"], ascending=[False,False,True]).iloc[0]
+    suggested_threshold = int(best_row["threshold"])
+else:
+    # If all thresholds exceed the cap, pick the one with best ratio solved/blocked
+    sweep_df["efficiency"] = sweep_df["solved"] / sweep_df["blocked"].replace({0:np.nan})
+    best_row = sweep_df.sort_values(["efficiency","solved"], ascending=False).iloc[0]
+    suggested_threshold = int(best_row["threshold"])
+
+st.markdown("**Threshold Recommendation (based on current scope):**")
+st.success(
+    f"Set the minimum delay to **{suggested_threshold} minutes** — "
+    f"it solves **{int(best_row['solved']):,}** problematic cases while keeping the "
+    f"blocked rate at **{best_row['blocked_rate']:.1%}**."
+)
 
 st.markdown("---")
 
-# ---------- Revenue share (if available) ----------
+# =========================================================
+# SECTION 2 — SCOPE DECISION (All cars vs Connect only)
+# =========================================================
+st.title("Decision 2 — Scope (apply to all cars or Connect only?)")
+
+# Build threshold sweeps for both scopes
+df_all = filter_scope(df, "all")
+df_conn = filter_scope(df, "connect")
+sweep_all = sweep_thresholds(df_all, thresholds).assign(scope="All cars")
+sweep_con = sweep_thresholds(df_conn, thresholds).assign(scope="Connect only")
+cmp = pd.concat([sweep_all, sweep_con], ignore_index=True)
+
+# Required analysis: rentals affected vs threshold & scope
+st.subheader("How many rentals would be affected by threshold & scope?")
+fig, ax = plt.subplots(figsize=(7,4))
+for label, g in cmp.groupby("scope"):
+    ax.plot(g["threshold"], g["blocked"], marker="o", label=label)
+ax.set_xlabel("Threshold (minutes)")
+ax.set_ylabel("Blocked rentals (count, with-gap only)")
+ax.legend()
+st.pyplot(fig, clear_figure=True)
+
+# Required analysis: problematic cases solved vs threshold & scope
+st.subheader("How many problematic cases will be solved?")
+fig, ax = plt.subplots(figsize=(7,4))
+for label, g in cmp.groupby("scope"):
+    ax.plot(g["threshold"], g["solved"], marker="o", label=label)
+ax.set_xlabel("Threshold (minutes)")
+ax.set_ylabel("Problems solved (count)")
+ax.legend()
+st.pyplot(fig, clear_figure=True)
+
+# Efficiency plot: solved per blocked (avoid harming availability)
+st.subheader("Efficiency: problems solved per blocked rental")
+cmp_eff = cmp.copy()
+cmp_eff["efficiency"] = cmp_eff["solved"] / cmp_eff["blocked"].replace({0:np.nan})
+fig, ax = plt.subplots(figsize=(7,4))
+for label, g in cmp_eff.groupby("scope"):
+    ax.plot(g["threshold"], g["efficiency"], marker="o", label=label)
+ax.set_xlabel("Threshold (minutes)")
+ax.set_ylabel("Solved / Blocked")
+ax.legend()
+st.pyplot(fig, clear_figure=True)
+
+# Revenue share by scope (or proxy)
+st.subheader("Share of owner revenue affected (by scope)")
 if REVENUE_COL:
-    st.subheader("Share of owner revenue blocked (by threshold)")
-    fig3, ax3 = plt.subplots(figsize=(6,4))
-    ax3.plot(curve_df["Threshold (min)"], curve_df["Revenue share blocked"], marker="o")
-    ax3.set_xlabel("Threshold (minutes)")
-    ax3.set_ylabel("Revenue share blocked")
-    st.pyplot(fig3, clear_figure=True)
+    rows = []
+    for sc, dat in [("All cars", df_all), ("Connect only", df_conn)]:
+        for t in thresholds:
+            m = metrics_for(dat, t)
+            rows.append({"scope": sc, "threshold": t, "revenue_share_blocked": m["revenue_share_blocked"]})
+    rev_cmp = pd.DataFrame(rows).dropna()
+    fig, ax = plt.subplots(figsize=(7,4))
+    for label, g in rev_cmp.groupby("scope"):
+        ax.plot(g["threshold"], g["revenue_share_blocked"], marker="o", label=label)
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Revenue share blocked")
+    ax.legend()
+    st.pyplot(fig, clear_figure=True)
+else:
+    fig, ax = plt.subplots(figsize=(7,4))
+    for label, g in cmp.groupby("scope"):
+        ax.plot(g["threshold"], g["blocked_rate"], marker="o", label=label)
+    ax.set_xlabel("Threshold (minutes)")
+    ax.set_ylabel("Share of rentals blocked (proxy)")
+    ax.legend()
+    st.pyplot(fig, clear_figure=True)
+
+# ---- Scope recommendation (transparent rule)
+# Pick, at your chosen threshold, the scope with (a) more problems solved,
+# and (b) lower or comparable blocked rate; if tie, pick higher efficiency.
+m_all  = metrics_for(df_all, threshold)
+m_conn = metrics_for(df_conn, threshold)
+
+def efficiency(m): 
+    return (m["solved"] / m["blocked"]) if m["blocked"] > 0 else 0.0
+
+choice = "All cars"
+reason = ""
+if (m_conn["solved"] > m_all["solved"]) and (m_conn["blocked_rate"] <= m_all["blocked_rate"]):
+    choice = "Connect only"
+elif (abs(m_conn["solved"] - m_all["solved"]) <= 2) and (m_conn["blocked_rate"] + 0.01 < m_all["blocked_rate"]):
+    choice = "Connect only"
 else:
-    st.subheader("Proxy: share of rentals blocked (by threshold)")
-    fig4, ax4 = plt.subplots(figsize=(6,4))
-    ax4.plot(curve_df["Threshold (min)"], curve_df["Proxy: rental share blocked"], marker="o")
-    ax4.set_xlabel("Threshold (minutes)")
-    ax4.set_ylabel("Share of rentals blocked (proxy)")
-    st.pyplot(fig4, clear_figure=True)
-
-# ---------- Footer ----------
-st.caption("All metrics are computed from raw gaps and delays; no heuristic business assumptions.")
+    # tie-breaker on efficiency
+    if efficiency(m_conn) > efficiency(m_all) and m_conn["blocked_rate"] <= m_all["blocked_rate"] + 0.01:
+        choice = "Connect only"
+
+if choice == "Connect only":
+    reason = (
+        f"At **{threshold} min**, Connect-only solves **{m_conn['solved']:,}** vs **{m_all['solved']:,}** "
+        f"problems, with a blocked rate of **{m_conn['blocked_rate']:.1%}** vs **{m_all['blocked_rate']:.1%}**."
+    )
+else:
+    reason = (
+        f"At **{threshold} min**, All cars solves **{m_all['solved']:,}** vs **{m_conn['solved']:,}** "
+        f"problems, with a blocked rate of **{m_all['blocked_rate']:.1%}** vs **{m_conn['blocked_rate']:.1%}**."
+    )
+
+st.markdown("**Scope Recommendation (at your selected threshold):**")
+st.success(f"Apply to **{choice}**. {reason}")
+
+# ------- Method note (expandable) -------
+with st.expander("How we compute metrics (transparency)"):
+    st.markdown("""
+- **Overlap problem (today):** `delay_at_checkout_in_minutes (cleaned) > time_delta_with_previous_rental_in_minutes`
+- **Next-driver wait:** `max(delay - gap, 0)`
+- **Blocked by buffer:** `gap < threshold`
+- **Solved by buffer:** `overlap_problem AND blocked`
+- **Blocked rate:** `blocked / rentals_with_gap`
+- **Solve rate:** `solved / blocked`
+- **Revenue share blocked:** sum(revenue for blocked) / sum(revenue all), if a revenue column exists.
+""")
+
+st.markdown("---")
+st.caption("Built for Getaround — answers focused on Threshold & Scope only, with transparent calculations.")