Add GMNL variants, IP tracking, BWS fix, session activity, UI polish

- GMNL special forms dropdown: S-MNL (gamma=0), GMNL-II (gamma=1)
- Admin IP tracking with country/region geolocation and VPN detection
- BWS early validation (J>=3) and clean error display (no traceback)
- Session timeout: JS activity monitor (scroll/mouse/keyboard) keeps heartbeat alive
- Auth: replace real name example with fictional "Jordan McAllister"
- Home: remove duplicate WeChat donation pill (keep expander)
- Admin page moved to top-right "⋯" Developer Entry menu (admin only)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/Home.py

@@ -174,18 +174,10 @@ with _bro_col2:
     )
 
     st.markdown(
-        "<div style='display:flex; gap:12px;'>"
-        # ── Buy Me a Coffee ──
         f"<a href='{_coffee_url}' target='_blank' style='"
-        f"{_btn_style} flex:1; background:#FFDD00; color:#000;'>"
+        f"{_btn_style} max-width:300px; background:#FFDD00; color:#000;'>"
         f"<img src='{_bmc_logo}' width='22' style='flex-shrink:0;'/>"
-        f"Buy Slowbro a Coffee</a>"
-        # ── WeChat ──
-        f"<div style='{_btn_style} flex:1; background:#07C160; color:#fff;' "
-        f"id='wechat-tip-btn'>"
-        f"<img src='{_wechat_logo}' width='22' style='flex-shrink:0;'/>"
-        f"微信打赏</div>"
-        "</div>",
+        f"Buy Slowbro a Coffee</a>",
         unsafe_allow_html=True,
     )
 

app/auth.py

@@ -7,7 +7,7 @@ Supports two methods:
 MUCHE team members are stored as a whitelist.
 First login: match name + set password to claim account.
 Subsequent logins: match name + enter password.
-Fuzzy matching allows minor name variations (e.g. "Nora" matches "Noura").
+Fuzzy matching allows minor name variations (e.g. "John" matches "Jonathan").
 
 Toggle with PREFERO_AUTH_ENABLED env var ("true" to enable).
 """
@@ -213,7 +213,7 @@ def auth_gate() -> bool:
         name_input = st.text_input(
             "Your name",
             key="_auth_member_name",
-            placeholder="e.g. Noura Saba",
+            placeholder="e.g. Jordan McAllister",
         )
 
         matched_name = None

app/community_db.py

@@ -17,10 +17,82 @@ import sqlite3
 import threading
 import time
 from dataclasses import dataclass
+from functools import lru_cache
 from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+
+# ---------------------------------------------------------------------------
+# IP geolocation helpers
+# ---------------------------------------------------------------------------
+
+# In-memory cache: ip -> {country, region, city, org, is_vpn}
+_geo_cache: dict[str, dict] = {}
+_GEO_CACHE_MAX = 500
+
+
+def get_client_ip() -> str | None:
+    """Extract client IP from Streamlit request headers (X-Forwarded-For)."""
+    try:
+        import streamlit as st
+        xff = st.context.headers.get("x-forwarded-for")
+        if xff and isinstance(xff, str):
+            return xff.split(",")[0].strip()
+        return None
+    except Exception:
+        return None
+
+
+def geolocate_ip(ip: str | None) -> dict:
+    """Look up country, region, org for an IP via ipapi.co (free, 30k/month).
+
+    Returns dict with keys: country, region, city, org, is_vpn.
+    Results are cached in-memory.
+    """
+    if not ip:
+        return {}
+    if ip in _geo_cache:
+        return _geo_cache[ip]
+
+    result: dict = {}
+    try:
+        import requests
+        resp = requests.get(
+            f"https://ipapi.co/{ip}/json/",
+            timeout=3,
+            headers={"User-Agent": "Prefero/1.0"},
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            if not data.get("error"):
+                org = data.get("org", "")
+                # Heuristic VPN/datacenter detection: check org name
+                _vpn_keywords = [
+                    "vpn", "proxy", "tunnel", "hosting", "datacenter",
+                    "data center", "cloud", "server", "digitalocean",
+                    "amazon", "aws", "google cloud", "microsoft azure",
+                    "linode", "vultr", "ovh", "hetzner", "mullvad",
+                    "nordvpn", "expressvpn", "surfshark", "proton",
+                ]
+                is_vpn = any(kw in org.lower() for kw in _vpn_keywords)
+                result = {
+                    "country": data.get("country_name", ""),
+                    "country_code": data.get("country_code", ""),
+                    "region": data.get("region", ""),
+                    "city": data.get("city", ""),
+                    "org": org,
+                    "is_vpn": is_vpn,
+                }
+    except Exception as exc:
+        logger.debug("Geo lookup failed for %s: %s", ip, exc)
+
+    # Cache result (even empty, to avoid repeated failed lookups)
+    if len(_geo_cache) < _GEO_CACHE_MAX:
+        _geo_cache[ip] = result
+    return result
+
+
 # ---------------------------------------------------------------------------
 # HF Dataset persistence for user accounts
 # ---------------------------------------------------------------------------
@@ -200,6 +272,24 @@ def init_db() -> None:
         CREATE INDEX IF NOT EXISTS idx_activity_time  ON activity_log(timestamp DESC);
     """)
     conn.commit()
