Update app.py

app.py

@@ -6,13 +6,15 @@ import gradio as gr
 
 # ==========================================
 # CARPL Multi-Use-Case ROI Calculators (MMG / FFR-CT / MSK AI)
-# Shared UI/UX: Inter font, white cards, pill header, Overall + Tabs + Waterfall + Evidence + CTA
-# Extras: card-style use case chooser, MMG vendor presets, CSV export
-# MSK: hides zero-value rows & bars; no NaNs, only relevant metrics
+# - Consistent UI/UX across use cases
+# - Waterfall now colors COSTS in red automatically
+# - Monthly/Annual toggle (default: Annual)
+# - MSK hides zero/NA metrics
+# - ROI/Payback shown only when finite
 # ==========================================
 
 USE_CASES = ["Mammography AI (MMG)", "FFR-CT AI", "MSK AI (ER/Trauma)"]
-CTA_URL = "https://carpl.ai/contact-us"  # swap to your HubSpot/Calendly
+CTA_URL = "https://carpl.ai/contact-us"
 CTA_LABEL = "Book a 15-min walkthrough"
 
 MMG_VENDOR_PRESETS = {
@@ -69,6 +71,9 @@ def pct(x: float, digits: int = 1) -> str:
 def clamp_nonneg(x: float) -> float:
     return max(0.0, float(x))
 
+def safe_fraction(x: float) -> float:
+    return max(0.0, min(1.0, float(x)))
+
 def write_csv(rows, title: str = "roi_results") -> str:
     """Write rows [(label, value), ...] to a temp CSV and return file path."""
     csv_dir = Path(tempfile.gettempdir())
@@ -104,11 +109,13 @@ def compute_mmg(
     monthly_ai_cases = clamp_nonneg(monthly_volume)
     annual_ai_cases = monthly_ai_cases * 12.0
 
+    # Clinical
     errors_reduced     = clamp_nonneg(monthly_ai_cases * (base_ppr - ai_ppr))
     discrepant_flags   = clamp_nonneg(monthly_ai_cases * (ai_audit_rate - base_audit_rate))
     recalls_avoided    = clamp_nonneg(monthly_ai_cases * (base_recall_rate - ai_recall_rate))
     earlier_detections = clamp_nonneg(monthly_ai_cases * (early_detect_uplift_per_1000 / 1000.0))
 
+    # Ops
     base_read_seconds = read_minutes * 60.0
     hours_saved = clamp_nonneg(monthly_ai_cases * (base_read_seconds * read_reduction_pct) / 3600.0)
     workload_reduction_pct = read_reduction_pct
@@ -116,6 +123,7 @@ def compute_mmg(
     capacity_increase_pct = (1.0 / max(1e-6, (1.0 - read_reduction_pct)) - 1.0)
     value_time_saved_month = hours_saved * radiologist_hourly_cost
 
+    # $$
     baseline_monthly_cost         = monthly_ai_cases * base_cost_per_scan
     new_monthly_cost              = baseline_monthly_cost * (1.0 - cost_reduction_pct)
     per_scan_cost_savings_month   = baseline_monthly_cost - new_monthly_cost
@@ -133,7 +141,7 @@ def compute_mmg(
     ops_value_month    = value_time_saved_month + per_scan_cost_savings_month + recall_cost_savings_month + early_detection_savings_month
 
     net_impact_month = incr_revenue_month - incr_costs_month + ops_value_month
-    roi_pct_annual   = ((net_impact_month*12) / (incr_costs_month*12)) if incr_costs_month > 0 else float("nan")
+    roi_pct_annual   = ( (net_impact_month*12) / max(1e-6, (incr_costs_month*12)) )
     months_to_payback = (
         (platform_annual_fee + vendor_per_case_fee*annual_ai_cases + other_costs_month*12.0)
         / max(1e-6, (net_impact_month / max(1.0, monthly_ai_cases))) / max(1.0, monthly_ai_cases)
@@ -168,7 +176,7 @@ def compute_mmg(
                 ("Integration & cloud (mo)", usd(other_costs_month)),
                 ("Net impact (mo)", f"<b>{usd(net_impact_month)}</b>"),
                 ("Net impact (annual)", f"<b>{usd(net_impact_month*12)}</b>"),
-                ("ROI % (annual)", f"<b>{'' if math.isnan(roi_pct_annual) else f'{roi_pct_annual*100:.1f}%'}</b>"),
+                ("ROI % (annual)", f"<b>{roi_pct_annual*100:.1f}%</b>"),
                 ("Months to payback", f"<b>{months_to_payback:.1f}</b>"),
             ]
         },
@@ -192,7 +200,7 @@ def compute_mmg(
                 ("Effective capacity increase", pct(capacity_increase_pct)),
             ]
         },
-        "waterfall": [("Incremental revenue", incr_revenue_month), ("Incremental costs", -incr_costs_month), ("Operational value", ops_value_month)],
+        "waterfall_monthly": [("Incremental revenue", incr_revenue_month), ("Incremental costs", -incr_costs_month), ("Operational value", ops_value_month)],
         "annual_card": {
             "incr_rev": incr_revenue_month * 12.0,
             "incr_costs": incr_costs_month * 12.0,
@@ -226,65 +234,68 @@ def compute_ffrct(
         net_cost_per_diag_ica = 4000.0
 
     monthly_eligible_ccta = clamp_nonneg(monthly_eligible_ccta)
-    uptake = max(0.0, min(1.0, uptake_pct/100.0 * max(0.0, min(1.0, sens_uptake_factor_pct/100.0))))
+    uptake = safe_fraction(uptake_pct/100.0) * safe_fraction(sens_uptake_factor_pct/100.0)
     annual_eligible = monthly_eligible_ccta * 12.0
-    annual_uptake_cases = annual_eligible * uptake
-
-    pct_ai_qpa     = max(0.0, min(1.0, pct_billed_ai_qpa/100.0))
-    one_test_dx    = max(0.0, min(1.0, one_test_dx_pct/100.0))
-    dec_unnec_ica  = max(0.0, min(1.0, dec_unnec_ica_pct/100.0 * max(0.0, min(1.0, sens_dec_unnec_ica_factor_pct/100.0))))
-    more_likely_revasc = max(0.0, min(1.0, more_likely_revasc_pct/100.0))
-    revasc_prev    = max(0.0, min(1.0, revasc_prevalence_pct/100.0))
-    vendor_cost    = float(vendor_per_case_cost) * max(0.0, min(1.0, sens_vendor_cost_factor_pct/100.0))
+    annual_ai_cases = annual_eligible * uptake
+
+    pct_ai_qpa     = safe_fraction(pct_billed_ai_qpa/100.0)
+    one_test_dx    = safe_fraction(one_test_dx_pct/100.0)
+    dec_unnec_ica  = safe_fraction(dec_unnec_ica_pct/100.0) * safe_fraction(sens_dec_unnec_ica_factor_pct/100.0)
+    more_likely_revasc = safe_fraction(more_likely_revasc_pct/100.0)
+    revasc_prev    = safe_fraction(revasc_prevalence_pct/100.0)
+    vendor_cost    = float(vendor_per_case_cost) * safe_fraction(sens_vendor_cost_factor_pct/100.0)
     platform_annual_cost = float(platform_annual_cost)
     stress_test_cost     = float(stress_test_cost)
 
+    # Baseline (annual)
     baseline_revenue = annual_eligible * reimb_ccta
-    baseline_additional_tests = annual_eligible * max(0.0, min(1.0, baseline_additional_testing_rate_pct/100.0))
+    baseline_additional_tests = annual_eligible * safe_fraction(baseline_additional_testing_rate_pct/100.0)
     baseline_additional_tests_cost = baseline_additional_tests * stress_test_cost
-    baseline_diag_ica_total = annual_eligible * max(0.0, min(1.0, baseline_diag_ica_rate_pct/100.0))
+    baseline_diag_ica_total = annual_eligible * safe_fraction(baseline_diag_ica_rate_pct/100.0)
     baseline_revasc_true = annual_eligible * revasc_prev
     baseline_unnecessary_ica = max(0.0, baseline_diag_ica_total - baseline_revasc_true)
     baseline_unnecessary_ica_cost = baseline_unnecessary_ica * net_cost_per_diag_ica
     baseline_ops_value = 0.0
     baseline_costs = baseline_additional_tests_cost + baseline_unnecessary_ica_cost
 
+    # With AI (annual)
     with_ai_revenue = (
         annual_eligible * reimb_ccta
-        + annual_uptake_cases * reimb_ffrct
-        + annual_uptake_cases * pct_ai_qpa * reimb_ai_qpa
+        + annual_ai_cases * reimb_ffrct
+        + annual_ai_cases * pct_ai_qpa * reimb_ai_qpa
     )
-    with_ai_vendor_costs = annual_uptake_cases * vendor_cost
+    with_ai_vendor_costs = annual_ai_cases * vendor_cost
     with_ai_platform_costs = platform_annual_cost
 
-    baseline_addl_tests_in_ai_cohort = annual_uptake_cases * max(0.0, min(1.0, baseline_additional_testing_rate_pct/100.0))
-    with_ai_additional_tests = annual_uptake_cases * (1.0 - one_test_dx)
+    baseline_addl_tests_in_ai_cohort = annual_ai_cases * safe_fraction(baseline_additional_testing_rate_pct/100.0)
+    with_ai_additional_tests = annual_ai_cases * (1.0 - one_test_dx)
     with_ai_additional_tests_cost = with_ai_additional_tests * stress_test_cost
     avoided_additional_tests = max(0.0, baseline_addl_tests_in_ai_cohort - with_ai_additional_tests)
 
-    avoided_unnec_ica = baseline_unnecessary_ica * dec_unnec_ica * (annual_uptake_cases / annual_eligible if annual_eligible > 0 else 0)
+    avoided_unnec_ica = baseline_unnecessary_ica * dec_unnec_ica * (annual_ai_cases / annual_eligible if annual_eligible > 0 else 0.0)
     with_ai_unnecessary_ica = max(0.0, baseline_unnecessary_ica - avoided_unnec_ica)
     with_ai_unnecessary_ica_cost = with_ai_unnecessary_ica * net_cost_per_diag_ica
 
     ai_saved_hours_per_case = min(max(0.0, ai_time_to_decision_min/60.0), max(0.0, float(avg_time_to_decision_today_hours)))
-    bed_hours_saved = annual_uptake_cases * ai_saved_hours_per_case
+    bed_hours_saved = annual_ai_cases * ai_saved_hours_per_case
     bed_hours_value = bed_hours_saved * bed_hour_value
-    clinician_hours_saved = annual_uptake_cases * max(0.0, float(baseline_clinician_touch_min)/60.0) * max(0.0, min(1.0, clinician_touch_reduction_pct/100.0))
+    clinician_hours_saved = annual_ai_cases * max(0.0, float(baseline_clinician_touch_min)/60.0) * safe_fraction(clinician_touch_reduction_pct/100.0)
     clinician_hours_value = clinician_hours_saved * clinician_hour_cost
     with_ai_ops_value = bed_hours_value + clinician_hours_value
 
     with_ai_costs = with_ai_vendor_costs + with_ai_platform_costs + with_ai_additional_tests_cost + with_ai_unnecessary_ica_cost
+
     incr_revenue = with_ai_revenue - baseline_revenue
     incr_costs   = with_ai_costs - baseline_costs
     incr_ops     = with_ai_ops_value - baseline_ops_value
     net_impact   = incr_revenue - incr_costs + incr_ops
 
     ai_program_costs = with_ai_vendor_costs + with_ai_platform_costs
-    roi_pct_val = (net_impact / ai_program_costs) if ai_program_costs > 0 else float("nan")
+    roi_pct_val = net_impact / max(1e-6, ai_program_costs)
 
-    per_case_net_impact = (net_impact / annual_uptake_cases) if annual_uptake_cases > 0 else 0.0
-    cases_to_payback = (ai_program_costs / per_case_net_impact) if per_case_net_impact > 0 else math.inf
-    months_to_payback = ((cases_to_payback / (monthly_eligible_ccta * (uptake))) if (monthly_eligible_ccta * uptake) > 0 and cases_to_payback != math.inf else math.inf)
+    per_case_net_impact = (net_impact / annual_ai_cases) if annual_ai_cases > 0 else 0.0
+    cases_to_payback = (ai_program_costs / max(1e-6, per_case_net_impact)) if per_case_net_impact > 0 else math.inf
+    months_to_payback = (cases_to_payback / (monthly_eligible_ccta * uptake)) if (monthly_eligible_ccta * uptake) > 0 else math.inf
 
     evidence = """
     <ul class='evidence'>
@@ -295,7 +306,7 @@ def compute_ffrct(
     """
 
     return {
-        "summary": f"For your program with {int(annual_uptake_cases):,} AI cases/year, modeled net impact is {usd(net_impact)} annually.",
+        "summary": f"For your program with {int(annual_ai_cases):,} AI cases/year, modeled net impact is {usd(net_impact)} annually.",
         "financial": {
             "rows": [
                 ("Incremental revenue (annual)", usd(incr_revenue)),
@@ -303,7 +314,7 @@ def compute_ffrct(
                 ("Operational value (annual)", usd(incr_ops)),
                 ("AI program costs (annual)", usd(ai_program_costs)),
                 ("Net impact (annual)", f"<b>{usd(net_impact)}</b>"),
-                ("ROI % (annual on AI program)", f"<b>{'' if math.isnan(roi_pct_val) else f'{roi_pct_val*100:.1f}%'}</b>"),
+                ("ROI % (annual on AI program)", f"<b>{roi_pct_val*100:.1f}%</b>"),
                 ("Months to payback", f"<b>{'∞' if months_to_payback==math.inf else f'{months_to_payback:.1f}'}</b>"),
             ]
         },
@@ -328,7 +339,7 @@ def compute_ffrct(
                 ("Value of clinician time", usd(clinician_hours_value)),
             ]
         },
-        "waterfall": [("Incremental revenue", incr_revenue), ("Incremental costs", -incr_costs), ("Operational value", incr_ops)],
+        "waterfall_annual": [("Incremental revenue", incr_revenue), ("Incremental costs", -incr_costs), ("Operational value", incr_ops)],
         "annual_card": {
             "incr_rev": incr_revenue,
             "incr_costs": incr_costs,
@@ -349,8 +360,8 @@ def compute_msk(
 ):
     scans_per_month = clamp_nonneg(scans_per_day) * 30.0
 
-    # Clinical volumes
-    errors_reduced_per_month = int(scans_per_month * 0.05 * 0.20)   # example incidence × improvement
+    # Clinical volumes (illustrative)
+    errors_reduced_per_month = int(scans_per_month * 0.05 * 0.20)   # incidence × improvement
     discrepant_cases_flagged = int(scans_per_month * 0.05)
     hrs_saved_per_visit      = max(0.0, er_time_to_treatment_min) * 0.50 / 60.0
 
@@ -358,34 +369,29 @@ def compute_msk(
     time_saved_per_scan_min  = max(0.0, reading_time_min) * 0.30
     total_time_saved_hours   = (scans_per_month * time_saved_per_scan_min) / 60.0
     value_time_saved_month   = total_time_saved_hours * radiologist_hourly_cost
-    radiologist_cost_savings = scans_per_month * 4.0  # proxy from earlier MSK model
+    radiologist_cost_savings = scans_per_month * 4.0  # conservative proxy
     ops_value_month          = value_time_saved_month + radiologist_cost_savings
 
-    # Financial (FFS-style): no extra revenue/costs modeled here
+    # Financial: by default not counted
     incr_revenue_month = 0.0
     incr_costs_month   = 0.0
 
-    # Clinical value ($) — placeholder (0); if you later monetize, wire it here
-    clinical_value_month = 0.0
-
-    # Net impact
-    net_impact_month = incr_revenue_month - incr_costs_month + ops_value_month + clinical_value_month
+    net_impact_month = incr_revenue_month - incr_costs_month + ops_value_month
 
     evidence = """
     <ul class='evidence'>
       <li>Faster ED triage modeled via shorter time-to-treatment and reduced radiologist touch time.</li>
       <li>Audit flags approximate discrepancy capture for QA workflows.</li>
-      <li>Staff time savings converted to dollar value at radiologist $/hr.</li>
+      <li>Staff time savings converted to $ value at radiologist $/hr.</li>
     </ul>
     """
 
-    # Build rows conditionally (hide zeros)
+    # Conditional rows (hide zeros)
     fin_rows = []
     if incr_revenue_month != 0:
         fin_rows.append(("Incremental revenue (mo)", usd(incr_revenue_month)))
     if incr_costs_month != 0:
         fin_rows.append(("Incremental costs (mo)", usd(incr_costs_month)))
-    # Always show net
     fin_rows.append(("Net impact (mo)", f"<b>{usd(net_impact_month)}</b>"))
 
     clin_rows = []
@@ -404,7 +410,7 @@ def compute_msk(
     if radiologist_cost_savings > 0:
         op_rows.append(("Radiologist cost proxy savings (mo)", usd(radiologist_cost_savings)))
 
-    # Waterfall: include only nonzero components
+    # Waterfall (monthly), include only nonzero components
     wf_rows = []
     if incr_revenue_month != 0:
         wf_rows.append(("Incremental revenue", incr_revenue_month))
@@ -412,19 +418,16 @@ def compute_msk(
         wf_rows.append(("Incremental costs", -incr_costs_month))
     if ops_value_month != 0:
         wf_rows.append(("Operational value", ops_value_month))
-    if clinical_value_month != 0:
-        wf_rows.append(("Clinical value", clinical_value_month))
-    # If all are zero except ops (typical), wf_rows will still show ops
+    if not wf_rows:
+        wf_rows = [("Operational value", ops_value_month)]
 
     annual_card = {
         "incr_rev": incr_revenue_month * 12.0,
         "incr_costs": incr_costs_month * 12.0,
-        # only add clinical_value if monetized
-        # "clinical_value": clinical_value_month * 12.0,
         "ops_value": ops_value_month * 12.0,
         "net": net_impact_month * 12.0,
-        "roi_pct": None,   # hide in Overall Impact
-        "payback": None,   # hide in Overall Impact
+        "roi_pct": None,   # hidden
+        "payback": None,   # hidden
     }
 
     return {
@@ -432,31 +435,28 @@ def compute_msk(
         "financial": {"rows": fin_rows},
         "clinical": {"rows": clin_rows, "bars": [("Touch-time reduction", 0.30)] if time_saved_per_scan_min > 0 else []},
         "operational": {"rows": op_rows},
-        "waterfall": wf_rows if wf_rows else [("Operational value", ops_value_month)],
+        "waterfall_monthly": wf_rows,
         "annual_card": annual_card,
         "evidence": evidence,
     }
 
 # ---------- Card / HTML builders ----------
 def build_overall_card(title: str, summary_line: str, annual: dict):
-    """Conditional Overall card: shows Financial + Clinical + Operational; hides ROI/Payback if N/A or invalid."""
     rows = []
     if "incr_rev" in annual and annual["incr_rev"] != 0:
         rows.append(("Incremental revenue (annual)", f"<b>{usd(annual['incr_rev'])}</b>"))
     if "incr_costs" in annual and annual["incr_costs"] != 0:
         rows.append(("Incremental costs (annual)", f"<b class='neg'>{usd(annual['incr_costs'])}</b>"))
-    if "clinical_value" in annual and isinstance(annual["clinical_value"], (int, float)) and annual["clinical_value"] != 0:
-        rows.append(("Clinical value (annual)", f"<b>{usd(annual['clinical_value'])}</b>"))
     if "ops_value" in annual and annual["ops_value"] != 0:
         rows.append(("Operational value (annual)", f"<b>{usd(annual['ops_value'])}</b>"))
     if "net" in annual:
         rows.append(("Net impact (annual)", f"<b>{usd(annual['net'])}</b>"))
 
     roi = annual.get("roi_pct", None)
-    if isinstance(roi, (int, float)) and not (math.isnan(roi) or math.isinf(roi)):
+    if isinstance(roi, (int, float)) and math.isfinite(roi):
         rows.append(("ROI %", f"<b>{roi*100:.1f}%</b>"))
     payback = annual.get("payback", None)
-    if isinstance(payback, (int, float)) and not (math.isnan(payback) or math.isinf(payback)):
+    if isinstance(payback, (int, float)) and math.isfinite(payback):
         rows.append(("Months to payback", f"<b>{payback:.1f}</b>"))
 
     items = "".join(f"<div>{lab}</div><div>{val}</div>" for lab, val in rows)
@@ -480,8 +480,7 @@ def build_clinical_card(rows, bars):
     bars_html = ""
     for lab, frac in (bars or []):
         frac = max(0.0, min(1.0, float(frac)))
-        # skip rendering a 0% bar entirely
-        if frac <= 0: 
+        if frac <= 0:
             continue
         bars_html += f"""
           <div class='bar-row'>
@@ -492,17 +491,26 @@ def build_clinical_card(rows, bars):
     bars_section = f"<div class='bars'>{bars_html}</div>" if bars_html else ""
     return f"<div class='card'><div class='card-title'>Clinical</div><div class='kpi-grid'>{rows_html}</div>{bars_section}</div>"
 
-def build_waterfall(wf_rows, title="Waterfall (monthly)"):
-    # Remove exact-zero bars, but keep at least one row (Net shows separately)
-    filtered = [(l, v) for (l, v) in wf_rows if abs(float(v)) > 1e-9]
-    wf_rows = filtered if filtered else wf_rows
+def build_waterfall(wf_rows, period_label="Annual"):
+    """
+    wf_rows: list of (label, value) where value is signed.
+    Colors: positive=green, negative=red (costs).
+    """
+    # remove exact zero bars
+    wf_rows = [(l, v) for (l, v) in wf_rows if abs(float(v)) > 1e-9]
+    if not wf_rows:
+        return "<div class='card'><div class='card-title'>Waterfall ({})</div><div>—</div></div>".format(period_label)
+
     denom = sum(abs(v) for _, v in wf_rows) or 1.0
+
     def row(label, val):
         width = min(100, max(2, int(abs(val)/denom * 100)))
-        cls = "pos" if val >= 0 else "neg"
+        cls = "wf-pos" if val >= 0 else "wf-neg"
         return f"<div class='wf-row'><div>{label}</div><div class='wf-bar {cls}' style='width:{width}%;'><span class='wf-val'>{usd(val)}</span></div></div>"
-    return "<div class='card'><div class='card-title'>{}</div>{}<div class='wf-total'>Net impact: <b>{}</b></div></div>".format(
-        title, "".join(row(l, v) for l, v in wf_rows), usd(sum(v for _, v in wf_rows))
+
+    net_total = sum(v for _, v in wf_rows)
+    return "<div class='card'><div class='card-title'>Waterfall ({})</div>{}<div class='wf-total'>Net impact: <b>{}</b></div></div>".format(
+        period_label, "".join(row(l, v) for l, v in wf_rows), usd(net_total)
     )
 
 def rows_to_csv(fin_rows, clin_rows, op_rows) -> str:
@@ -514,12 +522,11 @@ def build_ui():
     with gr.Blocks(theme=gr.themes.Soft(), css="""
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;800&display=swap');
 * { font-family: Inter, ui-sans-serif, system-ui; }
-.gradio-container { max-width: 1100px !important; }
+.gradio-container { max-width: 1120px !important; }
 .card{background:#fff;border:1px solid #eef2f7;border-radius:18px;padding:18px;box-shadow:0 8px 24px rgba(0,0,0,.08);margin-bottom:12px}
 .card-title{font-weight:700;margin-bottom:6px}
 .pill{background:#ecfdf5;color:#065f46;padding:4px 10px;border-radius:999px;font-weight:700;font-size:.75rem}
 .kpi-grid{display:grid;grid-template-columns:1fr auto;gap:6px 12px}
-.kpi-grid .sep{border-top:1px solid #e5e7eb;padding-top:6px}
 .neg{color:#b91c1c}
 .sumline{margin-bottom:8px;opacity:.9}
 .small-note{opacity:.75;font-size:.9em;margin-top:6px}
@@ -529,9 +536,9 @@ def build_ui():
 .bars .bar span em{position:absolute;right:6px;top:-18px;font-size:.85em;opacity:.8}
 .wf-row{display:grid;grid-template-columns:1fr auto;gap:10px;align-items:center;margin:8px 0}
 .wf-bar{height:22px;border-radius:6px;display:flex;align-items:center;justify-content:flex-end;padding-right:8px;color:#0b1727;min-width:80px}
-.wf-bar.pos{background:linear-gradient(90deg,#a7f3d0,#34d399)}
-.wf-bar.neg{background:linear-gradient(90deg,#fecaca,#f87171)}
-.wf-val{font-weight:700}
+.wf-bar .wf-val{font-weight:700}
+.wf-pos{background:linear-gradient(90deg,#a7f3d0,#34d399)}   /* green */
+.wf-neg{background:linear-gradient(90deg,#fecaca,#f87171)}   /* red for costs/negatives */
 .wf-total{margin-top:8px;border-top:1px solid #e5e7eb;padding-top:8px;font-weight:700}
 .cta{display:flex;justify-content:space-between;align-items:center}
 .cta-btn{background:#0ea5e9;color:#fff;text-decoration:none;padding:10px 14px;border-radius:12px;font-weight:700}
@@ -572,9 +579,8 @@ def build_ui():
 
         with gr.Row():
             with gr.Column(scale=1):
-                # Use case chooser (as cards)
+                # Use case chooser
                 with gr.Column(elem_id="uc"):
-                    gr.Markdown("### We have three pre-loaded use cases")
                     use_case = gr.Radio(
                         choices=[
                             "🩺 Mammography AI (MMG)",
@@ -582,10 +588,16 @@ def build_ui():
                             "🦴 MSK AI (ER/Trauma)"
                         ],
                         value="🩺 Mammography AI (MMG)",
-                        label="Select Use Case",
+                        label="Choose your use case",
+                        interactive=True
+                    )
+                    period = gr.Radio(
+                        choices=["Annual", "Monthly"],
+                        value="Annual",
+                        label="Reporting period",
                         interactive=True
                     )
-                    gr.Markdown("<div class='uc-hint'>Pick one to load the matching calculator. You can switch anytime.</div>")
+                    gr.Markdown("<div class='uc-hint'>Pick a calculator and reporting period. You can switch anytime.</div>")
 
                 # --- MMG Inputs ---
                 vendor_preset = gr.Dropdown(
@@ -671,7 +683,7 @@ def build_ui():
 
         def normalize_uc(uclabel: str) -> str:
             if "Mammography" in uclabel: return USE_CASES[0]
-            if "FFR-CT" in uclabel: return USE_CASES[1]
+            if "FFR" in uclabel: return USE_CASES[1]
             return USE_CASES[2]
 
         def _on_use_case_change(uc_label):
@@ -724,7 +736,7 @@ def build_ui():
         )
 
         def _compute(
-            uclabel,
+            uclabel, period_sel,
             # MMG
             mv, rm, rhr,
             base_ppr, ai_ppr, base_audit, ai_audit, base_recall, ai_recall, recall_cost, read_redux, cps, cps_redux, fol_price, fol_uplift, early_uplift, tx_delta,
@@ -736,6 +748,7 @@ def build_ui():
             msk_day, msk_read, msk_ttt, msk_rhr,
         ):
             uc = normalize_uc(uclabel)
+            annual = (period_sel == "Annual")
 
             if uc == USE_CASES[0]:
                 res = compute_mmg(
@@ -745,6 +758,9 @@ def build_ui():
                     v_fee, p_annual, integ_mo, cloud_mo,
                 )
                 title = "Overall Impact — Mammography AI"
+                # Waterfall source (monthly), scale if annual
+                wf = res["waterfall_monthly"]
+                wf = [(l, v*12.0) for (l, v) in wf] if annual else wf
             elif uc == USE_CASES[1]:
                 res = compute_ffrct(
                     s_type, ccta_mo, uptake, ttd_h, touch_min,
@@ -753,19 +769,24 @@ def build_ui():
                     sens_upt, sens_dec, sens_vendor,
                 )
                 title = "Overall Impact — FFR-CT AI"
+                # Waterfall source (annual), scale if monthly
+                wf = res["waterfall_annual"]
+                wf = [(l, v/12.0) for (l, v) in wf] if not annual else wf
             else:
                 res = compute_msk(msk_day, msk_read, msk_ttt, msk_rhr)
                 title = "Overall Impact — MSK AI"
+                wf = res["waterfall_monthly"]
+                wf = [(l, v*12.0) for (l, v) in wf] if annual else wf
 
             overall_html = build_overall_card(title, res["summary"], res["annual_card"])
             financial_html = build_rows_card("Financial", res["financial"]["rows"])
             clinical_html = build_clinical_card(res["clinical"]["rows"], res["clinical"].get("bars"))
             operational_html = build_rows_card("Operational", res["operational"]["rows"])
-            water = build_waterfall(res["waterfall"])
+            water = build_waterfall(wf, period_label=("Annual" if annual else "Monthly"))
             evidence = f"<div class='card'><div class='card-title'>Evidence snapshot</div>{res['evidence']}<div class='small-note'>Neutral claims; update with site citations.</div></div>"
             cta = f"<div class='card cta'><div>Want to see this in your workflow?</div><a class='cta-btn' href='{CTA_URL}' target='_blank' rel='noopener'>{CTA_LABEL}</a></div>"
 
-            # CSV export -> write to temp file
+            # CSV export
             fin_rows = [(lab, val) for lab, val in res["financial"]["rows"]]
             clin_rows = [(lab, val) for lab, val in res["clinical"]["rows"]]
             op_rows   = [(lab, val) for lab, val in res["operational"]["rows"]]
@@ -774,7 +795,7 @@ def build_ui():
             return overall_html, financial_html, clinical_html, operational_html, water, evidence, gr.update(value=cta, visible=True), gr.update(value=csv_path, visible=True)
 
         inputs = [
-            use_case,
+            use_case, period,
             # MMG inputs
             mmg_monthly_volume, mmg_read_minutes, mmg_rdx_hr_cost,
             mmg_base_ppr, mmg_ai_ppr, mmg_base_audit, mmg_ai_audit, mmg_base_recall, mmg_ai_recall, mmg_recall_cost, mmg_read_redux, mmg_cost_per_scan, mmg_cost_redux, mmg_follow_price, mmg_follow_uplift, mmg_early_uplift_per_1000, mmg_tx_delta,