Updated to latest version

Updated message

Fix bug

Fix bugs

.env.example

@@ -9,6 +9,7 @@ NDIF_API_KEY=your-ndif-api-key-here
 # Defaults to ~/.cache/huggingface if unset
 # Useful when working on a cluster with a shared cache or limited home quota
 HF_HOME=/path/to/your/hf/cache
+HF_TOKEN=your-token
 
 # Root directory for all generated artifacts (activations, plots, etc.)
 # Defaults to artifacts if unset

README.md

@@ -42,9 +42,15 @@ uv sync
 cp .env.example .env
 ```
 
+## Local Development
+
+The committed dependency graph uses git sources so `persona-ui` can install cleanly in a Hugging Face Space or any isolated environment.
+
+For local sibling checkouts, uncomment the `path` sources in `persona-ui/pyproject.toml` and `persona-vectors/pyproject.toml`, then comment out the git sources.
+
 ## Local Setup Note
 
-For now, `persona-data` and `persona-vectors` need to be checked out in the parent directory of `persona-ui`.
+For local development, `persona-data` and `persona-vectors` can still be checked out in the parent directory of `persona-ui`.
 
 Example:
 
@@ -80,6 +86,9 @@ ARTIFACTS_DIR=...      # Optional: where activations are read from (default: ./a
 
 The app picks up this file automatically via `load_dotenv()` on startup.
 
+You can also override the active NDIF or Hugging Face token from the sidebar
+`API Keys` section. Those inputs only apply for the current session.
+
 ## Saved Artifacts
 
 The Compare and Extract tabs read from / write to:
@@ -88,7 +97,7 @@ The Compare and Extract tabs read from / write to:
 artifacts/
 ├── activations/<model_dir>/<prompt_variant>/<persona_id>/
 │   ├── activations.safetensors
-│   └── metadata.json
+│   └── metadata.json   # used for persona names and layer counts
 └── chats/<model_dir>/<prompt_variant>/
     └── <export>.json
 ```

app.py

@@ -8,6 +8,42 @@ from utils.helpers import DATASET_SOURCES
 load_dotenv()
 DEFAULT_MODEL = os.environ.get("DEFAULT_MODEL", "google/gemma-2-2b-it")
 REMOTE_DEFAULT_MODEL = os.environ.get("REMOTE_DEFAULT_MODEL", "google/gemma-2-9b-it")
+NDIF_API_KEY = os.environ.get("NDIF_API_KEY", "")
+HF_TOKEN = os.environ.get("HF_TOKEN", os.environ.get("HUGGING_FACE_HUB_TOKEN", ""))
+
+
+_TABS = ["Chat", "Compare", "Extract"]
+_TAB_ICONS = [":material/chat:", ":material/search:", ":material/tune:"]
+
+
+def _sync_sidebar_api_key(env_var: str, value: str) -> None:
+    if value:
+        os.environ[env_var] = value
+
+
+def _sidebar_api_keys() -> None:
+    with st.sidebar:
+        st.divider()
+        st.caption("API Keys")
+
+        ndif_api_key = st.text_input(
+            "NDIF API key",
+            value=NDIF_API_KEY,
+            type="password",
+            key="sidebar__ndif_api_key",
+            help="Overrides NDIF_API_KEY for this session.",
+        )
+        _sync_sidebar_api_key("NDIF_API_KEY", ndif_api_key)
+
+        hf_token = st.text_input(
+            "Hugging Face token",
+            value=HF_TOKEN,
+            type="password",
+            key="sidebar__hf_token",
+            help="Overrides HF_TOKEN and HUGGING_FACE_HUB_TOKEN for this session.",
+        )
+        _sync_sidebar_api_key("HF_TOKEN", hf_token)
+        _sync_sidebar_api_key("HUGGING_FACE_HUB_TOKEN", hf_token)
 
 
 def _sidebar_controls() -> tuple[bool, str, str, str]:
@@ -18,7 +54,7 @@ def _sidebar_controls() -> tuple[bool, str, str, str]:
         st.caption("Chat, extract, and compare persona runs.")
 
         if "sidebar__active_tab" not in st.session_state:
-            st.session_state["sidebar__active_tab"] = _TABS[0]
+            st.session_state["sidebar__active_tab"] = "Chat"
 
         active_tab = st.session_state["sidebar__active_tab"]
         for tab_name, icon in zip(_TABS, _TAB_ICONS, strict=True):
@@ -71,11 +107,9 @@ def _sidebar_controls() -> tuple[bool, str, str, str]:
             help="Dataset for Chat and Extract.",
         )
 
-    return remote, model_name, dataset_source, active_tab
-
+    _sidebar_api_keys()
 
-_TABS = ["Chat", "Compare", "Extract"]
-_TAB_ICONS = [":material/chat:", ":material/search:", ":material/tune:"]
+    return remote, model_name, dataset_source, active_tab
 
 
 def main() -> None:

pyproject.toml

@@ -5,18 +5,19 @@ description = "Streamlit UI for persona-vectors"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "persona-vectors",
-    "persona-data",
+    "persona-vectors>=0.1.0",
+    "persona-data>=0.1.0",
     "streamlit>=1.44.0",
     "plotly>=6.6.0",
     "python-dotenv>=1.2.2",
 ]
 
 [tool.uv.sources]
-persona-vectors = { path = "../persona-vectors", editable = true }
-persona-data = { path = "../persona-data", editable = true }
-# persona-vectors = { git = "ssh://git@github.com/implicit-personalization/persona-vectors.git" }  # use for release
-# persona-data = { git = "ssh://git@github.com/implicit-personalization/persona-data.git" }  # use for release
+# Local development:
+# persona-vectors = { path = "../persona-vectors", editable = true }
+# persona-data = { path = "../persona-data", editable = true }
+persona-vectors = { git = "ssh://git@github.com/implicit-personalization/persona-vectors.git" }
+persona-data = { git = "ssh://git@github.com/implicit-personalization/persona-data.git" }
 
 # [build-system]
 # requires = ["uv_build>=0.11.3,<0.12"]

state.py