+    # Schema migration: add IP/geo columns to activity_log if missing
+    try:
+        conn.execute("ALTER TABLE activity_log ADD COLUMN ip_address TEXT DEFAULT ''")
+    except sqlite3.OperationalError:
+        pass  # column already exists
+    try:
+        conn.execute("ALTER TABLE activity_log ADD COLUMN country TEXT DEFAULT ''")
+    except sqlite3.OperationalError:
+        pass
+    try:
+        conn.execute("ALTER TABLE activity_log ADD COLUMN region TEXT DEFAULT ''")
+    except sqlite3.OperationalError:
+        pass
+    try:
+        conn.execute("ALTER TABLE activity_log ADD COLUMN is_vpn INTEGER DEFAULT 0")
+    except sqlite3.OperationalError:
+        pass
+    conn.commit()
     # Load persisted users from HF on first startup
     _sync_users_from_hf()
 
@@ -277,13 +367,22 @@ def create_user(username: str, email: str = "") -> User:
 
 
 def log_activity(username: str, action: str, details: str = "") -> None:
-    """Record an activity event."""
+    """Record an activity event with IP geolocation."""
     try:
         conn = _get_conn()
+        ip = get_client_ip()
+        geo = geolocate_ip(ip) if ip else {}
         conn.execute(
-            "INSERT INTO activity_log (timestamp, username, action, details) "
-            "VALUES (?, ?, ?, ?)",
-            (time.time(), username, action, details),
+            "INSERT INTO activity_log "
+            "(timestamp, username, action, details, ip_address, country, region, is_vpn) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                time.time(), username, action, details,
+                ip or "",
+                geo.get("country", ""),
+                geo.get("region", ""),
+                1 if geo.get("is_vpn") else 0,
+            ),
         )
         conn.commit()
     except Exception as exc:

app/pages/2_⚙️_Model.py

@@ -333,6 +333,25 @@ elif model_type == "gmnl":
         "Nests both S-MNL (pure scale) and MMNL as special cases."
     )
 
+    gmnl_variant_label = st.selectbox(
+        "GMNL variant",
+        ["GMNL (General)", "S-MNL (gamma=0)", "GMNL-II (gamma=1)"],
+        key="gmnl_variant_select",
+        help=(
+            "**GMNL (General):** gamma is freely estimated (Fiebig et al. 2010). "
+            "**S-MNL:** gamma fixed at 0 — pure scale heterogeneity only; "
+            "all taste variation comes from individual scale differences. "
+            "**GMNL-II:** gamma fixed at 1 — scale multiplies the full "
+            "individual-specific beta (mean + deviation)."
+        ),
+    )
+    _gmnl_variant_map = {
+        "GMNL (General)": "general",
+        "S-MNL (gamma=0)": "s-mnl",
+        "GMNL-II (gamma=1)": "gmnl-ii",
+    }
+    gmnl_variant = _gmnl_variant_map[gmnl_variant_label]
+
     st.markdown("**Distribution assumptions**")
     st.caption("Set distributions for each variable. At least one random variable is required.")
     with st.expander("What do the distribution options mean?"):
