Add per-user model saving, forum persistence, sidebar/header sticky, session timeout 30min

- model_store.py: serialize/deserialize EstimationResult & LatentClassResult to HF Dataset (per-user, max 10)
- Model page: Save to Profile button + Saved Models section with Load/Delete
- utils.py: auto-load saved models on login, show in sidebar with delete, sticky sidebar & header CSS
- community_db.py: persist forum posts/replies to HF Dataset (no longer ephemeral)
- session_queue.py: extend session timeout from 2min to 30min
- utils.py: language banner tooltip explaining multilingual translations

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

app/community_db.py

@@ -3,9 +3,9 @@
 Stores users (username, email, join date) and posts (author, title, body,
 replies, timestamps).  Designed for single-instance deployment (HF Spaces).
 
-User accounts are persisted to a private HF Dataset repo
-(Wil2200/prefero-data) so they survive container restarts.
-Posts/replies are ephemeral (in-memory SQLite).
+User accounts, activity logs, and forum posts/replies are persisted to a
+private HF Dataset repo (Wil2200/prefero-data) so they survive container
+restarts.
 """
 
 from __future__ import annotations
@@ -302,6 +302,126 @@ def _sync_users_from_hf() -> None:
     conn.commit()
     logger.info("Loaded %d users from HF dataset into SQLite", len(users))
 
+
+# ---------------------------------------------------------------------------
+# HF Dataset persistence for forum posts/replies
+# ---------------------------------------------------------------------------
+
+_posts_synced = False  # only sync once per process
+
+
+def _save_posts_to_hf() -> None:
+    """Persist all posts and replies to the HF dataset repo."""
+    token = _hf_token()
+    if not token:
+        return
+    try:
+        from huggingface_hub import HfApi
+        import tempfile
+
+        conn = _get_conn()
+        post_rows = conn.execute(
+            "SELECT id, author_id, title, body, created_at, updated_at "
+            "FROM posts ORDER BY id"
+        ).fetchall()
+        posts = [dict(r) for r in post_rows]
+
+        reply_rows = conn.execute(
+            "SELECT id, post_id, author_id, body, created_at "
+            "FROM replies ORDER BY id"
+        ).fetchall()
+        replies = [dict(r) for r in reply_rows]
+
+        data = {"posts": posts, "replies": replies}
+        tmp = os.path.join(tempfile.gettempdir(), "prefero_forum_posts.json")
+        with open(tmp, "w") as f:
+            json.dump(data, f, indent=2)
+
+        api = HfApi(token=token)
+        api.upload_file(
+            path_or_fileobj=tmp, path_in_repo="forum_posts.json",
+            repo_id=_HF_DATASET_REPO, repo_type="dataset",
+        )
+        logger.info("Synced %d posts and %d replies to HF dataset", len(posts), len(replies))
+    except Exception as exc:
+        logger.warning("Failed to save posts to HF: %s", exc)
+
+
+def _load_posts_from_hf() -> dict:
+    """Load posts and replies from HF dataset repo. Returns {} on failure."""
+    token = _hf_token()
+    if not token:
+        logger.debug("No HF token — skipping posts sync")
+        return {}
+    try:
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download(
+            repo_id=_HF_DATASET_REPO, filename="forum_posts.json",
+            repo_type="dataset", token=token,
+        )
+        with open(path) as f:
+            data = json.load(f)
+        return data
+    except Exception as exc:
+        logger.debug("Failed to load posts from HF: %s", exc)
+        return {}
+
+
+def _sync_posts_from_hf() -> None:
+    """Restore forum posts and replies from HF dataset on startup (once)."""
+    global _posts_synced
+    if _posts_synced:
+        return
+    _posts_synced = True
+
+    data = _load_posts_from_hf()
+    if not data:
+        return
+
+    conn = _get_conn()
+    posts = data.get("posts", [])
+    replies = data.get("replies", [])
+
+    restored_posts = 0
+    for p in posts:
+        try:
+            existing = conn.execute(
+                "SELECT 1 FROM posts WHERE id = ?", (p["id"],)
+            ).fetchone()
+            if existing:
+                continue
+            conn.execute(
+                "INSERT INTO posts (id, author_id, title, body, created_at, updated_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (p["id"], p["author_id"], p["title"], p["body"],
+                 p["created_at"], p["updated_at"]),
+            )
+            restored_posts += 1
+        except Exception:
+            pass
+
+    restored_replies = 0
+    for r in replies:
+        try:
+            existing = conn.execute(
+                "SELECT 1 FROM replies WHERE id = ?", (r["id"],)
+            ).fetchone()
+            if existing:
+                continue
+            conn.execute(
+                "INSERT INTO replies (id, post_id, author_id, body, created_at) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (r["id"], r["post_id"], r["author_id"], r["body"],
+                 r["created_at"]),
+            )
+            restored_replies += 1
+        except Exception:
+            pass
+
+    conn.commit()
+    logger.info("Restored %d posts and %d replies from HF dataset", restored_posts, restored_replies)
+
+
 # ---------------------------------------------------------------------------
 # Database path — persistent on HF Spaces at /data or fallback to app dir
 # ---------------------------------------------------------------------------
@@ -386,6 +506,7 @@ def init_db() -> None:
     # Load persisted data from HF on first startup
     _sync_users_from_hf()
     _sync_activity_from_hf()
+    _sync_posts_from_hf()
 
 
 # ---------------------------------------------------------------------------
@@ -571,6 +692,8 @@ def create_post(author_id: int, title: str, body: str) -> Post:
     )
     conn.commit()
     user = get_user_by_id(author_id)
+    # Persist to HF dataset repo (non-blocking)
+    threading.Thread(target=_save_posts_to_hf, daemon=True).start()
     return Post(
         id=cur.lastrowid,
         author_id=author_id,
@@ -665,6 +788,8 @@ def create_reply(post_id: int, author_id: int, body: str) -> Reply:
     )
     conn.commit()
     user = get_user_by_id(author_id)
+    # Persist to HF dataset repo (non-blocking)
+    threading.Thread(target=_save_posts_to_hf, daemon=True).start()
     return Reply(
         id=cur.lastrowid,
         post_id=post_id,

app/model_store.py

@@ -0,0 +1,483 @@
+"""Per-user model persistence via HF Dataset.
+
+Each user's saved models are stored as ``models/{username}.json`` in the
+private HF Dataset repo ``Wil2200/prefero-data``.  Models survive container
+restarts **and** redeployments.
+
+Public API
+----------
+- save_model(username, model_entry) -> bool
+- load_models(username) -> list[dict]
+- delete_saved_model(username, index) -> bool
+- serialize_model_entry(entry) -> dict
+- deserialize_model_entry(data) -> dict
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import math
+import os
+import tempfile
+import threading
+from datetime import datetime, timezone
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+def _sanitize_float(v):
+    """Convert NaN / Inf to None so JSON stays spec-compliant."""
+    if isinstance(v, float) and (math.isnan(v) or math.isinf(v)):
+        return None
+    return v
+
+
+def _sanitize_list(lst):
+    """Recursively sanitize a (possibly nested) list of floats."""
+    if lst is None:
+        return None
+    out = []
+    for item in lst:
+        if isinstance(item, list):
+            out.append(_sanitize_list(item))
+        elif isinstance(item, float):
+            out.append(_sanitize_float(item))
+        else:
+            out.append(item)
+    return out
+
+_HF_DATASET_REPO = "Wil2200/prefero-data"
+_MAX_MODELS_PER_USER = 10
+_lock = threading.Lock()
+
+
+# ---------------------------------------------------------------------------
+# HF helpers (mirrors community_db.py pattern)
+# ---------------------------------------------------------------------------
+
+def _hf_token() -> str | None:
+    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+
+
+def _load_user_models_from_hf(username: str) -> list[dict]:
+    """Download ``models/{username}.json`` from the HF Dataset repo."""
+    token = _hf_token()
+    if not token:
+        logger.debug("No HF token -- skipping model load for %s", username)
+        return []
+    try:
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download(
+            repo_id=_HF_DATASET_REPO,
+            filename=f"models/{username}.json",
+            repo_type="dataset",
+            token=token,
+        )
+        with open(path) as f:
+            data = json.load(f)
+        return data.get("models", [])
+    except Exception as exc:
+        logger.debug("Failed to load models for %s from HF: %s", username, exc)
+        return []
+
+
+def _save_user_models_to_hf(username: str, models: list[dict]) -> None:
+    """Upload ``models/{username}.json`` to the HF Dataset repo."""
+    token = _hf_token()
+    if not token:
+        return
+    try:
+        from huggingface_hub import HfApi
+
+        data = {"models": models}
+        tmp = os.path.join(tempfile.gettempdir(), f"prefero_models_{username}.json")
+        with open(tmp, "w") as f:
+            json.dump(data, f)
+
+        api = HfApi(token=token)
+        api.upload_file(
+            path_or_fileobj=tmp,
+            path_in_repo=f"models/{username}.json",
+            repo_id=_HF_DATASET_REPO,
+            repo_type="dataset",
+        )
+        logger.info("Saved %d models for user %s to HF", len(models), username)
+    except Exception as exc:
+        logger.warning("Failed to save models for %s to HF: %s", username, exc)
+
+
+# ---------------------------------------------------------------------------
+# Serialization helpers
+# ---------------------------------------------------------------------------
+
+def _serialize_dataframe(df: pd.DataFrame | None) -> dict | None:
+    if df is None:
+        return None
+    data = {}
+    for col in df.columns:
+        vals = df[col].tolist()
+        data[col] = [_sanitize_float(v) if isinstance(v, float) else v for v in vals]
+    return {
+        "columns": list(df.columns),
+        "data": data,
+    }
+
+
+def _deserialize_dataframe(d: dict | None) -> pd.DataFrame | None:
+    if d is None:
+        return None
+    return pd.DataFrame(d["data"], columns=d["columns"])
+
+
+def _serialize_ndarray(arr: np.ndarray | None) -> list | None:
+    if arr is None:
+        return None
+    return _sanitize_list(arr.tolist())
+
+
+def _deserialize_ndarray(lst: list | None) -> np.ndarray | None:
+    if lst is None:
+        return None
+    return np.array(lst)
+
+
+def _serialize_variable_spec(vs) -> dict:
+    return {"name": vs.name, "column": vs.column, "distribution": vs.distribution}
+
+
+def _serialize_dummy_coding(dc) -> dict:
+    ref = dc.ref_level
+    # ref_level can be int/str/float -- store as-is (JSON-safe for primitives)
+    return {"column": dc.column, "ref_level": ref}
+
+
+def _serialize_interaction_term(it) -> dict:
+    return {"columns": list(it.columns)}
+
+
+def _serialize_model_spec(spec) -> dict | None:
+    if spec is None:
+        return None
+    from dce_analyzer.config import ModelSpec
+    return {
+        "id_col": spec.id_col,
+        "task_col": spec.task_col,
+        "alt_col": spec.alt_col,
+        "choice_col": spec.choice_col,
+        "variables": [_serialize_variable_spec(v) for v in spec.variables],
+        "n_draws": spec.n_draws,
+        "n_classes": getattr(spec, "n_classes", 2),
+        "membership_cols": getattr(spec, "membership_cols", None),
+    }
+
+
+def _serialize_full_model_spec(spec) -> dict | None:
+    if spec is None:
+        return None
+    return {
+        "id_col": spec.id_col,
+        "task_col": spec.task_col,
+        "alt_col": spec.alt_col,
+        "choice_col": spec.choice_col,
+        "variables": [_serialize_variable_spec(v) for v in spec.variables],
+        "model_type": spec.model_type,
+        "dummy_codings": [_serialize_dummy_coding(dc) for dc in spec.dummy_codings],
+        "interactions": [_serialize_interaction_term(it) for it in spec.interactions],
+        "correlated": spec.correlated,
+        "correlation_groups": spec.correlation_groups,
+        "bws_worst_col": spec.bws_worst_col,
+        "estimate_lambda_w": spec.estimate_lambda_w,
+        "gmnl_variant": spec.gmnl_variant,
+        "n_classes": spec.n_classes,
+        "membership_cols": spec.membership_cols,
+        "lc_method": spec.lc_method,
+        "n_draws": spec.n_draws,
+        "maxiter": spec.maxiter,
+        "seed": spec.seed,
+        "n_starts": spec.n_starts,
+        "custom_start": spec.custom_start,
+    }
+
+
+def _deserialize_variable_spec(d: dict):
+    from dce_analyzer.config import VariableSpec
+    return VariableSpec(name=d["name"], column=d["column"], distribution=d.get("distribution", "fixed"))
+
+
+def _deserialize_model_spec(d: dict | None):
+    if d is None:
+        return None
+    from dce_analyzer.config import ModelSpec
+    return ModelSpec(
+        id_col=d["id_col"],
+        task_col=d["task_col"],
+        alt_col=d["alt_col"],
+        choice_col=d["choice_col"],
+        variables=[_deserialize_variable_spec(v) for v in d["variables"]],
+        n_draws=d.get("n_draws", 200),
+        n_classes=d.get("n_classes", 2),
+        membership_cols=d.get("membership_cols"),
+    )
+
+
+def _deserialize_full_model_spec(d: dict | None):
+    if d is None:
+        return None
+    from dce_analyzer.config import FullModelSpec, DummyCoding, InteractionTerm
+    return FullModelSpec(
+        id_col=d["id_col"],
+        task_col=d["task_col"],
+        alt_col=d["alt_col"],
+        choice_col=d["choice_col"],
+        variables=[_deserialize_variable_spec(v) for v in d["variables"]],
+        model_type=d.get("model_type", "mixed"),
+        dummy_codings=[DummyCoding(column=dc["column"], ref_level=dc["ref_level"]) for dc in d.get("dummy_codings", [])],
+        interactions=[InteractionTerm(columns=tuple(it["columns"])) for it in d.get("interactions", [])],
+        correlated=d.get("correlated", False),
+        correlation_groups=d.get("correlation_groups"),
+        bws_worst_col=d.get("bws_worst_col"),
+        estimate_lambda_w=d.get("estimate_lambda_w", True),
+        gmnl_variant=d.get("gmnl_variant", "general"),
+        n_classes=d.get("n_classes", 2),
+        membership_cols=d.get("membership_cols"),
+        lc_method=d.get("lc_method", "em"),
+        n_draws=d.get("n_draws", 200),
+        maxiter=d.get("maxiter", 300),
+        seed=d.get("seed", 123),
+        n_starts=d.get("n_starts", 10),
+        custom_start=d.get("custom_start"),
+    )
+
+
+def _serialize_estimation_result(est) -> dict:
+    """Serialize an EstimationResult to a JSON-safe dict."""
+    return {
+        "_type": "EstimationResult",
+        "success": est.success,
+        "message": est.message,
+        "log_likelihood": _sanitize_float(est.log_likelihood),
+        "aic": _sanitize_float(est.aic),
+        "bic": _sanitize_float(est.bic),
+        "n_parameters": est.n_parameters,
+        "n_observations": est.n_observations,
+        "n_individuals": est.n_individuals,
+        "optimizer_iterations": est.optimizer_iterations,
+        "runtime_seconds": _sanitize_float(est.runtime_seconds),
+        "estimates": _serialize_dataframe(est.estimates),
+        "vcov_matrix": _serialize_ndarray(est.vcov_matrix),
+        "covariance_matrix": _serialize_ndarray(est.covariance_matrix),
+        "correlation_matrix": _serialize_ndarray(est.correlation_matrix),
+        "random_param_names": est.random_param_names,
+        "covariance_se": _serialize_ndarray(est.covariance_se),
+        "correlation_se": _serialize_ndarray(est.correlation_se),
+        "correlation_test": _serialize_dataframe(est.correlation_test),
+        "raw_theta": _serialize_ndarray(est.raw_theta),
+    }
+
+
+def _serialize_latent_class_result(est) -> dict:
+    """Serialize a LatentClassResult to a JSON-safe dict.
+
+    ``posterior_probs`` is skipped (too large) and restored as an empty
+    DataFrame on deserialization.
+    """
+    return {
+        "_type": "LatentClassResult",
+        "success": est.success,
+        "message": est.message,
+        "log_likelihood": _sanitize_float(est.log_likelihood),
+        "aic": _sanitize_float(est.aic),
+        "bic": _sanitize_float(est.bic),
+        "n_parameters": est.n_parameters,
+        "n_observations": est.n_observations,
+        "n_individuals": est.n_individuals,
+        "optimizer_iterations": est.optimizer_iterations,
+        "runtime_seconds": _sanitize_float(est.runtime_seconds),
+        "estimates": _serialize_dataframe(est.estimates),
+        "n_classes": est.n_classes,
+        "class_probabilities": _sanitize_list(list(est.class_probabilities)),
+        "class_estimates": _serialize_dataframe(est.class_estimates),
+        # posterior_probs intentionally skipped
+        "vcov_matrix": _serialize_ndarray(est.vcov_matrix),
+        "membership_estimates": _serialize_dataframe(est.membership_estimates),
+        "n_starts_attempted": est.n_starts_attempted,
+        "n_starts_succeeded": est.n_starts_succeeded,
+        "all_start_lls": _sanitize_list(list(est.all_start_lls)),
+        "best_start_index": est.best_start_index,
+        "optimizer_method": est.optimizer_method,
+        "em_iterations": est.em_iterations,
+        "em_ll_history": _sanitize_list(list(est.em_ll_history)),
+        "em_converged": est.em_converged,
+        "raw_theta": _serialize_ndarray(est.raw_theta),
+    }
+
+
+def _deserialize_estimation_result(d: dict):
+    from dce_analyzer.model import EstimationResult
+    return EstimationResult(
+        success=d["success"],
+        message=d["message"],
+        log_likelihood=d["log_likelihood"],
+        aic=d["aic"],
+        bic=d["bic"],
+        n_parameters=d["n_parameters"],
+        n_observations=d["n_observations"],
+        n_individuals=d["n_individuals"],
+        optimizer_iterations=d["optimizer_iterations"],
+        runtime_seconds=d["runtime_seconds"],
+        estimates=_deserialize_dataframe(d["estimates"]),
+        vcov_matrix=_deserialize_ndarray(d.get("vcov_matrix")),
+        covariance_matrix=_deserialize_ndarray(d.get("covariance_matrix")),
+        correlation_matrix=_deserialize_ndarray(d.get("correlation_matrix")),
+        random_param_names=d.get("random_param_names"),
+        covariance_se=_deserialize_ndarray(d.get("covariance_se")),
+        correlation_se=_deserialize_ndarray(d.get("correlation_se")),
+        correlation_test=_deserialize_dataframe(d.get("correlation_test")),
+        raw_theta=_deserialize_ndarray(d.get("raw_theta")),
+    )
+
+
+def _deserialize_latent_class_result(d: dict):
+    from dce_analyzer.latent_class import LatentClassResult
+    return LatentClassResult(
+        success=d["success"],
+        message=d["message"],
+        log_likelihood=d["log_likelihood"],
+        aic=d["aic"],
+        bic=d["bic"],
+        n_parameters=d["n_parameters"],
+        n_observations=d["n_observations"],
+        n_individuals=d["n_individuals"],
+        optimizer_iterations=d["optimizer_iterations"],
+        runtime_seconds=d["runtime_seconds"],
+        estimates=_deserialize_dataframe(d["estimates"]),
+        n_classes=d["n_classes"],
+        class_probabilities=d["class_probabilities"],
+        class_estimates=_deserialize_dataframe(d["class_estimates"]),
+        posterior_probs=pd.DataFrame(),  # skipped on serialize
+        vcov_matrix=_deserialize_ndarray(d.get("vcov_matrix")),
+        membership_estimates=_deserialize_dataframe(d.get("membership_estimates")),
+        n_starts_attempted=d.get("n_starts_attempted", 0),
+        n_starts_succeeded=d.get("n_starts_succeeded", 0),
+        all_start_lls=d.get("all_start_lls", []),
+        best_start_index=d.get("best_start_index", -1),
+        optimizer_method=d.get("optimizer_method", "L-BFGS-B"),
+        em_iterations=d.get("em_iterations", 0),
+        em_ll_history=d.get("em_ll_history", []),
+        em_converged=d.get("em_converged", False),
+        raw_theta=_deserialize_ndarray(d.get("raw_theta")),
+    )
+
+
+def _serialize_estimation(est) -> dict:
+    """Route to the correct serializer based on type."""
+    from dce_analyzer.latent_class import LatentClassResult
+    if isinstance(est, LatentClassResult):
+        return _serialize_latent_class_result(est)
+    return _serialize_estimation_result(est)
+
+
+def _deserialize_estimation(d: dict):
+    """Route to the correct deserializer based on ``_type`` tag."""
+    if d.get("_type") == "LatentClassResult":
+        return _deserialize_latent_class_result(d)
+    return _deserialize_estimation_result(d)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def serialize_model_entry(entry: dict) -> dict:
+    """Convert a session_state model_history entry to a JSON-serializable dict.
+
+    Expected keys in *entry*: label, model_type, spec, full_spec, estimation.
+    """
+    est = entry["estimation"]
+    return {
+        "label": entry.get("label", "unnamed"),
+        "model_type": entry.get("model_type", "mixed"),
+        "saved_at": datetime.now(timezone.utc).isoformat(),
+        "stats": {
+            "log_likelihood": _sanitize_float(est.log_likelihood),
+            "aic": _sanitize_float(est.aic),
+            "bic": _sanitize_float(est.bic),
+            "n_parameters": est.n_parameters,
+            "n_observations": est.n_observations,
+            "n_individuals": est.n_individuals,
+            "runtime_seconds": _sanitize_float(est.runtime_seconds),
+        },
+        "spec": _serialize_model_spec(entry.get("spec")),
+        "full_spec": _serialize_full_model_spec(entry.get("full_spec")),
+        "estimation_data": _serialize_estimation(est),
+    }
+
+
+def deserialize_model_entry(data: dict) -> dict:
+    """Reconstruct a model_history-compatible dict from stored JSON.
+
+    Returns a dict with keys: label, model_type, spec, full_spec, estimation.
+    """
+    return {
+        "label": data.get("label", "unnamed"),
+        "model_type": data.get("model_type", "mixed"),
+        "saved_at": data.get("saved_at"),
+        "spec": _deserialize_model_spec(data.get("spec")),
+        "full_spec": _deserialize_full_model_spec(data.get("full_spec")),
+        "estimation": _deserialize_estimation(data["estimation_data"]),
+    }
+
+
+def save_model(username: str, model_entry: dict) -> bool:
+    """Save a model to the user's profile.
+
+    Enforces a maximum of ``_MAX_MODELS_PER_USER`` models.
+    Returns ``True`` on success.
+    """
+    with _lock:
+        models = _load_user_models_from_hf(username)
+        if len(models) >= _MAX_MODELS_PER_USER:
+            logger.warning(
+                "User %s already has %d models (limit %d)",
+                username, len(models), _MAX_MODELS_PER_USER,
+            )
+            return False
+        serialized = serialize_model_entry(model_entry)
+        models.append(serialized)
+        _save_user_models_to_hf(username, models)
+        return True
+
+
+def load_models(username: str) -> list[dict]:
+    """Load all saved models for a user.
+
+    Returns a list of deserialized model_history-compatible dicts.
+    """
+    with _lock:
+        raw_models = _load_user_models_from_hf(username)
+    result = []
+    for m in raw_models:
+        try:
+            result.append(deserialize_model_entry(m))
+        except Exception as exc:
+            logger.warning("Skipping corrupt model for %s: %s", username, exc)
+    return result
+
+
+def delete_saved_model(username: str, index: int) -> bool:
+    """Delete a saved model by its index (0-based).
+
+    Returns ``True`` on success.
+    """
+    with _lock:
+        models = _load_user_models_from_hf(username)
+        if index < 0 or index >= len(models):
+            logger.warning("Invalid index %d for user %s (has %d models)", index, username, len(models))
+            return False
+        models.pop(index)
+        _save_user_models_to_hf(username, models)
+        return True

