Refactor scenarios to plans with auto-projections

- Save a plan once (config only), auto-generate projections at 75/100/150/200%
- No more manually saving separate scenarios per attainment level
- New compute_projection() function computes results on-the-fly
- Compare tab shows all attainment levels per plan in one table
- Two charts: Total Comp and Net After Rep by attainment level
- Agreement text auto-generates illustrative earnings from projections
- Backward compatible with legacy scenarios via normalize_plan()
- Configurable attainment levels in sidebar
- Renamed: Scenario Calculator → Plan Builder, Compare Scenarios → Compare Plans

AIRULES.md

@@ -1,12 +1,12 @@
-# Sales Comp Calculator — AI Rules
+# Sales Comp Plan Builder — AI Rules
 
 ## Project Overview
 
-This is a Streamlit-based sales compensation calculator hosted on HuggingFace Spaces. It models different comp plan structures and saves scenarios to a Google Sheet for comparison.
+This is a Streamlit-based sales compensation plan builder hosted on HuggingFace Spaces. Users define comp plans (base salary, quota, commission tiers, ramp, draw, etc.) and the app auto-generates projections at multiple attainment levels (default: 75%, 100%, 150%, 200%).
 
 - **App:** `app.py` (single-file Streamlit app)
 - **Backend:** Google Sheets via public CSV reads + Google Apps Script (`apps_script.js`) for writes
-- **Hosting:** HuggingFace Spaces (private/unlisted) at `stepolan/salescomp`
+- **Hosting:** HuggingFace Spaces (unlisted) at `stepolan/salescomp`
 - **Repo:** `github.com/DBDoyen/salescomp`
 
 ## Deploying Changes
@@ -32,138 +32,107 @@ You will need a HuggingFace token with write access to push. Log in with:
 huggingface-cli login
 ```
 
-## Saving / Updating Scenarios Programmatically
+## Data Model: Plans (v2)
 
-Scenarios are stored in the Google Sheet. You can save or update them by POSTing to the Apps Script URL.
-
-### Apps Script URL
-
-```
-https://script.google.com/macros/s/AKfycbxJTi4RhN-CevolOEsk4egxoTKQ0qgn2eLlmzu5Yv903MVWR-tVBcg02Hr5bBjtX4vj/exec
-```
-
-### Save / Update a Scenario
-
-POST JSON with `action: "save"`. If a scenario with the same `name` exists, it updates in place.
+Plans are saved as JSON to Google Sheets. A plan stores **config only** — results are computed on-the-fly via `compute_projection()`.
 
 ```python