@@ -369,11 +388,13 @@ elif model_type == "gmnl":
 
     with st.expander("About GMNL scale parameters"):
         st.markdown(
-            "The GMNL model estimates three additional parameters:\n"
+            "The GMNL model estimates additional scale parameters:\n"
             "- **tau** (scale mean): controls the average scale of utility.\n"
             "- **sigma_tau** (scale SD): individual variation in scale.\n"
             "- **gamma** (mixing, 0-1): gamma=0 is pure scale heterogeneity (S-MNL), "
-            "gamma=1 is GMNL-II (closest to standard MMNL)."
+            "gamma=1 is GMNL-II (closest to standard MMNL).\n\n"
+            "When using **S-MNL** or **GMNL-II**, gamma is fixed and not estimated — "
+            "reducing the parameter count by 1."
         )
 
     # ── Correlation structure for GMNL ────────────────────────────────
@@ -577,6 +598,8 @@ else:  # latent_class
 if model_type not in ("mixed", "gmnl"):
     mxl_correlated = False
     mxl_correlation_groups = None
+if model_type != "gmnl":
+    gmnl_variant = "general"
 if model_type != "latent_class":
     lc_membership_cols = []
     lc_method = "em"
@@ -939,6 +962,9 @@ def _suggest_model_name() -> str:
     """Build a descriptive default name from the current model configuration."""
     prefix_map = {"conditional": "CL", "mixed": "MXL", "gmnl": "GMNL", "latent_class": "LC"}
     prefix = prefix_map[model_type]
+    if model_type == "gmnl" and gmnl_variant != "general":
+        variant_labels = {"s-mnl": "S-MNL", "gmnl-ii": "GMNL-II"}
+        prefix = variant_labels.get(gmnl_variant, prefix)
     parts: list[str] = [prefix]
 
     if model_type in ("mixed", "gmnl"):
@@ -1071,9 +1097,10 @@ def _build_param_names() -> list[dict[str, str]]:
             rows.append({"#": str(idx), "Parameter": "raw_sigma_tau",
                          "Description": "Scale SD (raw, softplus-transformed)"})
             idx += 1
-            rows.append({"#": str(idx), "Parameter": "raw_gamma",
-                         "Description": "Mixing parameter (raw, sigmoid -> [0,1])"})
-            idx += 1
+            if gmnl_variant == "general":
+                rows.append({"#": str(idx), "Parameter": "raw_gamma",
+                             "Description": "Mixing parameter (raw, sigmoid -> [0,1])"})
+                idx += 1
 
     elif model_type == "latent_class":
         for q in range(1, n_classes + 1):
@@ -1188,6 +1215,7 @@ if st.button("Run Estimation", type="primary", use_container_width=True):
         interactions=_het_interactions,
         correlated=mxl_correlated,
         correlation_groups=mxl_correlation_groups,
+        gmnl_variant=gmnl_variant,
         bws_worst_col=bws_worst_col if bws_mode else None,
         estimate_lambda_w=bws_estimate_lambda_w if bws_mode else True,
         n_classes=int(n_classes),
@@ -1200,6 +1228,16 @@ if st.button("Run Estimation", type="primary", use_container_width=True):
         custom_start=_parsed_custom_start,
     )
 
+    # ── Early validation: BWS requires J >= 3 ──────────────────
+    if bws_mode:
+        _n_alts_per_task = df.groupby([id_col, task_col]).size()
+        if _n_alts_per_task.min() < 3:
+            st.error(
+                "BWS requires at least 3 alternatives per task (J >= 3). "
+                f"Your data has tasks with only {_n_alts_per_task.min()} alternatives."
+            )
+            st.stop()
+
     # Pass the original DataFrame; backend handles dummy expansion
     est_df = df
 
@@ -1273,10 +1311,14 @@ if st.button("Run Estimation", type="primary", use_container_width=True):
         st.error(f"Estimation failed: {exc}")
         try:
             from community_db import log_activity