app/pages/2_⚙️_Model.py

@@ -1348,6 +1348,22 @@ if st.button("Run Estimation", type="primary", use_container_width=True):
         "estimation": estimation,
     })
 
+    # Save to profile button
+    _username = st.session_state.get("username", "")
+    if _username:
+        _n_saved = len(st.session_state.get("saved_models", []))
+        if _n_saved >= 10:
+            st.warning("You've reached the limit of 10 saved models. Delete one to save more.")
+        else:
+            if st.button("Save to Profile", key=f"_save_profile_{run_label}", type="secondary"):
+                from model_store import save_model, load_models
+                _entry = st.session_state.model_history[-1]
+                if save_model(_username, _entry):
+                    st.session_state.saved_models = load_models(_username)
+                    st.success(f"Model '{run_label}' saved to your profile!")
+                else:
+                    st.error("Could not save -- you may have reached the 10-model limit.")
+
     # Also store LC-specific result
     if model_type == "latent_class":
         st.session_state.lc_result = {
@@ -1495,4 +1511,53 @@ if st.session_state.model_history:
             st.session_state.model_results = None
         st.rerun()
 
+# ── Saved models from profile ──────────────────────────────────
+_saved = st.session_state.get("saved_models", [])
+if _saved:
+    st.divider()
+    st.subheader("Saved Models (Profile)")
+    st.caption("These models are saved to your profile and persist across sessions.")
+    _profile_delete_idx: int | None = None
+    _profile_load_idx: int | None = None
+    for i, sm in enumerate(_saved):
+        est = sm.get("estimation")
+        _info_c, _load_c, _del_c = st.columns([5, 1, 1])
+        with _info_c:
+            _saved_at = sm.get("saved_at", "")
+            if _saved_at:
+                _saved_at = _saved_at[:10]  # just date
+            st.markdown(
+                f"**{i+1}. {sm.get('label', 'model')}** ({sm.get('model_type', '?')}) "
+                f"-- LL: {est.log_likelihood:.3f}, AIC: {est.aic:.2f}, BIC: {est.bic:.2f} "
+                f"<span style='color:gray;font-size:0.8em;'>({_saved_at})</span>",
+                unsafe_allow_html=True,
+            )
+        with _load_c:
+            if st.button("Load", key=f"_load_saved_{i}"):
+                _profile_load_idx = i
+        with _del_c:
+            if st.button("Delete", key=f"_del_saved_{i}"):
+                _profile_delete_idx = i
+
+    if _profile_load_idx is not None:
+        _loaded = _saved[_profile_load_idx]
+        st.session_state.model_results = {
+            "spec": _loaded.get("spec"),
+            "full_spec": _loaded.get("full_spec"),
+            "model_type": _loaded.get("model_type"),
+            "estimation": _loaded["estimation"],
+            "label": _loaded.get("label"),
+            "expanded_df": None,
+        }
+        if _loaded not in st.session_state.model_history:
+            st.session_state.model_history.append(_loaded)
+        st.rerun()
+
+    if _profile_delete_idx is not None:
+        _username = st.session_state.get("username", "")
+        from model_store import delete_saved_model, load_models
+        if delete_saved_model(_username, _profile_delete_idx):
+            st.session_state.saved_models = load_models(_username)
+        st.rerun()
+
 slowbro_next_step("pages/2_⚙️_Model.py")

app/session_queue.py

@@ -21,7 +21,7 @@ import streamlit as st
 # ---------------------------------------------------------------------------
 
 _MAX_CONCURRENT = int(os.environ.get("PREFERO_MAX_CONCURRENT", "5"))
-_SESSION_TIMEOUT = 120  # 2 minutes of inactivity → evicted
+_SESSION_TIMEOUT = 1800  # 30 minutes of inactivity → evicted
 
 
 def _queue_enabled() -> bool:
@@ -212,7 +212,7 @@ def queue_gate() -> bool:
     # ── Session policy note ──
     st.warning(
         "**How the queue works:** Each user gets a seat for as long as "
-        "they're active. Sessions expire after **2 minutes** of inactivity "
+        "they're active. Sessions expire after **30 minutes** of inactivity "
         "to keep things moving — but if you're running a model, your seat "
         "is safe until estimation completes."
     )

app/utils.py

@@ -26,6 +26,7 @@ _SESSION_DEFAULTS: dict[str, object] = {
     "lc_result": None,
     "lc_bic_comparison": None,
     "lc_best_q": None,
+    "saved_models": [],
     "authenticated": False,
     "auth_email": "",
     "username": "",
@@ -139,6 +140,12 @@ def init_session_state() -> None:
         st.stop()
     require_queue_slot()
     queue_heartbeat()
+    if not st.session_state.get("_saved_models_loaded"):
+        username = st.session_state.get("username", "")
+        if username:
+            from model_store import load_models
+            st.session_state.saved_models = load_models(username)
+            st.session_state._saved_models_loaded = True
     st.session_state["_queue_admitted"] = True
     _inject_activity_heartbeat()
     import inspect
@@ -194,6 +201,26 @@ def slowbro_status() -> None:
         [data-testid="stStatusWidget"] {{
             display: none !important;
         }}
+        /* Keep header fixed at top when scrolling */
+        [data-testid="stHeader"] {{
+            position: fixed !important;
+            top: 0 !important;
+            left: 0 !important;
+            right: 0 !important;
+            z-index: 1000 !important;
+        }}
+        /* Keep sidebar fixed when scrolling */
+        section[data-testid="stSidebar"] {{
+            position: fixed !important;
+            height: 100vh !important;
+            top: 0 !important;
+            left: 0 !important;
+            z-index: 999 !important;
+        }}
+        section[data-testid="stSidebar"] > div {{
+            height: 100vh !important;
+            overflow-y: auto !important;
+        }}
         {_hide_admin_css}
         /* Slowbro pill — injected into Streamlit's fixed header via ::after */
         [data-testid="stHeader"]::after {{
@@ -237,6 +264,28 @@ def sidebar_branding() -> None:
     else:
         st.sidebar.info("No data loaded yet.")
 
+    # ── Saved models in sidebar ──
+    _saved = st.session_state.get("saved_models", [])
+    if _saved:
+        with st.sidebar.expander(f"Saved Models ({len(_saved)}/10)", expanded=False):
+            _sb_delete_idx: int | None = None
+            for i, sm in enumerate(_saved):
+                est = sm.get("estimation")
+                _ll = f"{est.log_likelihood:.1f}" if est else "?"
+                _col_info, _col_del = st.columns([5, 1])
+                with _col_info:
+                    st.caption(f"**{sm.get('label', 'model')}** ({sm.get('model_type', '?')}) LL:{_ll}")
+                with _col_del:
+                    if st.button("✕", key=f"_sb_del_saved_{i}", help="Delete"):
+                        _sb_delete_idx = i
+            if _sb_delete_idx is not None:
+                _uname = st.session_state.get("username", "")
+                if _uname:
+                    from model_store import delete_saved_model, load_models
+                    if delete_saved_model(_uname, _sb_delete_idx):
+                        st.session_state.saved_models = load_models(_uname)
+                    st.rerun()
+
     # Developer mode prompt (admin users only)
     if _is_admin_user() and not st.session_state.get("_dev_mode_active"):
         import os
@@ -290,11 +339,14 @@ def language_banner() -> None:
             0%   { transform: translateX(0%); }
             100% { transform: translateX(-50%); }
         }
+        .scroll-banner-wrap {
+            position: relative;
+            margin-bottom: 8px;
+        }
         .scroll-banner {
             overflow: hidden;
             white-space: nowrap;
             padding: 12px 0;
-            margin-bottom: 8px;
             border-top: 1px solid rgba(128,128,128,0.2);
             border-bottom: 1px solid rgba(128,128,128,0.2);
         }
@@ -309,6 +361,52 @@ def language_banner() -> None:
             padding: 0 16px;
         }
         .scroll-inner .zh { font-weight: 700; opacity: 1.0; font-size: 1.2rem; }
+        .banner-help {
+            position: absolute;
+            right: 6px;
+            top: 50%;
+            transform: translateY(-50%);
+            z-index: 10;
+        }
+        .banner-help-icon {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            width: 20px;
+            height: 20px;
+            border-radius: 50%;
+            background: rgba(128,128,128,0.18);
+            color: rgba(128,128,128,0.7);
+            font-size: 0.75rem;
+            font-weight: 600;
+            cursor: default;
+            user-select: none;
+            line-height: 1;
+        }
+        .banner-help-icon:hover {
+            background: rgba(128,128,128,0.30);
+            color: rgba(128,128,128,0.95);
+        }
+        .banner-help-tooltip {
+            display: none;
+            position: absolute;
+            right: 0;
+            top: 28px;
+            width: 260px;
+            padding: 12px 14px;
+            background: var(--background-color, #fff);
+            border: 1px solid rgba(128,128,128,0.2);
+            border-radius: 8px;
+            box-shadow: 0 4px 16px rgba(0,0,0,0.10);
+            white-space: normal;
+            font-size: 0.82rem;
+            line-height: 1.5;
+            color: var(--text-color, #444);
+            z-index: 100;
+        }
+        .banner-help:hover .banner-help-tooltip {
+            display: block;
+        }
         </style>
         """,
         unsafe_allow_html=True,
@@ -322,8 +420,20 @@ def language_banner() -> None:
 
     st.markdown(
         f"""
-        <div class="scroll-banner">
-            <div class="scroll-inner">{doubled}</div>
+        <div class="scroll-banner-wrap">
+            <div class="scroll-banner">
+                <div class="scroll-inner">{doubled}</div>
+            </div>
+            <div class="banner-help">
+                <div class="banner-help-icon">?</div>
+                <div class="banner-help-tooltip">
+                    The name <b>Prefero</b> is shown in many languages
+                    to celebrate the wonderful diversity of our users.
+                    Translations may not be perfectly accurate &mdash;
+                    if you spot an error, we would love to hear from you
+                    on the <b>Community</b> page!
+                </div>
+            </div>
         </div>
         """,
         unsafe_allow_html=True,