-import requests, json, datetime
-
-SCRIPT_URL = "https://script.google.com/macros/s/AKfycbxJTi4RhN-CevolOEsk4egxoTKQ0qgn2eLlmzu5Yv903MVWR-tVBcg02Hr5bBjtX4vj/exec"
-
-scenario_data = {
+plan_data = {
+    "version": 2,
     "author": "Founder",                       # Generic label, no real names
-    "timestamp": datetime.datetime.now().isoformat(),
+    "timestamp": "2026-03-25T...",
     "commission_mode": "Attainment-based rates",  # or "Deal-size rates + accelerators"
+    "retroactive": False,                       # True = retroactive rates (top rate applies to ALL revenue)
+    "months_employed": 12,
+    "attainment_levels": [75, 100, 150, 200],   # Configurable projection levels
     "params": {
         "base_salary": 150000,
         "annual_quota": 1250000,
         "draw_amount": 0,
         "draw_months": 0,
         "draw_recoverable": True,
-        "ramp_pcts": [25, 50, 75],             # One entry per ramp month, remaining months = 100%
+        "ramp_pcts": [25, 50, 75],
         "cogs_pct": 20.0,
         "other_cost_per_rep": 20000,
-    },
-    "inputs": {
-        "months_employed": 12,
-        "actual_revenue": 1250000,
-    },
-    "results": {
-        "effective_quota": 1093750.0,
-        "attainment_pct": 114.3,
-        "commission": 51562.5,
-        "draw_paid": 0,
-        "total_variable": 51562.5,
-        "total_comp": 201562.5,
-        "gross_profit": 1000000.0,
-        "total_cost_of_rep": 221562.5,
-        "net_after_rep": 778437.5,
-        "roi_on_rep": 5.6,
+        "commission_tiers": [[100, 8.0], [150, 14.0], [200, 26.0], [null, 50.0]],
+        "deal_rate_tiers": null,
+        "accel_tiers": null,
+        # Optional rich fields for agreement text:
+        "equity": {"pct": "0.5", "vesting": "4-year vest with 1-year cliff"},
+        "policies": {...},
+        "illustrative_scenarios": [...],
     },
 }
+```
 
-payload = {
-    "action": "save",
-    "name": "Plan A - Conservative",           # Scenario name (used as key)
-    "author": scenario_data["author"],
-    "timestamp": scenario_data["timestamp"],
-    "data_json": json.dumps(scenario_data),
-}
+### Backward Compatibility
 
-resp = requests.post(SCRIPT_URL, json=payload, timeout=60)
-```
+Legacy scenarios (version 1, no version field) are auto-normalized by `normalize_plan()`. They had `inputs` and `results` baked in — these are ignored and projections are computed fresh from `params`.
 
-### Delete a Scenario
+## Saving / Updating Plans Programmatically
 
-```python
-payload = {"action": "delete", "name": "Plan A - Conservative"}
-requests.post(SCRIPT_URL, json=payload, timeout=60)
+### Apps Script URL
+
+```
+https://script.google.com/macros/s/AKfycbxJTi4RhN-CevolOEsk4egxoTKQ0qgn2eLlmzu5Yv903MVWR-tVBcg02Hr5bBjtX4vj/exec
 ```
 
-### Commission Calculation Logic
+### Save / Update a Plan
 
-**Attainment-based rates** — tiered marginal rates on revenue bands relative to effective quota:
+POST JSON with `action: "save"`. If a plan with the same `name` exists, it updates in place.
 
 ```python
-def calc_commission_attainment(revenue, quota, tiers):
-    """tiers: list of (upper_attainment_pct | None, rate_pct)"""
-    commission = 0.0
-    prev = 0.0
-    for upper, rate in tiers:
-        if upper is None:
-            if revenue > prev * quota / 100:
-                commission += (revenue - prev * quota / 100) * (rate / 100)
-            break
-        boundary = upper * quota / 100
-        if revenue <= prev * quota / 100:
-            break
-        taxable = min(revenue, boundary) - (prev * quota / 100)
-        if taxable > 0:
-            commission += taxable * (rate / 100)
-        prev = upper
-    return commission
-```
+import requests, json, datetime
 
-**Deal-size rates + accelerators** — flat % per deal ACV with attainment multiplier:
+SCRIPT_URL = "https://script.google.com/macros/s/AKfycbxJTi4RhN-CevolOEsk4egxoTKQ0qgn2eLlmzu5Yv903MVWR-tVBcg02Hr5bBjtX4vj/exec"
 
-```python
-commission = revenue * (deal_rate / 100) * accelerator_multiplier
+payload = {
+    "action": "save",
+    "name": "Plan A",
+    "author": plan_data["author"],
+    "timestamp": plan_data["timestamp"],
+    "data_json": json.dumps(plan_data),
+}
+resp = requests.post(SCRIPT_URL, json=payload, timeout=60)
 ```
 
-### Ramp-Adjusted Quota
+### Delete a Plan
 
 ```python
-def calc_ramp_quota(annual_quota, ramp_pcts, months=12):
-    monthly = annual_quota / 12
-    total = 0.0
-    for m in range(min(months, 12)):
-        if m < len(ramp_pcts):
-            total += monthly * (ramp_pcts[m] / 100)
-        else:
-            total += monthly
-    return total
+payload = {"action": "delete", "name": "Plan A"}
+requests.post(SCRIPT_URL, json=payload, timeout=60)
 ```
 
-### Key Formulas
+## Key Functions
+
+### `compute_projection(params, commission_mode, retroactive, attainment_pct, months_employed=12)`
+The core function. Takes plan params and an attainment %, returns a full results dict (commission, total_comp, net_after_rep, etc.). Used for:
+- Auto-generating projections in the Compare tab
+- Agreement text illustrative earnings
+- Can be called programmatically for batch scenario generation
 
-- **Attainment %** = actual_revenue / effective_quota * 100
-- **Draw paid** = draw_amount * (months_employed / draw_months)
+### Commission Calculation
+- **Attainment-based (marginal):** Each tier rate applies only to revenue in that band
+- **Attainment-based (retroactive):** Highest tier reached applies to ALL revenue from dollar one
+- **Deal-size + accelerators:** Flat rate per deal ACV × attainment multiplier
+- Commission tiers are calculated against the **full annual quota** (not ramp-adjusted)
+
+### Key Formulas
+- **Attainment %** = actual_revenue / effective_quota × 100
+- **Revenue at X% attainment** = annual_quota × X / 100
+- **Draw paid** = draw_amount × (months_employed / draw_months)
 - **Total variable** (non-recoverable draw) = commission + draw_paid
 - **Total variable** (recoverable draw) = max(commission, draw_paid)
 - **Total comp** = prorated_base + total_variable
-- **Gross profit** = revenue * (1 - cogs_pct / 100)
-- **Total rep cost** = total_comp + prorated_other_cost
-- **Net after rep** = gross_profit - total_rep_cost
-- **ROI on rep** = revenue / total_rep_cost
+- **Gross profit** = revenue × (1 - cogs_pct / 100)
+- **Net after rep** = gross_profit - total_cost_of_rep
 
 ## Privacy
 
-Do NOT use real names, company names, or identifying information in scenario names or author fields. The Google Sheet is accessible to anyone with the link.
+Do NOT use real names, company names, or identifying information in plan names or author fields. The Google Sheet is accessible to anyone with the link.
 
-## Current Saved Scenarios
+## Google Sheet
 
-Scenarios are in the Google Sheet:
 https://docs.google.com/spreadsheets/d/1SM9_8IRuoKwwtK_pQuF0wwb3DW-CQJgglB3XCBgH11M/edit
 
 Use timeout=60 when POSTing to the Apps Script — it can be slow on first invocation.

app.py

@@ -36,25 +36,26 @@ def _get_apps_script_url():
 
 
 @st.cache_data(ttl=30)
-def load_scenarios() -> dict:
+def load_plans() -> dict:
     sheet_id = _get_sheet_id()
     if not sheet_id:
         return {}
     try:
         csv_url = SHEET_CSV_TMPL.format(sheet_id=sheet_id)
         df = pd.read_csv(csv_url)
-        scenarios = {}
+        plans = {}
         for _, row in df.iterrows():
             try:
-                scenarios[row["name"]] = json.loads(row["data_json"])
+                data = json.loads(row["data_json"])
+                plans[row["name"]] = normalize_plan(data)
             except (json.JSONDecodeError, KeyError):
                 continue
-        return scenarios
+        return plans
     except Exception:
         return {}
 
 
-def save_scenario(name: str, data: dict):
+def save_plan(name: str, data: dict):
     url = _get_apps_script_url()
     if not url:
         raise ValueError("Apps Script URL not configured in secrets")
@@ -70,7 +71,7 @@ def save_scenario(name: str, data: dict):
         raise ValueError(f"Apps Script returned {resp.status_code}")
 
 
-def delete_scenario(name: str):
+def delete_plan(name: str):
     url = _get_apps_script_url()
     if not url:
         raise ValueError("Apps Script URL not configured in secrets")
@@ -80,6 +81,15 @@ def delete_scenario(name: str):
         raise ValueError(f"Apps Script returned {resp.status_code}")
 
 
+def normalize_plan(data):
+    """Ensure loaded data works as a plan regardless of version (backward compat)."""
+    if "version" not in data:
+        data["version"] = 1
+        data.setdefault("months_employed", data.get("inputs", {}).get("months_employed", 12))
+        data.setdefault("attainment_levels", [75, 100, 150, 200])
+    return data
+
+
 # ---------------------------------------------------------------------------
 # Commission engine
 # ---------------------------------------------------------------------------
@@ -90,7 +100,6 @@ def calc_commission_attainment(revenue, quota, tiers, retroactive=False):
     If retroactive=False (marginal): each rate applies only to revenue in that band.
     If retroactive=True: the highest tier reached applies to ALL revenue."""
     if retroactive:
-        # Find the highest tier the rep has reached
         applicable_rate = tiers[0][1]
         for upper_pct, rate in tiers:
             if upper_pct is None:
@@ -100,7 +109,6 @@ def calc_commission_attainment(revenue, quota, tiers, retroactive=False):
                 applicable_rate = rate
                 break
             applicable_rate = rate
-        # Check if we exceeded the last non-None tier
         last_upper = tiers[-2][0] if tiers[-1][0] is None else tiers[-1][0]
         if tiers[-1][0] is None and revenue > last_upper * quota / 100:
             applicable_rate = tiers[-1][1]
@@ -124,10 +132,7 @@ def calc_commission_attainment(revenue, quota, tiers, retroactive=False):
 
 
 def calc_commission_deal_rate(deals, deal_rate_tiers, attainment_pct, accel_tiers):
-    """Deal-size-based commission with attainment accelerators.
-    deal_rate_tiers: list of (min_acv, max_acv | None, rate_pct)
-    accel_tiers: list of (upper_attainment_pct | None, multiplier)
-    """
+    """Deal-size-based commission with attainment accelerators."""
     multiplier = 1.0
     for upper_pct, mult in accel_tiers:
         if upper_pct is None or attainment_pct <= upper_pct:
@@ -171,20 +176,87 @@ def calc_ramp_adjusted_quota(annual_quota, ramp_pcts, months_employed=12):
     return total
 
 
+def compute_projection(params, commission_mode, retroactive, attainment_pct, months_employed=12):
+    """Compute full results for a plan at a given attainment level."""
+    annual_quota = params.get("annual_quota", 0)
+    base_salary = params.get("base_salary", 0)
+    draw_amount = params.get("draw_amount", 0)
+    draw_months_val = params.get("draw_months", 0)
+    draw_recoverable = params.get("draw_recoverable", False)
+    ramp_pcts = params.get("ramp_pcts", [])
+    cogs_pct = params.get("cogs_pct", 20.0)
+    other_cost = params.get("other_cost_per_rep", 0)
+
+    effective_quota = calc_ramp_adjusted_quota(annual_quota, ramp_pcts, months_employed)
+    # Revenue = attainment % of full annual quota (not ramp-adjusted)
+    actual_revenue = annual_quota * attainment_pct / 100
+
+    # Commission
+    if commission_mode == "Attainment-based rates":
+        tiers = params.get("commission_tiers", [])
+        commission = calc_commission_attainment(actual_revenue, annual_quota, tiers, retroactive)
+    else:
+        deal_rate_tiers = params.get("deal_rate_tiers", [])
+        accel_tiers = params.get("accel_tiers", [])
+        avg_rate = 0.0
+        for mn, mx, rt in deal_rate_tiers:
+            if mx is None or actual_revenue / max(1, 12) <= mx:
+                avg_rate = rt
+                break
+        mult = 1.0
+        for upper, m in accel_tiers:
+            if upper is None or attainment_pct <= upper:
+                mult = m
+                break
+        commission = actual_revenue * (avg_rate / 100) * mult
+
+    # Draw
+    active_draw_months = min(int(draw_months_val), months_employed)
+    draw_paid = draw_amount * (active_draw_months / max(int(draw_months_val), 1)) if draw_months_val > 0 else 0
+    if draw_recoverable:
+        total_variable = max(commission, draw_paid)
+    else:
+        total_variable = commission + draw_paid
+
+    prorated_base = base_salary * (months_employed / 12)
+    total_comp = prorated_base + total_variable
+
+    # Company economics
+    gross_profit = actual_revenue * (1 - cogs_pct / 100)
+    total_cost_of_rep = total_comp + other_cost * (months_employed / 12)
+    net_after_rep = gross_profit - total_cost_of_rep
+    roi_on_rep = (actual_revenue / total_cost_of_rep) if total_cost_of_rep > 0 else 0
+
+    return {
+        "actual_revenue": round(actual_revenue, 2),
+        "effective_quota": round(effective_quota, 2),
+        "attainment_pct": round(attainment_pct, 1),
+        "commission": round(commission, 2),
+        "draw_paid": round(draw_paid, 2),
+        "total_variable": round(total_variable, 2),
+        "total_comp": round(total_comp, 2),
+        "gross_profit": round(gross_profit, 2),
+        "total_cost_of_rep": round(total_cost_of_rep, 2),
+        "net_after_rep": round(net_after_rep, 2),
+        "roi_on_rep": round(roi_on_rep, 2),
+    }
+
+
 # ---------------------------------------------------------------------------
 # App
 # ---------------------------------------------------------------------------
 
-st.set_page_config(page_title="Sales Comp Calculator", layout="wide")
-st.title("Sales Compensation Calculator")
+st.set_page_config(page_title="Sales Comp Plan Builder", layout="wide")
+st.title("Sales Comp Plan Builder")
 
 st.markdown("""
-Model different sales compensation plans and compare them side by side.
+Model different compensation plans and compare them side by side.
 
 **How to use:**
-1. **Set plan parameters** in the sidebar on the left (base salary, quota, commission structure, ramp, etc.)
-2. **Enter projected revenue** in the Scenario Calculator tab to see seller payout and company economics
-3. **Save & compare** scenarios to evaluate different plan structures against each other
+1. **Set plan parameters** in the sidebar (base salary, quota, commission structure, ramp, draw, etc.)
+2. **Explore what-if scenarios** in the Plan Builder tab with any revenue number
+3. **Save the plan** and it auto-generates projections at 75%, 100%, 150%, 200% attainment
+4. **Compare plans** side by side in the Compare tab
 """)
 
 # Check config
@@ -269,7 +341,6 @@ if commission_mode == "Attainment-based rates":
             rate = c2.number_input(f"Tier {i+1} rate %", value=d_rate, step=0.5, format="%.1f", key=f"at_r_{i}")
             att_tiers.append((upper, rate))
 else:
-    # -- Deal-size tiers --
     with st.sidebar.expander("Deal-Size Commission Rates", expanded=True):
         num_deal_tiers = st.number_input("Number of deal-size tiers", 1, 6, 3, key="num_deal_tiers")
         deal_defaults = [(0, 29_999, 20.0), (30_000, 100_000, 40.0), (100_001, None, 40.0)]
@@ -286,7 +357,6 @@ else:
             rt = c3.number_input(f"Tier {i+1} rate %", value=d[2], step=1.0, format="%.1f", key=f"dt_rt_{i}")
             deal_rate_tiers.append((mn, mx, rt))
 
-    # -- Accelerators --
     with st.sidebar.expander("Attainment Accelerators", expanded=True):
         st.caption("Multiplier applied to deal commission based on annual attainment")
         num_accels = st.number_input("Number of accelerator tiers", 1, 6, 3, key="num_accels")
@@ -325,16 +395,27 @@ with st.sidebar.expander("Company Economics", expanded=False):
     other_cost_per_rep = st.number_input("Other cost per rep ($)", value=20_000, step=5_000, key="other_cost",
                                           help="Annual cost for benefits, tools, travel, etc. — pro-rated if less than 12 months")
 
-# ---- Main tabs (deeplink via ?tab=scenario|deals|compare) ----
+# -- Projection settings --
+with st.sidebar.expander("Projection Settings", expanded=False):
+    st.caption("Attainment levels used when auto-generating plan projections.")
+    attainment_str = st.text_input("Attainment levels (%)", value="75, 100, 150, 200", key="att_levels")
+    attainment_levels = [int(x.strip()) for x in attainment_str.split(",") if x.strip().isdigit()]
+    if not attainment_levels:
+        attainment_levels = [75, 100, 150, 200]
+
+# ---- Main tabs (deeplink via ?tab=builder|deals|compare) ----
 
-TAB_KEYS = ["scenario", "deals", "compare"]
-TAB_LABELS = ["1. Scenario Calculator", "2. Per-Deal Calculator", "3. Compare Scenarios"]
+TAB_KEYS = ["builder", "deals", "compare"]
+TAB_LABELS = ["1. Plan Builder", "2. Per-Deal Calculator", "3. Compare Plans"]
 TAB_MAP = dict(zip(TAB_KEYS, TAB_LABELS))
 
 qp = st.query_params
-initial_tab = qp.get("tab", "scenario")
+initial_tab = qp.get("tab", "builder")
+# backward compat for old ?tab=scenario links
+if initial_tab == "scenario":
+    initial_tab = "builder"
 if initial_tab not in TAB_KEYS:
-    initial_tab = "scenario"
+    initial_tab = "builder"
 
 active_tab = st.radio(
     "Navigate",
@@ -347,17 +428,17 @@ active_tab = st.radio(
 )
 st.query_params["tab"] = active_tab
 
-# ===================== TAB 1: Scenario Calculator =====================
+# ===================== TAB 1: Plan Builder =====================
 
-if active_tab == "scenario":
-    st.caption("Enter a revenue number to see what the seller earns and what it costs the company.")
+if active_tab == "builder":
+    st.caption("Configure the plan in the sidebar, then explore any revenue number below. Save the plan to auto-generate projections.")
     col_in, col_out = st.columns([1, 1.5])
 
     with col_in:
-        st.subheader("Inputs")
-        author = st.text_input("Scenario author", key="author",
+        st.subheader("What-If Calculator")
+        author = st.text_input("Plan author", key="author",
                                 placeholder="e.g. 'Founder', 'VP Sales'",
-                                help="A generic label for who created this scenario — avoid real names")
+                                help="A generic label for who created this plan — avoid real names")
         months_employed = st.slider("Months in plan year", 1, 12, 12, key="months_emp",
                                      help="Set to less than 12 for mid-year hires — ramp schedule adjusts the quota automatically")
 
@@ -369,8 +450,7 @@ if active_tab == "scenario":
                                           help="Actual or projected closed revenue for the period")
         attainment_pct = (actual_revenue / effective_quota * 100) if effective_quota > 0 else 0
 
-    # Commission tier quota: use full annual quota so OTE math is clean.
-    # Ramp adjusts attainment % display but not the commission tier boundaries.
+    # Commission uses full annual quota for tier boundaries
     commission_quota = annual_quota
 
     # --- Commission calc ---
@@ -444,7 +524,7 @@ if active_tab == "scenario":
                   help="Revenue generated per dollar spent on the rep")
 
         st.markdown("**Commission Curve**")
-        st.caption("How commission scales with attainment — the red dot is your current scenario.")
+        st.caption("How commission scales with attainment — the red dot is your current what-if.")
         rev_pts = [commission_quota * x / 100 for x in range(0, 201, 5)]
         if commission_mode == "Attainment-based rates":
             comm_pts = [calc_commission_attainment(r, commission_quota, att_tiers, retroactive_mode) for r in rev_pts]
@@ -473,15 +553,20 @@ if active_tab == "scenario":
                           height=350, margin=dict(l=0, r=0, t=30, b=0))
         st.plotly_chart(fig, use_container_width=True)
 
-    # --- Save scenario ---
+    # --- Save plan ---
     st.divider()
-    st.subheader("Save This Scenario")
-    st.caption("Save the current plan configuration and results so you can compare it with other scenarios later.")
-    scenario_data = {
+    st.subheader("Save This Plan")
+    st.caption("Save the plan configuration. Projections at each attainment level are generated automatically.")
+
+    # Build plan data (config only, no baked-in results)
+    plan_data = {
+        "version": 2,
         "author": author,
         "timestamp": datetime.datetime.now().isoformat(),
         "commission_mode": commission_mode,
         "retroactive": retroactive_mode,
+        "months_employed": months_employed,
+        "attainment_levels": attainment_levels,
         "params": {
             "base_salary": base_salary, "annual_quota": annual_quota,
             "draw_amount": draw_amount,
@@ -492,46 +577,30 @@ if active_tab == "scenario":
             "deal_rate_tiers": deal_rate_tiers if commission_mode != "Attainment-based rates" else None,
             "accel_tiers": accel_tiers if commission_mode != "Attainment-based rates" else None,
         },
-        "inputs": {
-            "months_employed": months_employed,
-            "actual_revenue": actual_revenue,
-        },
-        "results": {
-            "effective_quota": round(effective_quota, 2),
-            "attainment_pct": round(attainment_pct, 1),
-            "commission": round(commission, 2),
-            "draw_paid": round(draw_paid, 2),
-            "total_variable": round(total_variable, 2),
-            "total_comp": round(total_comp, 2),
-            "gross_profit": round(gross_profit, 2),
-            "total_cost_of_rep": round(total_cost_of_rep, 2),
-            "net_after_rep": round(net_after_rep, 2),
-            "roi_on_rep": round(roi_on_rep, 2),
-        },
     }
 
     st.warning(
-        "**Privacy:** Saved scenarios are stored in a shared Google Sheet. "
+        "**Privacy:** Saved plans are stored in a shared Google Sheet. "
         "Do NOT use real names, company names, or any identifying information "
-        "in scenario names or the 'Your name' field. Use generic labels "
+        "in plan names or the author field. Use generic labels "
         "(e.g. 'Plan A - aggressive', 'Option 2 - conservative').",
         icon="🔒",
     )
     scol1, scol2 = st.columns(2)
     with scol1:
-        scenario_name = st.text_input("Scenario name", key="save_name",
-                                       placeholder="e.g. 'plan-a-aggressive'")
-        if st.button("Save Scenario", type="primary"):
-            if scenario_name.strip():
+        plan_name = st.text_input("Plan name", key="save_name",
+                                   placeholder="e.g. 'plan-a-aggressive'")
+        if st.button("Save Plan", type="primary"):
+            if plan_name.strip():
                 try:
-                    save_scenario(scenario_name.strip(), scenario_data)
-                    st.success(f"Saved '{scenario_name.strip()}'")
-                    load_scenarios.clear()
+                    save_plan(plan_name.strip(), plan_data)
+                    st.success(f"Saved '{plan_name.strip()}'")
+                    load_plans.clear()
                     st.rerun()
                 except Exception as e:
                     st.error(f"Failed to save: {e}")
             else:
-                st.warning("Enter a scenario name")
+                st.warning("Enter a plan name")
 
 # ===================== TAB 2: Per-Deal Calculator =====================
 
@@ -570,37 +639,37 @@ if active_tab == "deals":
         st.dataframe(pd.DataFrame(deal_details), use_container_width=True, hide_index=True)
         st.metric("Total Commission from Deals", f"${total_deal_comm:,.0f}")
 
-# ===================== TAB 3: Compare Scenarios =====================
+# ===================== TAB 3: Compare Plans =====================
 
 if active_tab == "compare":
-    st.subheader("Compare Saved Scenarios")
-    st.caption("Select saved scenarios below to compare them side by side. "
-               "Use this to evaluate different plan structures — e.g. higher base vs. higher commission rate.")
+    st.subheader("Compare Plans")
+    st.caption("Each plan auto-generates projections at multiple attainment levels. "
+               "Compare different plan structures to see how they perform across scenarios.")
 
     if not sheet_ok:
-        st.warning("Configure your Google Sheet URL in secrets to enable scenario saving.")
+        st.warning("Configure your Google Sheet URL in secrets to enable plan saving.")
     else:
         if st.button("Refresh from Google Sheets"):
-            load_scenarios.clear()
+            load_plans.clear()
             st.rerun()
 
-        scenarios = load_scenarios()
+        plans = load_plans()
 
-        if scenarios:
+        if plans:
             col_a, col_b = st.columns(2)
             with col_b:
-                to_delete = st.selectbox("Delete a scenario", [""] + list(scenarios.keys()), key="del_sel")
+                to_delete = st.selectbox("Delete a plan", [""] + list(plans.keys()), key="del_sel")
                 if st.button("Delete"):
                     if to_delete:
                         try:
-                            delete_scenario(to_delete)
-                            load_scenarios.clear()
+                            delete_plan(to_delete)
+                            load_plans.clear()
                             st.success(f"Deleted '{to_delete}'")
                             st.rerun()
                         except Exception as e:
                             st.error(f"Failed to delete: {e}")
 
-            all_names = list(scenarios.keys())
+            all_names = list(plans.keys())
             tc1, tc2 = st.columns([3, 1])
             with tc2:
                 if st.button("Clear all"):
@@ -610,58 +679,104 @@ if active_tab == "compare":
                     st.session_state["compare_sel"] = all_names
                     st.rerun()
             with tc1:
-                selected = st.multiselect("Filter scenarios", all_names,
+                selected = st.multiselect("Filter plans", all_names,
                                            default=all_names, key="compare_sel")
+
             if selected:
+                # Build comparison table with projections at each attainment level
                 rows = []
                 for name in selected:
-                    s = scenarios[name]
-                    r = s.get("results", {})
-                    p = s.get("params", {})
-                    inp = s.get("inputs", {})
-                    rev = inp.get("actual_revenue", 0)
-                    rows.append({
-                        "Scenario": name,
-                        "Author": s.get("author", ""),
-                        "Mode": s.get("commission_mode", "") + (" (retro)" if s.get("retroactive") else ""),
+                    plan = plans[name]
+                    p = plan.get("params", {})
+                    months = plan.get("months_employed", 12)
+                    levels = plan.get("attainment_levels", [75, 100, 150, 200])
+                    retro = plan.get("retroactive", False)
+                    mode = plan.get("commission_mode", "Attainment-based rates")
+
+                    row = {
+                        "Plan": name,
+                        "Author": plan.get("author", ""),
+                        "Mode": mode + (" (retro)" if retro else ""),
                         "Base": f"${p.get('base_salary', 0):,.0f}",
                         "Quota": f"${p.get('annual_quota', 0):,.0f}",
-                        "Revenue": f"${rev:,.0f}",
-                        "Attainment": f"{r.get('attainment_pct', 0)}%",
-                        "Commission": f"${r.get('commission', 0):,.0f}",
-                        "Draw": f"${r.get('draw_paid', 0):,.0f}",
-                        "Total Comp": f"${r.get('total_comp', 0):,.0f}",
-                        "Gross Profit": f"${r.get('gross_profit', 0):,.0f}",
-                        "Net After Rep": f"${r.get('net_after_rep', 0):,.0f}",
-                        "Rep Cost % Rev": f"{r.get('total_cost_of_rep', 0) / rev * 100:.1f}%" if rev > 0 else "N/A",
-                        "ROI": f"{r.get('roi_on_rep', 0):.1f}x",
-                    })
+                    }
+
+                    for level in levels:
+                        proj = compute_projection(p, mode, retro, level, months)
+                        row[f"{level}% Comm"] = f"${proj['commission']:,.0f}"
+                        row[f"{level}% Total"] = f"${proj['total_comp']:,.0f}"
+                        row[f"{level}% Net"] = f"${proj['net_after_rep']:,.0f}"
+
+                    rows.append(row)
+
                 st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
 
+                # Chart: total comp at each attainment level per plan
+                st.markdown("**Total Compensation by Attainment**")
                 fig = go.Figure()
+                # Use the union of all attainment levels across selected plans
+                all_levels = sorted(set(
+                    lvl for name in selected
+                    for lvl in plans[name].get("attainment_levels", [75, 100, 150, 200])
+                ))
                 for name in selected:
-                    s = scenarios[name]
-                    r = s.get("results", {})
+                    plan = plans[name]
+                    p = plan.get("params", {})
+                    months = plan.get("months_employed", 12)
+                    retro = plan.get("retroactive", False)
+                    mode = plan.get("commission_mode", "Attainment-based rates")
+                    comps = []
+                    for level in all_levels:
+                        proj = compute_projection(p, mode, retro, level, months)
+                        comps.append(proj["total_comp"])
                     fig.add_trace(go.Bar(
                         name=name,
-                        x=["Commission", "Total Comp", "Gross Profit", "Net After Rep"],
-                        y=[r.get("commission", 0), r.get("total_comp", 0),
-                           r.get("gross_profit", 0), r.get("net_after_rep", 0)],
+                        x=[f"{l}%" for l in all_levels],
+                        y=comps,
                     ))
                 fig.update_layout(barmode="group", height=400,
+                                  xaxis_title="Attainment", yaxis_title="Total Comp ($)",
                                   margin=dict(l=0, r=0, t=30, b=0))
                 st.plotly_chart(fig, use_container_width=True)
 
-                # --- Scenario detail view ---
+                # Net after rep chart
+                st.markdown("**Net After Rep Cost by Attainment**")
+                fig2 = go.Figure()
+                for name in selected:
+                    plan = plans[name]
+                    p = plan.get("params", {})
+                    months = plan.get("months_employed", 12)
+                    retro = plan.get("retroactive", False)
+                    mode = plan.get("commission_mode", "Attainment-based rates")
+                    nets = []
+                    for level in all_levels:
+                        proj = compute_projection(p, mode, retro, level, months)
+                        nets.append(proj["net_after_rep"])
+                    fig2.add_trace(go.Bar(
+                        name=name,
+                        x=[f"{l}%" for l in all_levels],
+                        y=nets,
+                    ))
+                fig2.update_layout(barmode="group", height=400,
+                                   xaxis_title="Attainment", yaxis_title="Net After Rep ($)",
+                                   margin=dict(l=0, r=0, t=30, b=0))
+                st.plotly_chart(fig2, use_container_width=True)
+
+                # --- Plan detail view ---
                 st.divider()
-                st.markdown("**Scenario Details**")
-                st.caption("Select a scenario to view agreement-ready compensation terms.")
+                st.markdown("**Plan Details**")
+                st.caption("Select a plan to view agreement-ready compensation terms.")
                 detail_name = st.selectbox("View details for", [""] + selected, key="detail_sel")
-                if detail_name and detail_name in scenarios:
-                    s = scenarios[detail_name]
+                if detail_name and detail_name in plans:
+                    s = plans[detail_name]
                     p = s.get("params", {})
-                    inp = s.get("inputs", {})
-                    r = s.get("results", {})
+                    months = s.get("months_employed", 12)
+                    retro = s.get("retroactive", False)
+                    mode = s.get("commission_mode", "Attainment-based rates")
+                    levels = s.get("attainment_levels", [75, 100, 150, 200])
+
+                    # Compute 100% projection for OTE reference
+                    proj_100 = compute_projection(p, mode, retro, 100, months)
 
                     # Build agreement text
                     lines = []
@@ -675,7 +790,7 @@ if active_tab == "compare":
                     lines.append("")
 
                     # Header summary
-                    lines.append(f"  ${p.get('base_salary', 0):,.0f}".ljust(22) + f"~${r.get('total_comp', 0):,.0f}".ljust(22))
+                    lines.append(f"  ${p.get('base_salary', 0):,.0f}".ljust(22) + f"~${proj_100['total_comp']:,.0f}".ljust(22))
                     lines.append("  Base Salary".ljust(22) + "OTE".ljust(22))
                     draw_amt = p.get("draw_amount", 0)
                     if draw_amt > 0 or equity:
@@ -714,7 +829,7 @@ if active_tab == "compare":
                         lines.append("")
 
                     lines.append("  On-Target Earnings (OTE)")
-                    lines.append(f"    • ${p.get('base_salary', 0):,.0f} base + ~${r.get('commission', 0):,.0f} variable = ~${r.get('total_comp', 0):,.0f} OTE")
+                    lines.append(f"    • ${p.get('base_salary', 0):,.0f} base + ~${proj_100['commission']:,.0f} variable = ~${proj_100['total_comp']:,.0f} OTE")
                     lines.append(f"    • Uncapped — no ceiling on commissions")
                     lines.append("")
 
@@ -742,7 +857,7 @@ if active_tab == "compare":
                         lines.append("  issued. Paid on the first payroll cycle of the following month.")
                         lines.append("  Churn within 90 days triggers a proportional clawback.")
                     elif comm_tiers:
-                        is_retro = s.get("retroactive", False)
+                        is_retro = retro
                         if is_retro:
                             lines.append("  Commission rates are applied retroactively. Once a higher attainment")
                             lines.append("  threshold is crossed, that rate applies to ALL revenue from dollar one.")
@@ -753,33 +868,34 @@ if active_tab == "compare":
                         lines.append(f"  {'Attainment Level':<24} {'Commission Rate':<18}")
                         lines.append(f"  {'-' * 22:<24} {'-' * 16:<18}")
                         for i, tier in enumerate(comm_tiers):
-                            upper, rate = tier[0], tier[1]
-                            if upper is None:
+                            upper_val, rate_val = tier[0], tier[1]
+                            if upper_val is None:
                                 prev_upper = int(comm_tiers[i-1][0])
-                                lines.append(f"  {prev_upper}%+{'':<19} {rate:.1f}%")
+                                lines.append(f"  {prev_upper}%+{'':<19} {rate_val:.1f}%")
                             elif i == 0:
-                                lines.append(f"  0% – {int(upper)}%{'':<14} {rate:.1f}%")
+                                lines.append(f"  0% – {int(upper_val)}%{'':<14} {rate_val:.1f}%")
                             else:
                                 prev_upper = int(comm_tiers[i-1][0])
-                                lines.append(f"  {prev_upper}% – {int(upper)}%{'':<12} {rate:.1f}%")
+                                lines.append(f"  {prev_upper}% – {int(upper_val)}%{'':<12} {rate_val:.1f}%")
                     elif deal_tiers_data:
                         lines.append("  Commission is calculated as a percentage of deal ACV based on deal size.")
                         lines.append("")
                         lines.append(f"  {'Deal ACV Range':<28} {'Commission Rate':<18}")
                         lines.append(f"  {'-' * 26:<28} {'-' * 16:<18}")
                         for tier in deal_tiers_data:
-                            mn, mx, rt = tier[0], tier[1], tier[2]
-                            if mx is None:
-                                lines.append(f"  ${mn:,.0f}+{'':<19} {rt:.1f}%")
+                            mn_v, mx_v, rt_v = tier[0], tier[1], tier[2]
+                            if mx_v is None:
+                                lines.append(f"  ${mn_v:,.0f}+{'':<19} {rt_v:.1f}%")
                             else:
-                                lines.append(f"  ${mn:,.0f} – ${mx:,.0f}{'':<8} {rt:.1f}%")
+                                lines.append(f"  ${mn_v:,.0f} – ${mx_v:,.0f}{'':<8} {rt_v:.1f}%")
 
                     lines.append("")
 
-                    # 3. Annual Quota & Deal Targets
+                    # Deal Targets (if present in legacy data)
                     deal_targets = p.get("deal_targets")
+                    section_num = 3
                     if deal_targets:
-                        lines.append("3. ANNUAL QUOTA & DEAL TARGETS")
+                        lines.append(f"{section_num}. ANNUAL QUOTA & DEAL TARGETS")
                         lines.append("")
                         lines.append(f"  On-target quota is ${p.get('annual_quota', 0):,.0f} ACV.")
                         lines.append("")
@@ -787,19 +903,17 @@ if active_tab == "compare":
                         lines.append(f"  {'-'*13:<14} {'-'*8:<10} {'-'*12:<14} {'-'*12:<14} {'-'*6:<8} {'-'*12}")
                         total_deals = 0
                         total_acv = 0
-                        total_comm = 0
+                        total_comm_dt = 0
                         for dt in deal_targets:
                             t_acv = dt['num_deals'] * dt['avg_acv']
                             t_comm = t_acv * dt['rate'] / 100
                             total_deals += dt['num_deals']
                             total_acv += t_acv
-                            total_comm += t_comm
+                            total_comm_dt += t_comm
                             lines.append(f"  {dt['segment']:<14} {dt['num_deals']:<10} ${dt['avg_acv']:,.0f}{'':<6} ${t_acv:,.0f}{'':<6} {dt['rate']:.0f}%{'':<5} ${t_comm:,.0f}")
-                        lines.append(f"  {'Total':<14} {total_deals:<10} {'—':<14} ${total_acv:,.0f}{'':<6} {'—':<8} ~${total_comm:,.0f}")
+                        lines.append(f"  {'Total':<14} {total_deals:<10} {'—':<14} ${total_acv:,.0f}{'':<6} {'—':<8} ~${total_comm_dt:,.0f}")
                         lines.append("")
-                        section_num = 4
-                    else:
-                        section_num = 3
+                        section_num += 1
 
                     # Ramp
                     ramp_list = p.get("ramp_pcts", [])
@@ -813,59 +927,50 @@ if active_tab == "compare":
                         monthly_quota = p.get('annual_quota', 0) / 12
                         lines.append(f"  {'Month':<10} {'Quota %':<12} {'Monthly Target':<18} {'Ann. Run Rate':<16} {'Notes'}")
                         lines.append(f"  {'-'*8:<10} {'-'*10:<12} {'-'*16:<18} {'-'*14:<16} {'-'*20}")
-                        # Group consecutive months with same pct
                         ramp_groups = []
-                        i = 0
-                        while i < len(ramp_list):
-                            pct = ramp_list[i]
-                            start = i + 1
-                            while i + 1 < len(ramp_list) and ramp_list[i + 1] == pct:
-                                i += 1
-                            end = i + 1
-                            ramp_groups.append((start, end, pct))
-                            i += 1
+                        idx = 0
+                        while idx < len(ramp_list):
+                            pct_val = ramp_list[idx]
+                            start = idx + 1
+                            while idx + 1 < len(ramp_list) and ramp_list[idx + 1] == pct_val:
+                                idx += 1
+                            end = idx + 1
+                            ramp_groups.append((start, end, pct_val))
+                            idx += 1
                         ramp_notes = {0: "Onboarding, no quota", 25: "First demos, early pipeline",
                                       50: "Close first deals", 75: "Full funnel operating", 100: "Full quota in effect"}
-                        for start, end, pct in ramp_groups:
+                        for start, end, pct_val in ramp_groups:
                             month_label = f"{start}–{end}" if start != end else str(start)
-                            target = monthly_quota * pct / 100
+                            target = monthly_quota * pct_val / 100
                             run_rate = target * 12
-                            note = ramp_notes.get(int(pct), "")
-                            if draw_amt > 0:
-                                monthly_draw_val = draw_amt / max(p.get('draw_months', 1), 1)
-                                lines.append(f"  {month_label:<10} {int(pct)}%{'':<9} ${target:,.0f}{'':<8} ${run_rate:,.0f}{'':<6} {note}")
-                            else:
-                                lines.append(f"  {month_label:<10} {int(pct)}%{'':<9} ${target:,.0f}{'':<8} ${run_rate:,.0f}{'':<6} {note}")
-                        # Full quota months
+                            note = ramp_notes.get(int(pct_val), "")
+                            lines.append(f"  {month_label:<10} {int(pct_val)}%{'':<9} ${target:,.0f}{'':<8} ${run_rate:,.0f}{'':<6} {note}")
                         if len(ramp_list) < 12:
                             month_label = f"{len(ramp_list)+1}–12"
                             lines.append(f"  {month_label:<10} 100%{'':<8} ${monthly_quota:,.0f}{'':<8} ${monthly_quota*12:,.0f}{'':<6} Full quota in effect")
                         lines.append("")
                         section_num += 1
 
-                    # Accelerators
+                    # Accelerators (for deal-size mode)
                     if accel_t:
                         lines.append(f"{section_num}. ACCELERATORS & OVERACHIEVEMENT")
                         lines.append("")
                         lines.append(f"  {'Attainment':<18} {'Rate / Multiplier':<22} {'Notes'}")
                         lines.append(f"  {'-'*16:<18} {'-'*20:<22} {'-'*20}")
                         for i, tier in enumerate(accel_t):
-                            upper, mult = tier[0], tier[1]
-                            if upper is None:
+                            upper_val, mult_val = tier[0], tier[1]
+                            if upper_val is None:
                                 prev_upper = int(accel_t[i-1][0])
-                                lines.append(f"  {prev_upper}%+{'':<14} {mult:.1f}x multiplier")
+                                lines.append(f"  {prev_upper}%+{'':<14} {mult_val:.1f}x multiplier")
                             elif i == 0:
-                                lines.append(f"  0% – {int(upper)}%{'':<9} {mult:.1f}x (base rate)")
+                                lines.append(f"  0% – {int(upper_val)}%{'':<9} {mult_val:.1f}x (base rate)")
                             else:
                                 prev_upper = int(accel_t[i-1][0])
-                                lines.append(f"  {prev_upper}% – {int(upper)}%{'':<7} {mult:.1f}x multiplier")
+                                lines.append(f"  {prev_upper}% – {int(upper_val)}%{'':<7} {mult_val:.1f}x multiplier")
                         lines.append("")
                         section_num += 1
-                    elif comm_tiers:
-                        # Attainment-based tiers already shown above, no separate accelerator section needed
-                        pass
 
-                    # Illustrative earnings
+                    # Illustrative earnings — auto-generated from projections
                     lines.append(f"{section_num}. ILLUSTRATIVE EARNINGS SCENARIOS")
                     lines.append("")
                     if illustrative:
@@ -874,13 +979,11 @@ if active_tab == "compare":
                         for sc in illustrative:
                             lines.append(f"  {sc['label']:<22} {sc.get('deal_mix', '—'):<20} ${sc['acv']:,.0f}{'':<4} ${sc['commission']:,.0f}{'':<4} ${sc['total_cash']:,.0f}{'':<4} {sc.get('notes', '')}")
                     else:
-                        lines.append(f"  At {r.get('attainment_pct', 0):.0f}% quota attainment (${inp.get('actual_revenue', 0):,.0f} revenue):")
-                        lines.append("")
-                        lines.append(f"  Base Salary:        ${p.get('base_salary', 0):,.0f}")
-                        if draw_amt > 0:
-                            lines.append(f"  Draw:               ${r.get('draw_paid', 0):,.0f}")
-                        lines.append(f"  Commission:         ${r.get('commission', 0):,.0f}")
-                        lines.append(f"  Total Compensation: ${r.get('total_comp', 0):,.0f}")
+                        lines.append(f"  {'Attainment':<16} {'Revenue':<16} {'Commission':<16} {'Total Comp':<16} {'Net After Rep'}")
+                        lines.append(f"  {'-'*14:<16} {'-'*14:<16} {'-'*14:<16} {'-'*14:<16} {'-'*14}")
+                        for level in levels:
+                            proj = compute_projection(p, mode, retro, level, months)
+                            lines.append(f"  {level}%{'':<12} ${proj['actual_revenue']:,.0f}{'':<4} ${proj['commission']:,.0f}{'':<6} ${proj['total_comp']:,.0f}{'':<6} ${proj['net_after_rep']:,.0f}")
                     lines.append("")
                     section_num += 1
 
@@ -920,7 +1023,6 @@ if active_tab == "compare":
 
                     st.code(agreement_text, language=None)
 
-                    # Copy button
                     st.download_button(
                         label="Download as text file",
                         data=agreement_text,
@@ -928,4 +1030,4 @@ if active_tab == "compare":
                         mime="text/plain",
                     )
         else:
-            st.info("No saved scenarios yet. Save one from the Scenario Calculator tab.")
+            st.info("No saved plans yet. Save one from the Plan Builder tab.")