+            import traceback as _tb
+            _tb_str = _tb.format_exc()
             log_activity(st.session_state.get("username", "anonymous"), "estimation_error", f"model={model_type}, error={str(exc)[:200]}")
+            logger_msg = f"Estimation error: {_tb_str}"
+            import logging
+            logging.getLogger("prefero").warning(logger_msg)
         except Exception:
             pass
-        st.exception(exc)
         st.stop()
 
     st.session_state["_estimation_running"] = False

app/pages/8_🔒_Admin.py

@@ -223,12 +223,22 @@ try:
         log_data = []
         for r in log_rows:
             ts = datetime.fromtimestamp(r["timestamp"], tz=timezone.utc)
-            log_data.append({
+            row = {
                 "Timestamp": ts.strftime("%Y-%m-%d %H:%M:%S UTC"),
                 "Username": r["username"],
                 "Action": r["action"],
                 "Details": r["details"],
-            })
+            }
+            # IP/geo columns (may not exist in older records)
+            ip_val = r["ip_address"] if "ip_address" in r.keys() else ""
+            country_val = r["country"] if "country" in r.keys() else ""
+            region_val = r["region"] if "region" in r.keys() else ""
+            vpn_val = r["is_vpn"] if "is_vpn" in r.keys() else 0
+            row["IP"] = ip_val or ""
+            row["Country"] = country_val or ""
+            row["Region"] = region_val or ""
+            row["VPN"] = "Yes" if vpn_val else ""
+            log_data.append(row)
         log_df = pd.DataFrame(log_data)
         st.dataframe(log_df, use_container_width=True, hide_index=True)
 
@@ -244,6 +254,44 @@ try:
 except Exception as _exc:
     st.info(f"Activity timeline not available: {_exc}")
 
+# ── 2a-2. Geographic Overview ──────────────────────────────────
+
+st.header("Geographic Overview")
+
+try:
+    geo_rows = conn.execute(
+        "SELECT country, region, ip_address, is_vpn, COUNT(*) as cnt "
+        "FROM activity_log WHERE country != '' GROUP BY country ORDER BY cnt DESC"
+    ).fetchall()
+    if geo_rows:
+        geo_data = [
+            {"Country": r["country"], "Activities": r["cnt"]}
+            for r in geo_rows
+        ]
+        geo_df = pd.DataFrame(geo_data)
+        g1, g2 = st.columns(2)
+        with g1:
+            st.dataframe(geo_df, use_container_width=True, hide_index=True)
+        with g2:
+            if _has_plotly:
+                fig_geo = px.pie(geo_df, names="Country", values="Activities", title="Activities by Country")
+                st.plotly_chart(fig_geo, use_container_width=True, key="admin_geo_pie")
+
+    vpn_total = conn.execute(
+        "SELECT SUM(is_vpn) as vpn_cnt, COUNT(*) as total "
+        "FROM activity_log WHERE ip_address != ''"
+    ).fetchone()
+    if vpn_total and vpn_total["total"] > 0:
+        vpn_count = int(vpn_total["vpn_cnt"] or 0)
+        total_with_ip = int(vpn_total["total"])
+        v1, v2 = st.columns(2)
+        v1.metric("Tracked requests (with IP)", total_with_ip)
+        v2.metric("Suspected VPN/Datacenter", f"{vpn_count} ({vpn_count/total_with_ip*100:.1f}%)" if total_with_ip else "0")
+    else:
+        st.info("No geographic data yet. IP tracking starts collecting data on the next user activity.")
+except Exception as _exc:
+    st.info(f"Geographic data not available: {_exc}")
+
 # ── 2b. Model Usage Stats ───────────────────────────────────────
 
 st.header("Model Usage Stats")

app/utils.py

@@ -87,6 +87,47 @@ def _check_session_timeout() -> None:
         st.stop()
 
 