@@ -51,9 +51,11 @@ def get_chat_state(
     return state
 
 
-def reset_chat_state(model_name: str, remote: bool, dataset_source: str) -> None:
+def reset_chat_state(model_name: str, dataset_source: str) -> None:
     """Reset chat history and cache for the active context."""
 
-    state = get_chat_state(model_name, remote, dataset_source)
-    state["messages"] = []
-    state["past_key_values"] = None
+    key = chat_session_key(model_name, dataset_source)
+    if key in st.session_state:
+        state = st.session_state[key]
+        state["messages"] = []
+        state["past_key_values"] = None

tabs/chat.py

@@ -23,12 +23,118 @@ from utils.helpers import (
 )
 from utils.runtime import cached_model
 
+COLLAPSED_MESSAGE_CHAR_LIMIT = 500
+
+
+def _render_collapsible_markdown(content: str) -> None:
+    if len(content) <= COLLAPSED_MESSAGE_CHAR_LIMIT:
+        st.markdown(content)
+        return
+
+    with st.expander(f"Show full text ({len(content)} chars)", expanded=False):
+        st.markdown(content)
+
 
 def _render_chat_message(message: dict[str, str]) -> None:
     if not message.get("content"):
         return
     with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+        _render_collapsible_markdown(message["content"])
+
+
+def _render_inline_system_prompt(
+    prompt_key: str,
+    prompt_mode: str,
+    active_system_prompt: str | None,
+    edit_key: str,
+    height: int = 200,
+) -> str | None:
+    """Render the system prompt as an inline editable item at the top of the chat."""
+    if prompt_mode == "empty":
+        return active_system_prompt
+
+    if prompt_key not in st.session_state:
+        st.session_state[prompt_key] = active_system_prompt or ""
+
+    current_prompt = st.session_state[prompt_key] or None
+    is_editing = st.session_state.get(edit_key) == -1
+
+    with st.container(border=True):
+        st.caption("System prompt")
+        if is_editing:
+            new_val = st.text_area(
+                "system_prompt_edit",
+                value=current_prompt or "",
+                height=height,
+                label_visibility="collapsed",
+                key=f"{prompt_key}_inline_edit",
+            )
+            c1, c2 = st.columns(2)
+            with c1:
+                if st.button("Save", key=f"{edit_key}_sys_save", type="primary"):
+                    st.session_state[prompt_key] = new_val
+                    st.session_state[edit_key] = None
+                    st.rerun()
+            with c2:
+                if st.button("Cancel", key=f"{edit_key}_sys_cancel"):
+                    st.session_state[edit_key] = None
+                    st.rerun()
+        else:
+            if current_prompt:
+                _render_collapsible_markdown(current_prompt)
+            else:
+                st.markdown("*(empty)*")
+            if st.button("Edit", key=f"{edit_key}_sys_edit"):
+                st.session_state[edit_key] = -1
+                st.rerun()
+
+    return st.session_state.get(prompt_key) or None
+
+
+def _render_editable_message(
+    message: dict[str, str],
+    msg_index: int,
+    messages: list[dict[str, str]],
+    chat_state: dict[str, object],
+    edit_key: str,
+    pending_key: str,
+) -> None:
+    """Render a single message with an inline edit button."""
+    if not message.get("content"):
+        return
+
+    is_editing = st.session_state.get(edit_key) == msg_index
+
+    with st.chat_message(message["role"]):
+        if is_editing:
+            new_content = st.text_area(
+                "Edit",
+                value=message["content"],
+                height=100,
+                label_visibility="collapsed",
+                key=f"{edit_key}_msg_{msg_index}",
+            )
+            c1, c2 = st.columns(2)
+            with c1:
+                if st.button(
+                    "Save", key=f"{edit_key}_msg_save_{msg_index}", type="primary"
+                ):
+                    messages[msg_index]["content"] = new_content
+                    del messages[msg_index + 1 :]
+                    chat_state["past_key_values"] = None
+                    st.session_state[edit_key] = None
+                    if message["role"] == "user":
+                        st.session_state[pending_key] = True
+                    st.rerun()
+            with c2:
+                if st.button("Cancel", key=f"{edit_key}_msg_cancel_{msg_index}"):
+                    st.session_state[edit_key] = None
+                    st.rerun()
+        else:
+            st.markdown(message["content"])
+            if st.button("Edit", key=f"{edit_key}_msg_edit_{msg_index}"):
+                st.session_state[edit_key] = msg_index
+                st.rerun()
 
 
 def _clear_chat_ui_state(*keys: str) -> None:
@@ -38,14 +144,13 @@ def _clear_chat_ui_state(*keys: str) -> None:
 
 def _reset_single_chat_context(
     model_name: str,
-    remote: bool,
     dataset_source: str,
     chat_state: dict[str, object],
     persona_id: str,
     prompt_mode: str,
     *ui_keys: str,
 ) -> None:
-    reset_chat_state(model_name, remote, dataset_source)
+    reset_chat_state(model_name, dataset_source)
     chat_state["persona_id"] = persona_id
     chat_state["prompt_mode"] = prompt_mode
     _clear_chat_ui_state(*ui_keys)
@@ -101,35 +206,6 @@ def _render_persona_prompt_controls(
     return selected_persona, prompt_mode, changed
 
 
-def _render_system_prompt_editor(
-    prompt_key: str,
-    prompt_mode: str,
-    active_system_prompt: str | None,
-    *,
-    height: int,
-    label: str = "Prompt",
-) -> str | None:
-    """Render the editable system prompt area for a chat panel."""
-
-    if prompt_mode == "empty":
-        return active_system_prompt
-
-    if prompt_key not in st.session_state:
-        st.session_state[prompt_key] = active_system_prompt or ""
-
-    with st.expander("Edit prompt", expanded=False):
-        edited_prompt = (
-            st.text_area(
-                label,
-                key=prompt_key,
-                height=height,
-                label_visibility="collapsed",
-            )
-            or None
-        )
-    return edited_prompt
-
-
 def _render_chat_window(
     *,
     chat_log: Any,
@@ -137,6 +213,9 @@ def _render_chat_window(
     show_all_key: str,
     show_all_btn_key: str,
     show_earlier_label: str,
+    chat_state: dict[str, object] | None = None,
+    edit_key: str | None = None,
+    pending_key: str | None = None,
 ) -> Any:
     """Render the visible chat history inside one container."""
 
@@ -152,11 +231,19 @@ def _render_chat_window(
                 st.session_state[show_all_key] = True
                 st.rerun()
             visible_messages = messages[-VISIBLE_MESSAGE_COUNT:]
+            index_offset = len(messages) - VISIBLE_MESSAGE_COUNT
         else:
             visible_messages = messages
+            index_offset = 0
 
-        for message in visible_messages:
-            _render_chat_message(message)
+        for i, message in enumerate(visible_messages):
+            actual_index = index_offset + i
+            if edit_key and pending_key:
+                _render_editable_message(
+                    message, actual_index, messages, chat_state, edit_key, pending_key
+                )
+            else:
+                _render_chat_message(message)
 
     return chat_log
 
@@ -218,7 +305,9 @@ def _render_compare_mode(
     """Render the full side-by-side comparison UI."""
     left_col, right_col = st.columns(2)
 
-    def render_panel(side: str, column) -> tuple[dict[str, object], Any, str | None]:
+    def render_panel(
+        side: str, column
+    ) -> tuple[dict[str, object], Any, str | None, str]:
         panel_key = widget_key(context_key, f"cmp_{side}")
         state = st.session_state.get(panel_key)
         if state is None:
@@ -226,6 +315,8 @@ def _render_compare_mode(
             st.session_state[panel_key] = state
         prompt_key = widget_key(panel_key, "custom_prompt")
         show_all_key = widget_key(panel_key, "show_all")
+        edit_key = widget_key(panel_key, "edit_idx")
+        pending_regen_key = widget_key(panel_key, "pending_regen")
 
         selected_persona, prompt_mode, changed = _render_persona_prompt_controls(
             personas,
@@ -240,16 +331,11 @@ def _render_compare_mode(
             state["persona_id"] = selected_persona.id
             state["prompt_mode"] = prompt_mode
             _clear_chat_ui_state(prompt_key, show_all_key)
+            st.session_state.pop(edit_key, None)
 
         active_system_prompt = resolve_system_prompt(
             persona=selected_persona, mode=prompt_mode
         )
-        active_system_prompt = _render_system_prompt_editor(
-            prompt_key,
-            prompt_mode,
-            active_system_prompt,
-            height=150,
-        )
 
         btn_col1, btn_col2 = st.columns(2)
         with btn_col1:
@@ -279,22 +365,73 @@ def _render_compare_mode(
                 state["messages"] = []
                 state["past_key_values"] = None
                 _clear_chat_ui_state(prompt_key, show_all_key)
+                st.session_state.pop(edit_key, None)
                 st.rerun()
 
         chat_log = st.container()
+        with chat_log:
+            active_system_prompt = _render_inline_system_prompt(
+                prompt_key,
+                prompt_mode,
+                active_system_prompt,
+                edit_key,
+                height=150,
+            )
         _render_chat_window(
             chat_log=chat_log,
             messages=state["messages"],
             show_all_key=show_all_key,
             show_all_btn_key=widget_key(panel_key, "show_all_btn"),
             show_earlier_label="Show earlier",
+            chat_state=state,
+            edit_key=edit_key,
+            pending_key=pending_regen_key,
         )
-        return state, chat_log, active_system_prompt
+        return state, chat_log, active_system_prompt, pending_regen_key
 
     with left_col:
-        left_state, left_log, left_prompt = render_panel("left", left_col)
+        left_state, left_log, left_prompt, left_pending = render_panel("left", left_col)
     with right_col:
-        right_state, right_log, right_prompt = render_panel("right", right_col)
+        right_state, right_log, right_prompt, right_pending = render_panel(
+            "right", right_col
+        )
+
+    panels = [
+        (left_state, left_log, left_prompt, left_pending),
+        (right_state, right_log, right_prompt, right_pending),
+    ]
+
+    # Handle per-panel regeneration triggered by message edits
+    any_regen = any(st.session_state.get(p_pending) for _, _, _, p_pending in panels)
+    if any_regen:
+        model = cached_model(model_name=model_name, remote=remote)
+        for panel_state, panel_log, panel_prompt, p_pending in panels:
+            if not st.session_state.pop(p_pending, False):
+                continue
+            regen_messages = _build_chat_messages(panel_prompt, panel_state["messages"])
+            with st.spinner("Regenerating..."):
+                try:
+                    result = generate_chat_reply(
+                        model=model,
+                        messages=regen_messages,
+                        remote=remote,
+                        past_key_values=panel_state["past_key_values"],
+                        **gen_kwargs,
+                    )
+                except Exception as exc:
+                    with panel_log:
+                        st.error(f"Generation failed: {exc}")
+                    panel_state["messages"].pop()
+                    continue
+            panel_state["messages"].append(
+                {"role": "assistant", "content": result.text}
+            )
+            panel_state["past_key_values"] = (
+                result.past_key_values if not remote else None
+            )
+            with panel_log:
+                _render_chat_message({"role": "assistant", "content": result.text})
+        st.rerun()
 
     user_prompt = st.chat_input(
         "Ask both...",
@@ -304,12 +441,8 @@ def _render_compare_mode(
         return
 
     model = cached_model(model_name=model_name, remote=remote)
-    panels = [
-        (left_state, left_log, left_prompt),
-        (right_state, right_log, right_prompt),
-    ]
 
-    for panel_state, panel_log, _panel_prompt in panels:
+    for panel_state, panel_log, _panel_prompt, _p_pending in panels:
         panel_state["messages"].append({"role": "user", "content": user_prompt})
         with panel_log:
             _render_chat_message({"role": "user", "content": user_prompt})
@@ -331,7 +464,7 @@ def _render_compare_mode(
                         past_key_values=panel_state["past_key_values"],
                         **gen_kwargs,
                     )
-                    for panel_state, _panel_log, panel_prompt in panels
+                    for panel_state, _panel_log, panel_prompt, _p_pending in panels
                 ]
                 results: list[ChatReply | Exception] = []
                 for future in futures:
@@ -341,7 +474,7 @@ def _render_compare_mode(
                         results.append(exc)
         else:
             results = []
-            for panel_state, _panel_log, panel_prompt in panels:
+            for panel_state, _panel_log, panel_prompt, _p_pending in panels:
                 try:
                     results.append(
                         generate_chat_reply(
@@ -360,7 +493,9 @@ def _render_compare_mode(
                 except Exception as exc:
                     results.append(exc)
 
-    for (panel_state, panel_log, _panel_prompt), result in zip(panels, results):
+    for (panel_state, panel_log, _panel_prompt, _p_pending), result in zip(
+        panels, results
+    ):
         if isinstance(result, Exception):
             with panel_log:
                 st.error(f"Generation failed: {result}")
@@ -384,7 +519,11 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
     context_key = chat_session_key(model_name, dataset_source)
     chat_state = get_chat_state(model_name, remote, dataset_source)
     try:
-        dataset, dataset_status = load_dataset(dataset_source)
+        dataset, dataset_status = load_dataset(
+            dataset_source,
+            personas_file=st.session_state.get("extract__personas_file"),
+            qa_file=st.session_state.get("extract__qa_file"),
+        )
         st.caption(dataset_status)
     except Exception as exc:
         st.error(f"Could not load data: {exc}")
@@ -534,6 +673,7 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
     pending_key = widget_key(context_key, "pending_prompt")
     export_key = widget_key(context_key, "export_chat")
     reset_key = widget_key(context_key, "reset")
+    edit_key = widget_key(context_key, "edit_idx")
 
     col1, col2 = st.columns([2, 1])
     with col1:
@@ -571,7 +711,6 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
         had_history = bool(chat_state["messages"])
         _reset_single_chat_context(
             model_name,
-            remote,
             dataset_source,
             chat_state,
             selected_persona.id,
@@ -581,17 +720,20 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
             prompt_key,
             pending_key,
         )
+        st.session_state.pop(edit_key, None)
         if had_history:
             st.info("Chat history reset because the persona or system prompt changed.")
 
     chat_log = st.container()
 
-    active_system_prompt = _render_system_prompt_editor(
-        prompt_key,
-        prompt_mode,
-        active_system_prompt,
-        height=200,
-    )
+    with chat_log:
+        active_system_prompt = _render_inline_system_prompt(
+            prompt_key,
+            prompt_mode,
+            active_system_prompt,
+            edit_key,
+            height=200,
+        )
 
     action_col1, action_col2 = st.columns(2)
     with action_col1:
@@ -612,7 +754,6 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
         if st.button("Reset chat", key=reset_key, width="stretch", type="secondary"):
             _reset_single_chat_context(
                 model_name,
-                remote,
                 dataset_source,
                 chat_state,
                 selected_persona.id,
@@ -622,6 +763,7 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
                 prompt_key,
                 pending_key,
             )
+            st.session_state.pop(edit_key, None)
             st.rerun()
 
     _render_chat_window(
@@ -630,6 +772,9 @@ def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
         show_all_key=show_all_key,
         show_all_btn_key=widget_key(context_key, "show_all_btn"),
         show_earlier_label="Show earlier messages",
+        chat_state=chat_state,
+        edit_key=edit_key,
+        pending_key=pending_key,
     )
 
     user_prompt = st.chat_input(

tabs/compare.py

@@ -5,7 +5,7 @@ import streamlit as st
 import torch
 from persona_data.environment import get_artifacts_dir
 from persona_vectors.analysis import build_embedding_figure, project_pca, project_umap
-from persona_vectors.artifacts import ActivationStore
+from persona_vectors.artifacts import SUPPORTED_VARIANTS, ActivationStore
 from persona_vectors.artifacts import list_layers as list_available_layers
 from persona_vectors.artifacts import list_personas as list_available_personas
 from persona_vectors.artifacts import load_mean_activations, load_persona_names
@@ -14,7 +14,6 @@ from persona_vectors.plots import plot_layer_similarity, save_plot_html, save_pl
 from utils.helpers import (
     ANALYSIS_HELP_TEXT,
     ANALYSIS_MODES,
-    PROMPT_VARIANTS,
     persona_display_label,
     prompt_variant_label,
     slugify,
@@ -34,20 +33,27 @@ class ProjectionConfig:
     project_fn: Callable[[torch.Tensor], torch.Tensor]
 
 
+@dataclass(frozen=True)
+class _EmbeddingConfig:
+    variant: str
+    persona_ids: list[str]
+    persona_names: dict[str, str]
+    selected_layers: list[int]
+    persona_key: str
+
+
 _PROJECTION_CONFIGS: dict[str, ProjectionConfig] = {
     "PCA": ProjectionConfig("PCA", "PC1", "PC2", project_pca),
     "UMAP": ProjectionConfig("UMAP", "UMAP 1", "UMAP 2", project_umap),
 }
 
+_list_layers_cached = st.cache_data(show_spinner=False)(list_available_layers)
 
-@st.cache_data(show_spinner=False)
-def _list_layers(
-    root_dir: str,
-    model_name: str,
-    variants: list[str],
-    persona_ids: list[str],
-) -> list[int]:
-    return list_available_layers(root_dir, model_name, variants, persona_ids)
+# Cross-model/NDIF-switch persistence keys — written on every render so that
+# when the model changes (and widget keys change) the last selection is reused
+# as the default, filtered to whatever is available for the new model.
+_LAST_PERSONAS_KEY = "compare:last_personas"
+_LAST_LAYERS_KEY = "compare:last_layers"
 
 
 def _load_embedding_samples(
@@ -86,9 +92,9 @@ def _load_embedding_samples(
                 continue
 
             layer_vectors = vectors[:, layer_idx, :]
-            samples.append(layer_vectors)
-            labels.extend([persona_id] * layer_vectors.shape[0])
             display_name = persona_names.get(persona_id) or persona_id
+            samples.append(layer_vectors)
+            labels.extend([display_name] * layer_vectors.shape[0])
             hover_text.extend(
                 [f"<b>{display_name}</b><br>{variant}"] * layer_vectors.shape[0]
             )
@@ -114,28 +120,8 @@ def _load_embedding_samples(
     return plots, errors
 
 
-def _build_embedding_figures(
-    plots: list[tuple[int, torch.Tensor, list[str], list[str]]],
-    config: ProjectionConfig,
-) -> list[tuple[int, object]]:
-    return [
-        (
-            layer_idx,
-            build_embedding_figure(
-                coords=coords,
-                labels=labels,
-                title=f"{config.title_prefix}, layer {layer_idx}",
-                x_label=config.x_label,
-                y_label=config.y_label,
-                hover_text=hover_text,
-            ),
-        )
-        for layer_idx, coords, labels, hover_text in plots
-    ]
-
-
 def _render_embedding_results(
-    store: ActivationStore,
+    model_name: str,
     analysis_mode: str,
     rendered_figures: list[tuple[int, object]],
     saved_variant: str,
@@ -152,7 +138,7 @@ def _render_embedding_results(
         _filename(
             "compare",
             analysis_mode,
-            store.model_name,
+            model_name,
             saved_variant,
             saved_persona_key,
             str(layer_idx),
@@ -181,15 +167,20 @@ def _select_artifact_personas(
             st.info("No personas found for this model yet. Run extraction first.")
         return [], persona_names
 
+    last_personas: list[str] = st.session_state.get(_LAST_PERSONAS_KEY, [])
+    default_personas = [
+        p for p in last_personas if p in persona_options
+    ] or persona_options[:1]
     persona_ids = st.multiselect(
         "Personas",
         options=persona_options,
-        default=persona_options[:1] if len(persona_options) > 1 else persona_options,
+        default=default_personas,
         format_func=lambda persona_id: persona_display_label(
             persona_id, persona_names.get(persona_id)
         ),
         key=widget_key("load", "personas", store.model_name, *variants),
     )
+    st.session_state[_LAST_PERSONAS_KEY] = persona_ids
     return persona_ids, persona_names
 
 
@@ -215,11 +206,11 @@ def _render_save_buttons(
 
 def _select_embedding_config(
     store: ActivationStore,
-) -> tuple[str, list[str], dict[str, str], list[int]] | None:
+) -> _EmbeddingConfig | None:
     """Render variant / persona / layer selectors and return the selection, or None on early exit."""
     selected_variant = st.selectbox(
         "Variant",
-        options=PROMPT_VARIANTS,
+        options=SUPPORTED_VARIANTS,
         format_func=prompt_variant_label,
         key=widget_key("load", "variant"),
     )
@@ -228,7 +219,8 @@ def _select_embedding_config(
     if not persona_ids:
         return None
 
-    layer_options = _list_layers(
+    persona_key = "_".join(sorted(persona_ids))
+    layer_options = _list_layers_cached(
         str(store.root_dir),
         store.model_name,
         [selected_variant],
@@ -240,14 +232,14 @@ def _select_embedding_config(
         )
         return None
 
-    persona_key = "_".join(sorted(persona_ids))
     layer_key = widget_key(
         "load", "layers", store.model_name, selected_variant, persona_key
     )
+    last_layers: list[int] = st.session_state.get(
+        layer_key, st.session_state.get(_LAST_LAYERS_KEY, layer_options[:3])
+    )
     default_layers = [
-        layer
-        for layer in st.session_state.get(layer_key, layer_options[:3])
-        if layer in layer_options
+        layer for layer in last_layers if layer in layer_options
     ] or layer_options[:3]
     selected_layers = st.multiselect(
         "Layers",
@@ -259,7 +251,15 @@ def _select_embedding_config(
         st.info("Select at least one layer.")
         return None
 
-    return selected_variant, persona_ids, persona_names, selected_layers
+    st.session_state[_LAST_LAYERS_KEY] = selected_layers
+
+    return _EmbeddingConfig(
+        variant=selected_variant,
+        persona_ids=persona_ids,
+        persona_names=persona_names,
+        selected_layers=selected_layers,
+        persona_key=persona_key,
+    )
 
 
 def _render_cosine_similarity(store: ActivationStore) -> None:
@@ -267,7 +267,7 @@ def _render_cosine_similarity(store: ActivationStore) -> None:
     with col1:
         variant_a = st.selectbox(
             "Variant A",
-            options=PROMPT_VARIANTS,
+            options=SUPPORTED_VARIANTS,
             index=0,
             format_func=prompt_variant_label,
             key=widget_key("load", "variant_a"),
@@ -275,8 +275,8 @@ def _render_cosine_similarity(store: ActivationStore) -> None:
     with col2:
         variant_b = st.selectbox(
             "Variant B",
-            options=PROMPT_VARIANTS,
-            index=min(1, len(PROMPT_VARIANTS) - 1),
+            options=SUPPORTED_VARIANTS,
+            index=min(1, len(SUPPORTED_VARIANTS) - 1),
             format_func=prompt_variant_label,
             key=widget_key("load", "variant_b"),
         )
@@ -289,7 +289,9 @@ def _render_cosine_similarity(store: ActivationStore) -> None:
     if not persona_ids:
         return
 
-    cosine_fig_key = widget_key("load", "cosine_fig_state", store.model_name)
+    cosine_fig_key = widget_key(
+        "load", "cosine_fig_state", store.model_name, variant_a, variant_b
+    )
     filename = _filename("compare", "cosine", store.model_name, variant_a, variant_b)
 
     if st.button("Compare vectors", type="primary"):
@@ -334,8 +336,7 @@ def _render_embedding_analysis(store: ActivationStore, analysis_mode: str) -> No
     config = _select_embedding_config(store)
     if config is None:
         return
-    selected_variant, persona_ids, persona_names, selected_layers = config
-    persona_key = "_".join(sorted(persona_ids))
+
     projection_config = _PROJECTION_CONFIGS.get(analysis_mode)
     if projection_config is None:
         st.error(f"Unsupported analysis mode: {analysis_mode}")
@@ -358,11 +359,11 @@ def _render_embedding_analysis(store: ActivationStore, analysis_mode: str) -> No
         try:
             plots, errors = _load_embedding_samples(
                 store,
-                persona_ids,
-                selected_variant,
-                selected_layers,
+                config.persona_ids,
+                config.variant,
+                config.selected_layers,
                 projection_config.project_fn,
-                persona_names,
+                config.persona_names,
                 progress_fn=update_progress,
             )
 
@@ -382,12 +383,25 @@ def _render_embedding_analysis(store: ActivationStore, analysis_mode: str) -> No
                 st.info("Try fewer personas, fewer layers, or a different variant.")
                 st.session_state.pop(embedding_fig_key, None)
             else:
-                rendered_figures = _build_embedding_figures(plots, projection_config)
+                rendered_figures = [
+                    (
+                        layer_idx,
+                        build_embedding_figure(
+                            coords=coords,
+                            labels=labels,
+                            title=f"{projection_config.title_prefix}, layer {layer_idx}",
+                            x_label=projection_config.x_label,
+                            y_label=projection_config.y_label,
+                            hover_text=hover_text,
+                        ),
+                    )
+                    for layer_idx, coords, labels, hover_text in plots
+                ]
                 total_samples = sum(coords.shape[0] for _, coords, _, _ in plots)
                 st.session_state[embedding_fig_key] = (
                     rendered_figures,
-                    persona_key,
-                    selected_variant,
+                    config.persona_key,
+                    config.variant,
                     total_samples,
                 )
         finally:
@@ -398,7 +412,7 @@ def _render_embedding_analysis(store: ActivationStore, analysis_mode: str) -> No
             st.session_state[embedding_fig_key]
         )
         _render_embedding_results(
-            store,
+            store.model_name,
             analysis_mode,
             rendered_figures,
             saved_variant,

tabs/extract.py

@@ -1,16 +1,28 @@
+from typing import Literal, cast
+
 import streamlit as st
+from persona_vectors.artifacts import SUPPORTED_VARIANTS
 from persona_vectors.extraction import run_extraction
 
 from utils.datasets import load_dataset
 from utils.helpers import (
     NDIF_STATUS_ICONS,
-    PROMPT_VARIANTS,
     persona_label,
     prompt_variant_label,
     widget_key,
 )
 from utils.runtime import cached_model
 
+# Cross-model / remote-switch persistence — same pattern as compare.py.
+# Written on every render so selections survive model or NDIF toggles.
+_LAST_VARIANTS_KEY = "extract:last_variants"
+_LAST_PERSONA_IDS_KEY = "extract:last_persona_ids"
+_LAST_QA_TYPE_KEY = "extract:last_qa_type"
+_LAST_DIFFICULTY_KEY = "extract:last_difficulty"
+_LAST_MAX_QUESTIONS_KEY = "extract:last_max_questions"
+
+_QA_TYPE_OPTIONS = ["all", "explicit", "implicit"]
+
 
 def _extract_widget_key(
     model_name: str, remote: bool, dataset_source: str, suffix: str
@@ -26,7 +38,7 @@ def _render_local_dataset_uploads() -> None:
             "personas.jsonl",
             type=["jsonl"],
             key="extract__personas_file",
-            help="Expected fields: id, persona, templated_prompt, biography_md",
+            help="Expected fields: id, persona, templated_view, biography_view",
         )
         st.file_uploader(
             "qa.jsonl",
@@ -44,19 +56,28 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
     if dataset_source == "Local JSONL upload":
         _render_local_dataset_uploads()
 
+    last_variants = st.session_state.get(_LAST_VARIANTS_KEY, list(SUPPORTED_VARIANTS))
+    default_variants = [v for v in last_variants if v in SUPPORTED_VARIANTS] or list(
+        SUPPORTED_VARIANTS
+    )
     selected_variants = st.multiselect(
         "Prompt variants",
-        options=PROMPT_VARIANTS,
-        default=PROMPT_VARIANTS,
+        options=SUPPORTED_VARIANTS,
+        default=default_variants,
         format_func=prompt_variant_label,
         key=_extract_widget_key(model_name, remote, dataset_source, "prompt_variants"),
     )
+    st.session_state[_LAST_VARIANTS_KEY] = selected_variants
     if not selected_variants:
         st.info("Select at least one prompt variant.")
         return
 
     try:
-        dataset, dataset_status = load_dataset(dataset_source)
+        dataset, dataset_status = load_dataset(
+            dataset_source,
+            personas_file=st.session_state.get("extract__personas_file"),
+            qa_file=st.session_state.get("extract__qa_file"),
+        )
         st.caption(dataset_status)
     except Exception as exc:
         st.error(f"Could not load data: {exc}")
@@ -73,13 +94,18 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
         )
         return
 
+    last_persona_ids: set[str] = set(st.session_state.get(_LAST_PERSONA_IDS_KEY, []))
+    default_personas = [p for p in personas if p.id in last_persona_ids] or [
+        personas[0]
+    ]
     selected_personas = st.multiselect(
         "Personas",
         options=personas,
-        default=[personas[0]] if personas else [],
+        default=default_personas,
         format_func=persona_label,
         key=_extract_widget_key(model_name, remote, dataset_source, "persona_select"),
     )
+    st.session_state[_LAST_PERSONA_IDS_KEY] = [p.id for p in selected_personas]
 
     if not selected_personas:
         st.info("Select at least one persona.")
@@ -93,26 +119,42 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
 
         col1, col2, col3 = st.columns([2, 2, 1])
         with col1:
+            last_qa_type = st.session_state.get(_LAST_QA_TYPE_KEY, "all")
+            qa_type_index = (
+                _QA_TYPE_OPTIONS.index(last_qa_type)
+                if last_qa_type in _QA_TYPE_OPTIONS
+                else 0
+            )
             qa_type_select = st.selectbox(
                 "QA type",
-                options=["all", "explicit", "implicit"],
-                index=0,
+                options=_QA_TYPE_OPTIONS,
+                index=qa_type_index,
                 key=_extract_widget_key(
                     model_name, remote, dataset_source, "qa_type_select"
                 ),
             )
-            qa_filter_type = (
-                qa_type_select if qa_type_select in ("explicit", "implicit") else None
+            st.session_state[_LAST_QA_TYPE_KEY] = qa_type_select
+            qa_filter_type: Literal["explicit", "implicit"] | None = (
+                cast(Literal["explicit", "implicit"], qa_type_select)
+                if qa_type_select in ("explicit", "implicit")
+                else None
             )
         with col2:
+            last_difficulty = st.session_state.get(_LAST_DIFFICULTY_KEY, [1, 2, 3])
+            default_difficulty = [d for d in last_difficulty if d in (1, 2, 3)] or [
+                1,
+                2,
+                3,
+            ]
             difficulty_values = st.multiselect(
                 "Difficulty",
                 options=[1, 2, 3],
-                default=[1, 2, 3],
+                default=default_difficulty,
                 key=_extract_widget_key(
                     model_name, remote, dataset_source, "difficulty_select"
                 ),
             )
+            st.session_state[_LAST_DIFFICULTY_KEY] = difficulty_values
             qa_filter_difficulty = difficulty_values if difficulty_values else None
 
         runs, skipped = [], []
@@ -135,15 +177,18 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
             return
 
         max_q = min(len(qa_pairs) for _, qa_pairs in runs)
+        last_max = st.session_state.get(_LAST_MAX_QUESTIONS_KEY, max_q)
+        default_max = min(max(last_max, 1), max_q)
         max_questions = st.slider(
             "Max questions",
             min_value=1,
             max_value=max_q,
-            value=max_q,
+            value=default_max,
             key=_extract_widget_key(
                 model_name, remote, dataset_source, "max_questions"
             ),
         )
+        st.session_state[_LAST_MAX_QUESTIONS_KEY] = max_questions
 
     if runs is None:
         return
@@ -180,7 +225,7 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
                     model_name=model_name,
                     persona=persona,
                     qa_pairs=qa_pairs[:max_questions],
-                    variants=[variant],
+                    variants=(variant,),
                     remote=remote,
                     on_status=_on_ndif_status if remote else None,
                 )

utils/chat.py

@@ -5,17 +5,10 @@ from typing import Literal
 
 import torch
 from nnterp import StandardizedTransformer
-
-logger = logging.getLogger(__name__)
-
-from persona_data.prompts import (
-    format_biography_prompt,
-    format_empty_persona_prompt,
-    format_templated_prompt,
-    normalize_messages,
-)
+from persona_data.prompts import format_roleplay_prompt, normalize_messages
 from persona_data.synth_persona import PersonaData
 
+logger = logging.getLogger(__name__)
 SystemPromptMode = Literal["empty", "templated", "biography", "custom"]
 
 
@@ -47,11 +40,12 @@ def resolve_system_prompt(
     if mode == "empty":
         return ""
     if mode == "templated":
-        return format_templated_prompt(persona.templated_prompt)
+        return format_roleplay_prompt(persona.templated_view, mode="conversational")
     if mode == "biography":
-        return format_biography_prompt(persona.biography_md)
+        return format_roleplay_prompt(persona.biography_view, mode="conversational")
     if mode == "custom":
-        return format_empty_persona_prompt()
+        return format_roleplay_prompt(mode="conversational")
+    raise ValueError(f"Unsupported system prompt mode: {mode}")
 
 
 def _format_plain_messages(

utils/chat_export.py

@@ -54,7 +54,7 @@ def save_chat_export(
     export_dir = (
         get_artifacts_dir()
         / "chats"
-        / model_name.replace("/", "__")
+        / "__".join(slugify(part) for part in model_name.split("/"))
         / slugify(dataset_source)
         / slugify(persona_id)
     )

utils/datasets.py

@@ -44,14 +44,14 @@ def _uploaded_file_to_temp_path(uploaded_file: Any, stem: str) -> Path:
 
 def load_dataset(
     dataset_source: str,
+    personas_file: Any = None,
+    qa_file: Any = None,
 ) -> tuple[SynthPersonaDataset | LocalPersonaDataset, str]:
     """Load the selected dataset source for the UI."""
 
     if dataset_source == DATASET_SOURCES[0]:
         return cached_hf_dataset(), "SynthPersona"
 
-    personas_file = st.session_state.get("extract__personas_file")
-    qa_file = st.session_state.get("extract__qa_file")
     if personas_file is None or qa_file is None:
         raise ValueError("Upload both personas.jsonl and qa.jsonl files")
 

utils/helpers.py

@@ -1,7 +1,6 @@
 import re
 
 from persona_data.synth_persona import PersonaData
-from persona_vectors.artifacts import SUPPORTED_VARIANTS
 
 # Variant key -> human-readable label mapping
 VARIANT_LABELS = {
@@ -11,9 +10,6 @@ VARIANT_LABELS = {
     "custom": "Custom",
 }
 
-# Variants that correspond to actual system prompts (excludes "empty")
-PROMPT_VARIANTS = list(SUPPORTED_VARIANTS)
-
 # For selectbox options: list of labels in definition order
 MODE_LABELS = list(VARIANT_LABELS.values())
 

uv.lock

@@ -297,7 +297,7 @@ name = "cuda-bindings"
 version = "13.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "cuda-pathfinder" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/1a/fe/7351d7e586a8b4c9f89731bfe4cf0148223e8f9903ff09571f78b3fb0682/cuda_bindings-13.2.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08b395f79cb89ce0cd8effff07c4a1e20101b873c256a1aeb286e8fd7bd0f556", size = 5744254, upload-time = "2026-03-11T00:12:29.798Z" },
@@ -316,10 +316,10 @@ wheels = [
 
 [[package]]
 name = "cuda-pathfinder"
-version = "1.5.1"
+version = "1.5.2"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/74/8c66861b873d8eed51fde56d3091baa4906a56f0d4390cae991f2d41dda5/cuda_pathfinder-1.5.1-py3-none-any.whl", hash = "sha256:b3718097fb57cf9e8a904dd072d806f2c9a27627e35c020b06ab9454bcec08c0", size = 49861, upload-time = "2026-04-03T16:41:22.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/f9/1b9b60a30fc463c14cdea7a77228131a0ccc89572e8df9cb86c9648271ab/cuda_pathfinder-1.5.2-py3-none-any.whl", hash = "sha256:0c5f160a7756c5b072723cbbd6d861e38917ef956c68150b02f0b6e9271c71fa", size = 49988, upload-time = "2026-04-06T23:01:05.17Z" },
 ]
 
 [[package]]
@@ -332,37 +332,37 @@ wheels = [
 
 [package.optional-dependencies]
 cublas = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cublas", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 cudart = [
-    { name = "nvidia-cuda-runtime", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 cufft = [
-    { name = "nvidia-cufft", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cufft", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 cufile = [
     { name = "nvidia-cufile", marker = "sys_platform == 'linux'" },
 ]
 cupti = [
-    { name = "nvidia-cuda-cupti", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 curand = [
-    { name = "nvidia-curand", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-curand", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 cusolver = [
-    { name = "nvidia-cusolver", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cusolver", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 cusparse = [
-    { name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cusparse", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 nvjitlink = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 nvrtc = [
-    { name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 nvtx = [
-    { name = "nvidia-nvtx", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or sys_platform == 'linux'" },
+    { name = "nvidia-nvtx", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 
 [[package]]
@@ -508,7 +508,7 @@ wheels = [
 
 [[package]]
 name = "huggingface-hub"
-version = "1.9.0"
+version = "1.9.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -521,9 +521,9 @@ dependencies = [
     { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/88/bb/62c7aa86f63a05e2f9b96642fdef9b94526a23979820b09f5455deff4983/huggingface_hub-1.9.0.tar.gz", hash = "sha256:0ea5be7a56135c91797cae6ad726e38eaeb6eb4b77cefff5c9d38ba0ecf874f7", size = 750326, upload-time = "2026-04-03T08:35:55.888Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/65/fb800d327bf25bf31b798dd08935d326d064ecb9b359059fecd91b3a98e8/huggingface_hub-1.9.2.tar.gz", hash = "sha256:8d09d080a186bd950a361bfc04b862dfb04d6a2b41d48e9ba1b37507cfd3f1e1", size = 750284, upload-time = "2026-04-08T08:43:11.127Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/37/0d15d16150e1829f3e90962c99f28257f6de9e526a680b4c6f5acdb54fd2/huggingface_hub-1.9.0-py3-none-any.whl", hash = "sha256:2999328c058d39fd19ab748dd09bd4da2fbaa4f4c1ddea823eab103051e14a1f", size = 637355, upload-time = "2026-04-03T08:35:53.897Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d4/e33bf0b362810a9b96c5923e38908950d58ecb512db42e3730320c7f4a3a/huggingface_hub-1.9.2-py3-none-any.whl", hash = "sha256:e1e62ce237d4fbeca9f970aeb15176fbd503e04c25577bfd22f44aa7aa2b5243", size = 637349, upload-time = "2026-04-08T08:43:09.114Z" },
 ]
 
 [[package]]
@@ -883,11 +883,11 @@ wheels = [
 
 [[package]]
 name = "narwhals"
-version = "2.18.1"
+version = "2.19.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/59/96/45218c2fdec4c9f22178f905086e85ef1a6d63862dcc3cd68eb60f1867f5/narwhals-2.18.1.tar.gz", hash = "sha256:652a1fcc9d432bbf114846688884c215f17eb118aa640b7419295d2f910d2a8b", size = 620578, upload-time = "2026-03-24T15:11:25.456Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/1a/bd3317c0bdbcd9ffb710ddf5250b32898f8f2c240be99494fe137feb77a7/narwhals-2.19.0.tar.gz", hash = "sha256:14fd7040b5ff211d415a82e4827b9d04c354e213e72a6d0730205ffd72e3b7ff", size = 623698, upload-time = "2026-04-06T15:50:58.786Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/c3/06490e98393dcb4d6ce2bf331a39335375c300afaef526897881fbeae6ab/narwhals-2.18.1-py3-none-any.whl", hash = "sha256:a0a8bb80205323851338888ba3a12b4f65d352362c8a94be591244faf36504ad", size = 444952, upload-time = "2026-03-24T15:11:23.801Z" },
+    { url = "https://files.pythonhosted.org/packages/37/72/e61e3091e0e00fae9d3a8ef85ece9d2cd4b5966058e1f2901ce42679eebf/narwhals-2.19.0-py3-none-any.whl", hash = "sha256:1f8dfa4a33a6dbff878c3e9be4c3b455dfcaf2a9322f1357db00e4e92e95b84b", size = 446991, upload-time = "2026-04-06T15:50:57.046Z" },
 ]
 
 [[package]]
@@ -1216,7 +1216,7 @@ name = "nvidia-cudnn-cu13"
 version = "9.19.0.56"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/84/26025437c1e6b61a707442184fa0c03d083b661adf3a3eecfd6d21677740/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:6ed29ffaee1176c612daf442e4dd6cfeb6a0caa43ddcbeb59da94953030b1be4", size = 433781201, upload-time = "2026-02-03T20:40:53.805Z" },
@@ -1228,7 +1228,7 @@ name = "nvidia-cufft"
 version = "12.0.0.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
@@ -1258,9 +1258,9 @@ name = "nvidia-cusolver"
 version = "12.0.4.66"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
-    { name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas" },
+    { name = "nvidia-cusparse" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
@@ -1272,7 +1272,7 @@ name = "nvidia-cusparse"
 version = "12.6.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
@@ -1561,7 +1561,7 @@ wheels = [
 [[package]]
 name = "persona-data"
 version = "0.1.0"
-source = { editable = "../persona-data" }
+source = { git = "ssh://git@github.com/implicit-personalization/persona-data.git#3763bd6e42472b589b4e32acd3e47b711a0af1f5" }
 dependencies = [
     { name = "huggingface-hub" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
@@ -1570,14 +1570,6 @@ dependencies = [
     { name = "torch" },
 ]
 
-[package.metadata]
-requires-dist = [
-    { name = "huggingface-hub", specifier = ">=0.30.0" },
-    { name = "numpy", specifier = ">=1.24.0" },
-    { name = "python-dotenv", specifier = ">=1.0.0" },
-    { name = "torch", specifier = ">=2.0.0" },
-]
-
 [[package]]
 name = "persona-ui"
 version = "0.1.0"
@@ -1592,8 +1584,8 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "persona-data", editable = "../persona-data" },
-    { name = "persona-vectors", editable = "../persona-vectors" },
+    { name = "persona-data", git = "ssh://git@github.com/implicit-personalization/persona-data.git" },
+    { name = "persona-vectors", git = "ssh://git@github.com/implicit-personalization/persona-vectors.git" },
     { name = "plotly", specifier = ">=6.6.0" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "streamlit", specifier = ">=1.44.0" },
@@ -1602,7 +1594,7 @@ requires-dist = [
 [[package]]
 name = "persona-vectors"
 version = "0.1.0"
-source = { editable = "../persona-vectors" }
+source = { git = "ssh://git@github.com/implicit-personalization/persona-vectors.git#fa6b4b61eaaba9ce64ee8614766bf75879148bbb" }
 dependencies = [
     { name = "kaleido" },
     { name = "nnsight" },
@@ -1620,23 +1612,6 @@ dependencies = [
     { name = "umap-learn" },
 ]
 
-[package.metadata]
-requires-dist = [
-    { name = "kaleido", specifier = ">=1.0.0" },
-    { name = "nnsight", specifier = ">=0.6.1" },
-    { name = "nnterp", specifier = ">=1.3.0" },
-    { name = "persona-data", editable = "../persona-data" },
-    { name = "plotly", specifier = ">=6.6.0" },
-    { name = "python-dotenv", specifier = ">=1.2.2" },
-    { name = "safetensors", specifier = ">=0.7.0" },
-    { name = "scikit-learn", specifier = ">=1.6.0" },
-    { name = "torch", specifier = ">=2.10.0" },
-    { name = "torchvision", specifier = ">=0.26.0" },
-    { name = "tqdm", specifier = ">=4.67.3" },
-    { name = "transformers", specifier = ">=5.2.0" },
-    { name = "umap-learn", specifier = ">=0.5.7" },
-]
-
 [[package]]
 name = "pexpect"
 version = "4.9.0"
@@ -2075,7 +2050,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "9.0.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -2086,9 +2061,9 @@ dependencies = [
     { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]