working with org token

app.py

@@ -9,8 +9,19 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from datetime import datetime
 
-from utils.dataset import format_categories_and_reasoning, save_to_dataset
-from utils.helpers import get_hf_token
+from utils.dataset import (
+    format_categories_and_reasoning,
+    get_dataset_repo_id,
+    get_roost_dataset_repo_id,
+    save_to_dataset,
+)
+from utils.helpers import (
+    check_token_availability,
+    format_token_status,
+    get_inference_token,
+    get_org_token,
+    get_personal_token,
+)
 from utils.model_interface import extract_model_id, run_test
 from ui.sidebar import build_sidebar
 from ui.tab_config import build_config_tab
@@ -40,10 +51,11 @@ def handle_run_test(test_input, current_policy, model_choice, reasoning_effort,
         return model_info, "*Please load a policy first*", "*No policy*", "*No response yet*", gr.update(value="", visible=False), gr.update(value="", visible=False)
 
     # OAuth token is automatically injected by Gradio - we don't pass login_button as input
-    hf_token, _ = get_hf_token(oauth_token)
+    # Use inference token (org preferred, falls back to personal)
+    hf_token, _ = get_inference_token(oauth_token)
     if hf_token is None:
         model_info = format_model_info(model_choice, reasoning_effort)
-        return model_info, "*Please log in to use Inference Providers*", "*Authentication required*", "*No response yet*", gr.update(value="", visible=False), gr.update(value="", visible=False)
+        return model_info, "*Please log in or set tokens to use Inference Providers*", "*Authentication required*", "*No response yet*", gr.update(value="", visible=False), gr.update(value="", visible=False)
 
     model_id = extract_model_id(model_choice)
 
@@ -65,31 +77,62 @@ def handle_run_test(test_input, current_policy, model_choice, reasoning_effort,
     reasoning_info_text, reasoning_info_visible = format_reasoning_info(model_choice, reasoning)
     
     # Save to dataset if enabled
-    if save_mode == "Save to Dataset" and hf_token is not None:
-        try:
-            categories_and_reasoning_text = format_categories_and_reasoning(parsed)
-            policy_violation = parsed.get("label", -1)
-            
-            data = {
-                "input": test_input,
-                "policy_violation": policy_violation,
-                "categories_and_reasoning": categories_and_reasoning_text,
-                "policy": current_policy,
-                "model_selection": model_choice,
-                "raw_response": raw_response,
-                "reasoning_trace": reasoning or "",
-                "reasoning_effort": reasoning_effort or "",
-                "max_tokens": int(max_tokens),
-                "temperature": float(temperature),
-                "top_p": float(top_p),
-                "system_prompt": system_prompt_val or "",
-                "response_format": response_format_val or "",
-                "timestamp": datetime.now().isoformat(),
-            }
-            save_to_dataset(hf_token, data)
-        except Exception as e:
-            # Log error but don't break test execution
-            print(f"Failed to save to dataset: {e}")
+    if save_mode == "Save to ROOST Dataset":
+        org_token = get_org_token()
+        if org_token:
+            try:
+                categories_and_reasoning_text = format_categories_and_reasoning(parsed)
+                policy_violation = parsed.get("label", -1)
+                
+                data = {
+                    "input": test_input,
+                    "policy_violation": policy_violation,
+                    "categories_and_reasoning": categories_and_reasoning_text,
+                    "policy": current_policy,
+                    "model_selection": model_choice,
+                    "raw_response": raw_response,
+                    "reasoning_trace": reasoning or "",
+                    "reasoning_effort": reasoning_effort or "",
+                    "max_tokens": int(max_tokens),
+                    "temperature": float(temperature),
+                    "top_p": float(top_p),
+                    "system_prompt": system_prompt_val or "",
+                    "response_format": response_format_val or "",
+                    "timestamp": datetime.now().isoformat(),
+                }
+                repo_id = get_roost_dataset_repo_id()
+                save_to_dataset(repo_id, org_token, data)
+            except Exception as e:
+                # Log error but don't break test execution
+                print(f"Failed to save to ROOST dataset: {e}")
+    elif save_mode == "Save to Private Dataset":
+        personal_token, _ = get_personal_token(oauth_token)
+        if personal_token:
+            try:
+                categories_and_reasoning_text = format_categories_and_reasoning(parsed)
+                policy_violation = parsed.get("label", -1)
+                
+                data = {
+                    "input": test_input,
+                    "policy_violation": policy_violation,
+                    "categories_and_reasoning": categories_and_reasoning_text,
+                    "policy": current_policy,
+                    "model_selection": model_choice,
+                    "raw_response": raw_response,
+                    "reasoning_trace": reasoning or "",
+                    "reasoning_effort": reasoning_effort or "",
+                    "max_tokens": int(max_tokens),
+                    "temperature": float(temperature),
+                    "top_p": float(top_p),
+                    "system_prompt": system_prompt_val or "",
+                    "response_format": response_format_val or "",
+                    "timestamp": datetime.now().isoformat(),
+                }
+                repo_id = get_dataset_repo_id(personal_token)
+                save_to_dataset(repo_id, personal_token, data)
+            except Exception as e:
+                # Log error but don't break test execution
+                print(f"Failed to save to private dataset: {e}")
     
     return (
         model_info,
@@ -116,6 +159,7 @@ with gr.Blocks(title="Moderation Model Testing") as demo:
     # Sidebar (collapsible)
     sidebar_components = build_sidebar()
     login_button = sidebar_components["login_button"]
+    token_status_markdown = sidebar_components["token_status"]
 
     # Main content area with tabs
     with gr.Tabs():
@@ -124,6 +168,7 @@ with gr.Blocks(title="Moderation Model Testing") as demo:
                 test_input = testing_components["test_input"]
                 run_test_btn = testing_components["run_test_btn"]
                 save_mode = testing_components["save_mode"]
+                save_mode_help = testing_components["save_mode_help"]
                 model_info_display = testing_components["model_info_display"]
                 label_display = testing_components["label_display"]
                 categories_display = testing_components["categories_display"]
@@ -147,6 +192,9 @@ with gr.Blocks(title="Moderation Model Testing") as demo:
                 example_dropdown = dataset_components["example_dropdown"]
                 cached_examples = dataset_components["cached_examples"]
                 dropdown_choices_state = dataset_components["dropdown_choices_state"]
+                refresh_private_btn = dataset_components["refresh_private_btn"]
+                refresh_roost_btn = dataset_components["refresh_roost_btn"]
+                dataset_help_text = dataset_components["dataset_help_text"]
 
     # ============================================================================
     # Event Handlers
@@ -189,6 +237,69 @@ with gr.Blocks(title="Moderation Model Testing") as demo:
         outputs=model_info_display,
     )
     
+    # Token status update handler
+    def update_token_status(oauth_token: gr.OAuthToken | None = None):
+        """Update token status markdown when OAuth changes."""
+        return format_token_status(oauth_token)
+    
+    # Save mode help text update handler
+    def update_save_mode_help(oauth_token: gr.OAuthToken | None = None):
+        """Update save mode help text based on token availability."""
+        from ui.tab_testing import format_save_mode_help
+        has_personal, has_org = check_token_availability(oauth_token)
+        return format_save_mode_help(has_personal, has_org)
+    
+    # Dataset button state update handler
+    def update_dataset_button_states(oauth_token: gr.OAuthToken | None = None):
+        """Update dataset button states based on token availability."""
+        has_personal, has_org = check_token_availability(oauth_token)
+        
+        # Update help text
+        help_text = (
+            f"*Private Dataset: {'✅ Available' if has_personal else '❌ Requires personal token (OAuth login or .env)'}*\n"
+            f"*ROOST Dataset: {'✅ Available' if has_org else '⚠️ Can load if public, requires org token to save'}*"
+        )
+        
+        return (
+            gr.update(interactive=has_personal),  # refresh_private_btn
+            gr.update(interactive=True),  # refresh_roost_btn (can load if public)
+            help_text,  # dataset_help_text
+        )
+    
+    # Combined handler for login button click - updates all token-dependent UI
+    def handle_login_click(oauth_token: gr.OAuthToken | None = None):
+        """Handle login button click and update all token-dependent UI."""
+        token_status = format_token_status(oauth_token)
+        
+        from ui.tab_testing import format_save_mode_help
+        has_personal, has_org = check_token_availability(oauth_token)
+        save_help = format_save_mode_help(has_personal, has_org)
+        
+        dataset_help = (
+            f"*Private Dataset: {'✅ Available' if has_personal else '❌ Requires personal token (OAuth login or .env)'}*\n"
+            f"*ROOST Dataset: {'✅ Available' if has_org else '⚠️ Can load if public, requires org token to save'}*"
+        )
+        
+        return (
+            token_status,  # token_status_markdown
+            save_help,  # save_mode_help
+            gr.update(interactive=has_personal),  # refresh_private_btn
+            gr.update(interactive=True),  # refresh_roost_btn
+            dataset_help,  # dataset_help_text
+        )
+    
+    login_button.click(
+        handle_login_click,
+        inputs=None,  # OAuth token auto-injected
+        outputs=[
+            token_status_markdown,
+            save_mode_help,
+            refresh_private_btn,
+            refresh_roost_btn,
+            dataset_help_text,
+        ]
+    )
+    
     # Dataset load handler
     def load_example_from_dataset(selected_label, cached_examples_list, dropdown_choices_list):
         """Load example from dataset and populate all fields."""

ui/sidebar.py

@@ -7,6 +7,8 @@ import gradio as gr
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+from utils.helpers import format_token_status
+
 
 def build_sidebar() -> dict:
     """Build the sidebar UI with app description and login."""
@@ -26,10 +28,11 @@ def build_sidebar() -> dict:
         
         gr.Markdown("---")
         gr.Markdown("### Authentication")
+        token_status_markdown = gr.Markdown(value=format_token_status(None))
         login_button = gr.LoginButton(value="Log in to Hugging Face")
-        gr.Markdown("*Log in with your Hugging Face to be able to query models through Inference Providers.*")
     
     return {
         "login_button": login_button,
+        "token_status": token_status_markdown,
     }
 

ui/tab_dataset.py

@@ -7,8 +7,8 @@ import gradio as gr
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from utils.dataset import load_dataset_examples
-from utils.helpers import get_hf_token
+from utils.dataset import get_dataset_repo_id, get_roost_dataset_repo_id, load_dataset_examples
+from utils.helpers import check_token_availability, get_org_token, get_personal_token
 from utils.model_interface import extract_model_id, get_model_info
 
 
@@ -61,13 +61,36 @@ def format_preview_markdown(example: dict) -> str:
 
 def build_dataset_tab() -> dict:
     """Build the dataset tab UI."""
-    with gr.Tab("📊 Saved Examples"):
+    with gr.Tab("📊 Session Management & Examples"):
         gr.Markdown(
             "Browse saved test results. Select an example to load it back into the app "
             "with all original settings for reproducibility."
         )
         
-        refresh_btn = gr.Button("Refresh Dataset", variant="secondary")
+        # Check token availability for button states
+        has_personal, has_org = check_token_availability(None)
+        
+        with gr.Row():
+            refresh_private_btn = gr.Button(
+                "Load Personal Dataset", 
+                variant="secondary",
+                interactive=has_personal
+            )
+            refresh_roost_btn = gr.Button(
+                "Load shared ROOST Dataset", 
+                variant="secondary",
+                interactive=True  # Can load if public, even without token
+            )
+        
+        # Help text explaining token requirements
+        dataset_help_text = gr.Markdown(
+            value=(
+                f"*Private Dataset: {'✅ Available' if has_personal else '❌ Requires personal token (OAuth login or .env)'}*\n"
+                f"*ROOST Dataset: {'✅ Available' if has_org else '⚠️ Can load if public, requires org token to save'}*"
+            ),
+            visible=True
+        )
+        
         example_dropdown = gr.Dropdown(
             label="Select Example",
             choices=[],
@@ -79,13 +102,28 @@ def build_dataset_tab() -> dict:
         cached_examples = gr.State(value=[])
         dropdown_choices_state = gr.State(value=[])
         
-        def refresh_dataset(oauth_token: gr.OAuthToken | None = None):
-            """Refresh dataset and populate dropdown."""
-            hf_token, _ = get_hf_token(oauth_token)
-            if hf_token is None:
-                return gr.update(choices=[]), "*Please log in to browse dataset*", [], []
+        def refresh_dataset(dataset_type: str, oauth_token: gr.OAuthToken | None = None):
+            """
+            Refresh dataset based on type.
+            
+            Args:
+                dataset_type: "private" or "roost"
+                oauth_token: OAuth token from login
+            """
+            if dataset_type == "private":
+                # Get personal token
+                personal_token, _ = get_personal_token(oauth_token)
+                if personal_token is None:
+                    return gr.update(choices=[]), "*Please log in or set personal token to browse private dataset*", [], []
+                repo_id = get_dataset_repo_id(personal_token)
+                token = personal_token
+            else:  # roost
+                # Try org token first, but allow None for public datasets
+                org_token = get_org_token()
+                repo_id = get_roost_dataset_repo_id()
+                token = org_token  # Can be None for public access
             
-            examples, labels = load_dataset_examples(hf_token)
+            examples, labels = load_dataset_examples(repo_id, token)
             if not examples or not labels:
                 return gr.update(choices=[], value=None), "*No examples found in dataset*", [], []
             
@@ -107,9 +145,23 @@ def build_dataset_tab() -> dict:
             
             return "*Select an example to preview*"
         
-        refresh_btn.click(
-            refresh_dataset,
-            inputs=None,
+        def refresh_private(oauth_token: gr.OAuthToken | None = None):
+            """Refresh private dataset."""
+            return refresh_dataset("private", oauth_token)
+        
+        def refresh_roost(oauth_token: gr.OAuthToken | None = None):
+            """Refresh ROOST dataset."""
+            return refresh_dataset("roost", oauth_token)
+        
+        refresh_private_btn.click(
+            refresh_private,
+            inputs=None,  # OAuth token auto-injected
+            outputs=[example_dropdown, preview_markdown, cached_examples, dropdown_choices_state]
+        )
+        
+        refresh_roost_btn.click(
+            refresh_roost,
+            inputs=None,  # OAuth token auto-injected
             outputs=[example_dropdown, preview_markdown, cached_examples, dropdown_choices_state]
         )
         
@@ -123,5 +175,8 @@ def build_dataset_tab() -> dict:
         "example_dropdown": example_dropdown,
         "cached_examples": cached_examples,
         "dropdown_choices_state": dropdown_choices_state,
+        "refresh_private_btn": refresh_private_btn,
+        "refresh_roost_btn": refresh_roost_btn,
+        "dataset_help_text": dataset_help_text,
     }
 

ui/tab_testing.py

@@ -11,6 +11,7 @@ import json
 
 from utils.constants import MODELS, TEST_EXAMPLES
 from utils.model_interface import extract_model_id, get_model_info
+from utils.helpers import check_token_availability
 
 
 def parse_json_response(response: str) -> dict:
@@ -82,6 +83,35 @@ def format_reasoning_info(model_choice, reasoning_text) -> tuple[str, bool]:
     return "", False
 
 
+def format_save_mode_help(has_personal: bool, has_org: bool) -> str:
+    """
+    Format help text explaining save mode options.
+    
+    Args:
+        has_personal: Whether personal token is available
+        has_org: Whether org token is available
+        
+    Returns:
+        Help text string
+    """
+    lines = []
+    
+    if not has_personal and not has_org:
+        lines.append("*⚠️ No tokens available. Please log in or set tokens to save results.*")
+    else:
+        if has_org:
+            lines.append("*✅ ROOST Dataset: Available (org token set)*")
+        else:
+            lines.append("*❌ ROOST Dataset: Requires org token (HACKATHON_INFERENCE_TOKEN)*")
+        
+        if has_personal:
+            lines.append("*✅ Private Dataset: Available (personal token set)*")
+        else:
+            lines.append("*❌ Private Dataset: Requires personal token (OAuth login or .env)*")
+    
+    return "\n".join(lines)
+
+
 def format_test_result(result: dict) -> tuple[str, dict, str, str, str]:
     """
     Format test result for display.
@@ -138,9 +168,15 @@ def build_testing_tab() -> dict:
                 run_test_btn = gr.Button("Run Test", variant="primary")
                 save_mode = gr.Radio(
                     label="Save to Dataset",
-                    choices=["Don't Save", "Save to Dataset"],
+                    choices=["Don't Save", "Save to ROOST Dataset", "Save to Private Dataset"],
                     value="Don't Save"
                 )
+                # Initialize help text based on token availability
+                has_personal, has_org = check_token_availability(None)
+                save_mode_help = gr.Markdown(
+                    value=format_save_mode_help(has_personal, has_org),
+                    visible=True
+                )
                 # Initialize with default model info
                 initial_model = f"{MODELS[0]['name']} ({MODELS[0]['id']})"
                 initial_info_lines = [
@@ -176,6 +212,7 @@ def build_testing_tab() -> dict:
         "load_example_btn": load_example_btn,
         "run_test_btn": run_test_btn,
         "save_mode": save_mode,
+        "save_mode_help": save_mode_help,
         "model_info_display": model_info_display,
         "label_display": label_display,
         "categories_display": categories_display,

utils/constants.py

@@ -38,12 +38,6 @@ MODELS = [
         "is_thinking": False,
         "supports_reasoning_level": False,
     },
-    {
-        "name": "Gemma-3-12B-Instruct",
-        "id": "google/gemma-3-12b-it",
-        "is_thinking": False,
-        "supports_reasoning_level": False,
-    },
     {
         "name": "Gemma-3-27B-Instruct",
         "id": "google/gemma-3-27b-it",

utils/dataset.py

@@ -43,18 +43,22 @@ def get_dataset_repo_id(token: str | None) -> str:
     return f"{username}/moderation-test-results"
 
 
-def load_dataset_from_hub(token: str | None) -> tuple[list[dict], Exception | None]:
+def get_roost_dataset_repo_id() -> str:
+    """Get ROOST org dataset repository ID."""
+    return "roosttools/moderation-test-results"
+
+
+def load_dataset_from_hub(repo_id: str, token: str | None) -> tuple[list[dict], Exception | None]:
     """
     Load dataset from Hub and return list of examples.
     
     Args:
-        token: HF token string or None
+        repo_id: Dataset repository ID
+        token: HF token string or None (None allows public dataset access)
         
     Returns:
         Tuple of (list of example dicts, error Exception or None if successful)
     """
-    repo_id = get_dataset_repo_id(token)
-    
     try:
         # Use load_dataset - more standard way to load from Hub
         dataset_dict = load_dataset(repo_id, token=token)
@@ -101,11 +105,12 @@ def format_categories_and_reasoning(parsed: dict) -> str:
         return "*No categories found in response*\n\nThis output expects a valid JSON response, as specified for example in the default prompt.\n\nThe raw response can be seen in the Model Response section below."
 
 
-def save_to_dataset(token: str | None, data: dict) -> tuple[bool, str]:
+def save_to_dataset(repo_id: str, token: str | None, data: dict) -> tuple[bool, str]:
     """
     Save test result to Hugging Face dataset.
     
     Args:
+        repo_id: Dataset repository ID (e.g., "username/moderation-test-results" or "roosttools/moderation-test-results")
         token: HF token string or None
         data: Dict with all test result fields
         
@@ -113,10 +118,8 @@ def save_to_dataset(token: str | None, data: dict) -> tuple[bool, str]:
         Tuple of (success: bool, message: str)
     """
     try:
-        repo_id = get_dataset_repo_id(token)
-        
         # Load existing dataset and examples using shared function
-        examples, load_error = load_dataset_from_hub(token)
+        examples, load_error = load_dataset_from_hub(repo_id, token)
         
         # If there was an error loading (other than FileNotFoundError), raise it
         if load_error is not None:
@@ -134,7 +137,6 @@ def save_to_dataset(token: str | None, data: dict) -> tuple[bool, str]:
     except FileNotFoundError:
         # Dataset doesn't exist yet, create new one
         try:
-            repo_id = get_dataset_repo_id(token)
             dataset = Dataset.from_list([data])
             dataset.push_to_hub(repo_id, token=token, private=True)
             return True, f"Saved to {repo_id}"
@@ -144,18 +146,19 @@ def save_to_dataset(token: str | None, data: dict) -> tuple[bool, str]:
         return False, f"Failed to save: {str(e)}"
 
 
-def load_dataset_examples(token: str | None) -> tuple[list[dict], list[str]]:
+def load_dataset_examples(repo_id: str, token: str | None) -> tuple[list[dict], list[str]]:
     """
     Load examples from Hugging Face dataset.
     
     Args:
-        token: HF token string or None
+        repo_id: Dataset repository ID
+        token: HF token string or None (None allows public dataset access)
         
     Returns:
         Tuple of (list of example dicts, list of formatted dropdown labels)
     """
     # Use shared loading function
-    examples, load_error = load_dataset_from_hub(token)
+    examples, load_error = load_dataset_from_hub(repo_id, token)
     
     # If there was an error loading, return empty lists
     if load_error is not None:

utils/helpers.py

@@ -6,9 +6,11 @@ import gradio as gr
 from dotenv import load_dotenv
 
 
-def get_hf_token(oauth_token: gr.OAuthToken | None) -> tuple[str | None, str]:
+def get_personal_token(oauth_token: gr.OAuthToken | None) -> tuple[str | None, str]:
     """
-    Get Hugging Face token from OAuth or .env fallback.
+    Get personal Hugging Face token from OAuth or .env fallback.
+    
+    Used for personal/user operations like saving to private datasets.
 
     Args:
         oauth_token: Gradio OAuth token from user login, or None
@@ -18,7 +20,7 @@ def get_hf_token(oauth_token: gr.OAuthToken | None) -> tuple[str | None, str]:
         - hf_token: Token string if available, None otherwise
         - status_message: Warning message if using local .env, empty string otherwise
     """
-    print(f"DEBUG: get_hf_token called with oauth_token type: {type(oauth_token)}")
+    print(f"DEBUG: get_personal_token called with oauth_token type: {type(oauth_token)}")
     
     if oauth_token is None or (isinstance(oauth_token, str) and oauth_token == "Log in to Hugging Face"):
         # Try loading from .env file
@@ -47,6 +49,103 @@ def get_hf_token(oauth_token: gr.OAuthToken | None) -> tuple[str | None, str]:
         return token, ""
 
 
+def get_org_token() -> str | None:
+    """
+    Get organization token from Space secret or .env fallback.
+    
+    Used for ROOST org dataset operations and inference (preferred).
+    
+    Returns:
+        Token string if available, None otherwise
+    """
+    # Check Space secret HACKATHON_INFERENCE_TOKEN
+    org_token = os.getenv("HACKATHON_INFERENCE_TOKEN")
+    if org_token:
+        return org_token
+    
+    # Fall back to .env file
+    load_dotenv()
+    org_token = os.getenv("ROOST_TOKEN_FALLBACK")
+    if org_token:
+        return org_token
+    
+    return None
+
+
+def get_inference_token(oauth_token: gr.OAuthToken | None) -> tuple[str | None, str]:
+    """
+    Get token for inference (org token preferred, falls back to personal).
+    
+    Returns:
+        Tuple of (token, status_message)
+    """
+    # Try org token first
+    org_token = get_org_token()
+    if org_token:
+        return org_token, ""
+    
+    # Fall back to personal token
+    personal_token, status_msg = get_personal_token(oauth_token)
+    return personal_token, status_msg
+
+
+def check_token_availability(oauth_token: gr.OAuthToken | None) -> tuple[bool, bool]:
+    """
+    Check which tokens are available.
+    
+    Returns:
+        Tuple of (has_personal: bool, has_org: bool)
+    """
+    has_personal = get_personal_token(oauth_token)[0] is not None
+    has_org = get_org_token() is not None
+    return has_personal, has_org
+
+
+def format_token_status(oauth_token: gr.OAuthToken | None) -> str:
+    """
+    Format markdown showing token status and usage.
+    
+    Returns:
+        Markdown string explaining which tokens are set and their uses
+    """
+    has_personal, has_org = check_token_availability(oauth_token)
+    
+    lines = [
+        "You can log in to yout Hugging Face account to save your work in a private dataset and use the app for inference after the end of the hackathon.",
+        "### Token Status",
+    ]
+    
+    # Personal token status
+    if has_personal:
+        personal_token, status_msg = get_personal_token(oauth_token)
+        if oauth_token and oauth_token.token:
+            source = "OAuth login"
+        else:
+            source = ".env file"
+        lines.append(f"- **Personal Token**: ✅ Available ({source})")
+        lines.append("  - Enables: Inference (fallback), Private dataset saves/loads")
+    else:
+        lines.append("- **Personal Token**: ❌ Not available")
+        lines.append("  - Required for: Private dataset operations")
+    
+    # Org token status
+    if has_org:
+        org_token = get_org_token()
+        # Check if it's from Space secret or .env
+        if os.getenv("HACKATHON_INFERENCE_TOKEN"):
+            source = "Space secret"
+        else:
+            source = ".env file"
+        lines.append(f"- **Org Token**: ✅ Available ({source})")
+        lines.append("  - Enables: Inference (preferred), ROOST dataset saves/loads")
+    else:
+        lines.append("- **Org Token**: ❌ Not available")
+        lines.append("  - Required for: ROOST dataset saves")
+        lines.append("  - Note: ROOST dataset can be loaded if public")
+    
+    return "\n".join(lines)
+
+
 def load_preset_policy(preset_name: str, base_dir: str) -> tuple[str, str]:
     """Load preset policy from markdown file."""
     preset_files = {

utils/model_interface.py

@@ -123,7 +123,7 @@ def run_test(
         temperature=temperature,
         top_p=top_p,
         stop=None,
-        # extra_headers={"X-HF-Bill-To": "roosttools"},
+        extra_headers={"X-HF-Bill-To": "roosttools"},
     )
 
     result = {"content": completion.choices[0].message.content}