+def _inject_activity_heartbeat() -> None:
+    """Inject JavaScript that detects user activity and auto-refreshes to keep the session alive.
+
+    Monitors scroll, mouse movement, keyboard, and touch events on the parent
+    document.  If activity is detected within the last 90 seconds, triggers a
+    lightweight page reload every 90 seconds.  Streamlit session state persists
+    across reloads, so the heartbeat() call in init_session_state() naturally
+    refreshes the server-side timestamp.
+    """
+    import os
+    if os.environ.get("PREFERO_QUEUE_ENABLED", "").lower() != "true":
+        return  # no queue → no need for activity tracking
+
+    import streamlit.components.v1 as _components
+    _components.html(
+        """
+        <script>
+        (function() {
+            var INTERVAL = 90000;  // 90 seconds
+            var lastActivity = Date.now();
+            var events = ['scroll', 'mousemove', 'keydown', 'touchstart', 'click', 'wheel'];
+            var doc;
+            try { doc = window.parent.document; } catch(e) { return; }
+
+            events.forEach(function(e) {
+                doc.addEventListener(e, function() { lastActivity = Date.now(); }, {passive: true});
+            });
+
+            setInterval(function() {
+                if (Date.now() - lastActivity < INTERVAL) {
+                    // User was active — trigger Streamlit rerun to refresh heartbeat
+                    try { window.parent.location.reload(); } catch(e) {}
+                }
+            }, INTERVAL);
+        })();
+        </script>
+        """,
+        height=0,
+    )
+
+
 def init_session_state() -> None:
     """Ensure every shared session-state key exists with its default value."""
     for key, default in _SESSION_DEFAULTS.items():
@@ -99,6 +140,7 @@ def init_session_state() -> None:
     require_queue_slot()
     queue_heartbeat()
     st.session_state["_queue_admitted"] = True
+    _inject_activity_heartbeat()
     import inspect
     _caller = inspect.stack()[1].filename
     _page = Path(_caller).stem
@@ -118,12 +160,96 @@ def data_is_loaded() -> bool:
     return st.session_state.get("df") is not None
 
 
+def _is_admin_user() -> bool:
+    """Check if the current user has admin privileges."""
+    import os
+    admin_csv = os.environ.get("PREFERO_ADMIN_USERS", "")
+    if not admin_csv.strip():
+        return False
+    admin_users = {u.strip().lower() for u in admin_csv.split(",") if u.strip()}
+    current = st.session_state.get("username", "").strip().lower()
+    return current in admin_users
+
+
 def slowbro_status() -> None:
     """Inject global Slowbro status widget into Streamlit's fixed header."""
     _slowbro_img = (
         "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites"
         "/pokemon/other/official-artwork/80.png"
     )
+
+    # Build optional developer entry menu (admin only)
+    _dev_menu_css = ""
+    _dev_menu_html = ""
+    if _is_admin_user():
+        _dev_menu_css = """
+        /* Hide Admin page from sidebar nav */
+        [data-testid="stSidebarNav"] a[href*="Admin"] {
+            display: none !important;
+        }
+        /* Developer entry ⋯ menu */
+        .dev-entry {
+            position: fixed;
+            top: 10px;
+            right: 14px;
+            z-index: 1001;
+        }
+        .dev-entry-btn {
+            background: rgba(50,50,50,0.7);
+            border: none;
+            color: #999;
+            font-size: 16px;
+            cursor: pointer;
+            border-radius: 6px;
+            width: 30px;
+            height: 30px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: background 0.15s;
+        }
+        .dev-entry-btn:hover {
+            background: rgba(80,80,80,0.9);
+            color: #ddd;
+        }
+        .dev-entry-dropdown {
+            display: none;
+            position: absolute;
+            right: 0;
+            top: 34px;
+            background: #1e1e1e;
+            border: 1px solid #333;
+            border-radius: 8px;
+            padding: 4px 0;
+            min-width: 170px;
+            box-shadow: 0 4px 16px rgba(0,0,0,0.4);
+        }
+        .dev-entry:hover .dev-entry-dropdown {
+            display: block;
+        }
+        .dev-entry-dropdown a {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 8px 14px;
+            color: #ccc;
+            text-decoration: none;
+            font-size: 0.82rem;
+        }
+        .dev-entry-dropdown a:hover {
+            background: rgba(255,255,255,0.08);
+            color: #fff;
+        }
+        """
+        _dev_menu_html = """
+        <div class="dev-entry">
+            <div class="dev-entry-btn">⋯</div>
+            <div class="dev-entry-dropdown">
+                <a href="/🔒_Admin" target="_self">🔧 Developer Entry</a>
+            </div>
+        </div>
+        """
+
     st.markdown(
         f"""
         <style>
@@ -150,7 +276,9 @@ def slowbro_status() -> None:
             white-space: nowrap;
             z-index: 999;
         }}
+        {_dev_menu_css}
         </style>
+        {_dev_menu_html}
         """,
         unsafe_allow_html=True,
     )

src/dce_analyzer/config.py

@@ -130,6 +130,9 @@ class FullModelSpec:
     bws_worst_col: str | None = None
     estimate_lambda_w: bool = True
 
+    # GMNL variant: "general" (gamma free), "s-mnl" (gamma=0), "gmnl-ii" (gamma=1)
+    gmnl_variant: str = "general"
+
     # Latent class
     n_classes: int = 2
     membership_cols: list[str] | None = None

src/dce_analyzer/model.py

@@ -716,6 +716,7 @@ class GmnlEstimator(MixedLogitEstimator):
         bws_data: BwsData | None = None,
         correlated: bool = False,
         correlation_groups: list[list[int]] | None = None,
+        fixed_gamma: float | None = None,
     ) -> None:
         super().__init__(
             tensors=tensors,
@@ -727,6 +728,8 @@ class GmnlEstimator(MixedLogitEstimator):
             correlation_groups=correlation_groups,
             bws_data=bws_data,
         )
+        self._fixed_gamma = fixed_gamma  # None = free, 0.0 = S-MNL, 1.0 = GMNL-II
+
         # Extra Halton draws for scale heterogeneity (one dim per individual per draw)
         scale_draws_np = generate_halton_draws(
             n_individuals=self.n_individuals,
@@ -738,11 +741,17 @@ class GmnlEstimator(MixedLogitEstimator):
             scale_draws_np[:, :, 0], dtype=torch.float32, device=self.device
         )  # (n_individuals, n_draws)
 
-        # Indices for the three extra GMNL parameters appended after MMNL params
+        # Indices for the extra GMNL parameters appended after MMNL params
         self._tau_idx = self.n_params          # tau (scale mean)
         self._sigma_tau_idx = self.n_params + 1  # raw sigma_tau (scale SD, softplus)
-        self._gamma_idx = self.n_params + 2      # raw gamma (sigmoid -> [0,1])
-        self.n_params += 3
+        if self._fixed_gamma is None:
+            # gamma is a free parameter
+            self._gamma_idx = self.n_params + 2      # raw gamma (sigmoid -> [0,1])
+            self.n_params += 3
+        else:
+            # gamma is fixed — not a free parameter
+            self._gamma_idx = None
+            self.n_params += 2
 
     def _initial_theta(self) -> np.ndarray:
         # Delegate to parent for MMNL params (handles both independent & correlated)
@@ -750,10 +759,12 @@ class GmnlEstimator(MixedLogitEstimator):
         # Extend to include GMNL-specific params (already allocated in n_params)
         if len(theta0) < self.n_params:
             theta0 = np.concatenate([theta0, np.zeros(self.n_params - len(theta0), dtype=np.float64)])
-        # tau=0 -> mean scale=1, raw_sigma_tau=-1 -> small scale SD, raw_gamma=0 -> gamma=0.5
+        # tau=0 -> mean scale=1, raw_sigma_tau=-1 -> small scale SD
         theta0[self._tau_idx] = 0.0
         theta0[self._sigma_tau_idx] = -1.0
-        theta0[self._gamma_idx] = 0.0
+        if self._gamma_idx is not None:
+            # raw_gamma=0 -> gamma=0.5
+            theta0[self._gamma_idx] = 0.0
         return theta0
 
     def _betas_from_theta(self, theta: torch.Tensor) -> torch.Tensor:
@@ -768,7 +779,10 @@ class GmnlEstimator(MixedLogitEstimator):
 
         tau = theta[self._tau_idx]
         sigma_tau = _positive(theta[self._sigma_tau_idx])
-        gamma = torch.sigmoid(theta[self._gamma_idx])
+        if self._fixed_gamma is not None:
+            gamma = torch.tensor(self._fixed_gamma, dtype=theta.dtype, device=theta.device)
+        else:
+            gamma = torch.sigmoid(theta[self._gamma_idx])
 
         # Scale factor: sigma_i = exp(tau + sigma_tau * epsilon_i)
         # shape: (n_individuals, n_draws)
@@ -819,23 +833,32 @@ class GmnlEstimator(MixedLogitEstimator):
         tau_est = float(theta_hat[self._tau_idx])
         raw_sigma_tau = theta_hat[self._sigma_tau_idx]
         sigma_tau_est = float(np.logaddexp(0.0, raw_sigma_tau) + 1e-6)
-        raw_gamma = theta_hat[self._gamma_idx]
-        gamma_est = float(1.0 / (1.0 + np.exp(-raw_gamma)))
 
         se_tau = float("nan")
         se_sigma_tau = float("nan")
-        se_gamma = float("nan")
         if vcov is not None:
             se_tau = float(np.sqrt(max(vcov[self._tau_idx, self._tau_idx], 0.0)))
             var_raw_st = vcov[self._sigma_tau_idx, self._sigma_tau_idx]
             deriv_st = self._softplus_derivative(raw_sigma_tau)
             se_sigma_tau = float(abs(deriv_st) * np.sqrt(max(var_raw_st, 0.0)))
-            var_raw_g = vcov[self._gamma_idx, self._gamma_idx]
-            deriv_g = gamma_est * (1.0 - gamma_est)  # sigmoid derivative
-            se_gamma = float(abs(deriv_g) * np.sqrt(max(var_raw_g, 0.0)))
 
         rows.append(self._make_row("tau (scale mean)", "scale", tau_est, se_tau, theta_index=self._tau_idx))
         rows.append(self._make_row("sigma_tau (scale SD)", "scale", sigma_tau_est, se_sigma_tau, theta_index=self._sigma_tau_idx))
-        rows.append(self._make_row("gamma (mixing)", "scale", gamma_est, se_gamma, theta_index=self._gamma_idx))
+
+        if self._fixed_gamma is not None:
+            # gamma is fixed — report as fixed value with no SE
+            rows.append(self._make_row(
+                f"gamma (fixed={self._fixed_gamma:.1f})", "scale",
+                self._fixed_gamma, float("nan"), theta_index=-1,
+            ))
+        else:
+            raw_gamma = theta_hat[self._gamma_idx]
+            gamma_est = float(1.0 / (1.0 + np.exp(-raw_gamma)))
+            se_gamma = float("nan")
+            if vcov is not None:
+                var_raw_g = vcov[self._gamma_idx, self._gamma_idx]
+                deriv_g = gamma_est * (1.0 - gamma_est)  # sigmoid derivative
+                se_gamma = float(abs(deriv_g) * np.sqrt(max(var_raw_g, 0.0)))
+            rows.append(self._make_row("gamma (mixing)", "scale", gamma_est, se_gamma, theta_index=self._gamma_idx))
 
         return pd.DataFrame(rows)

src/dce_analyzer/pipeline.py

@@ -38,6 +38,7 @@ def estimate_dataframe(
     estimate_lambda_w: bool = True,
     lc_method: str = "em",
     custom_start: list[float] | None = None,
+    fixed_gamma: float | None = None,
 ) -> PipelineResult:
     tensors = prepare_choice_tensors(df, spec, device=device)
 
@@ -94,6 +95,7 @@ def estimate_dataframe(
             bws_data=bws_data,
             correlated=correlated,
             correlation_groups=correlation_groups,
+            fixed_gamma=fixed_gamma,
         )
         return PipelineResult(
             tensors=tensors,
@@ -213,6 +215,7 @@ def estimate_from_spec(
         estimate_lambda_w=spec.estimate_lambda_w,
         lc_method=spec.lc_method,
         custom_start=spec.custom_start,
+        fixed_gamma={"s-mnl": 0.0, "gmnl-ii": 1.0}.get(spec.gmnl_variant),
     )
     result.expanded_spec = model_spec
     result.expanded_df = df