fix: resolve column mismatch error in get_settings function

Removed ihc_subtype parameter from get_settings() function to match
SETTINGS_COLUMNS which has 6 columns (IHC Subtype is commented out).
This fixes ValueError: 6 columns passed, passed data had 7 columns.

Changes:
- Remove ihc_subtype from get_settings() signature
- Remove ihc_subtype from settings list in get_settings()
- Remove ihc_subtype argument from get_settings() call in update_files()

All 410 tests pass.

README.md

@@ -27,6 +27,11 @@ Mosaic is a deep learning model designed for predicting cancer subtypes and biom
 - [Output Files](#output-files)
 - [Examples](#examples)
 - [Advanced Usage](#advanced-usage)
+- [User Storage Management (HF Spaces)](#user-storage-management-hf-spaces)
+  - [My Files Tab](#my-files-tab)
+  - [My Results Tab](#my-results-tab)
+  - [Storage Quotas](#storage-quotas)
+  - [Local Debug Mode](#local-debug-mode)
 - [CSV File Format](#csv-file-format)
 - [Cancer Subtypes](#cancer-subtypes)
 - [Troubleshooting](#troubleshooting)
@@ -330,6 +335,116 @@ mosaic --debug
 
 This will create a `debug.log` file with detailed information about the processing steps.
 
+## User Storage Management (HF Spaces)
+
+When running Mosaic on HuggingFace Spaces, logged-in users have access to ephemeral file storage for uploaded slides and analysis results. This feature allows you to:
+
+- **Re-analyze slides** with different settings without re-uploading
+- **View previous analysis results** from past sessions
+- **Download results** at any time during your session
+
+**Important**: All stored files are **ephemeral** and will be deleted when the HuggingFace Spaces instance restarts. This typically happens during updates or when the instance is idle for extended periods.
+
+### My Files Tab
+
+The **My Files** tab (visible only when logged in) provides access to your uploaded slides:
+
+**Features:**
+- **Storage usage display**: Shows current usage vs. quota (e.g., "2.3 GB / 5 GB")
+- **Color-coded warnings**:
+  - 💾 Normal: < 80% quota used
+  - ⚠️ Warning: 80-99% quota used (delete old files to free space)
+  - ⛔ Error: ≥ 100% quota exceeded (upload blocked until space freed)
+- **File browser**: View all uploaded slides with:
+  - Slide ID (unique identifier)
+  - Original filename
+  - File size
+  - Upload date
+  - Number of analyses performed
+- **File actions**:
+  - **Download**: Download original slide file
+  - **Delete**: Remove slide and all associated analysis results
+  - **Refresh**: Update file list
+
+**Typical workflow:**
+1. Upload slides via main analysis tab
+2. Review uploaded files in My Files tab
+3. Delete old slides when approaching quota limit
+
+### My Results Tab
+
+The **My Results** tab (visible only when logged in) displays all analysis results from your session:
+
+**Features:**
+- **Results browser**: View all analyses with:
+  - Analysis ID (unique identifier)
+  - Slide name
+  - Analysis date/time
+  - Predicted cancer subtype
+  - Analysis settings (sex, tissue site, site type)
+- **Result viewer**: Select an analysis to view:
+  - Full metadata (settings, timestamps)
+  - Tissue segmentation mask (PNG)
+  - Aeon predictions (top cancer subtypes with confidence scores)
+  - Paladin biomarker predictions (if applicable)
+- **Result actions**:
+  - **View**: Display full analysis details
+  - **Download ZIP**: Download all results as a ZIP file
+  - **Delete**: Remove specific analysis result
+  - **Refresh**: Update results list
+
+**Download ZIP contents:**
+```
+{analysis_id}.zip
+├── metadata.json          # Analysis settings and timestamps
+├── slide_mask.png         # Tissue segmentation visualization
+├── {analysis_id}_aeon_results.csv      # Cancer subtype predictions
+└── {analysis_id}_paladin_results.csv   # Biomarker predictions (if available)
+```
+
+### Storage Quotas
+
+**Per-user quota**: 5 GB (default)
+
+This limit is enforced to prevent disk exhaustion on shared HuggingFace Spaces instances. When you approach or exceed your quota:
+
+1. **Automatic cleanup**: Oldest files are deleted automatically (FIFO - First In, First Out)
+2. **Manual cleanup**: You can delete files manually via the My Files tab
+3. **Upload blocking**: New uploads are blocked at 100% quota until space is freed
+
+**Typical storage usage:**
+- Small WSI (biopsy): 100-300 MB
+- Medium WSI (tissue section): 500 MB - 1 GB
+- Large WSI (whole tissue): 1-2 GB
+- Analysis results: ~1-2 MB each (negligible)
+
+**Example**: With a 5 GB quota, you can store approximately **5-10 slides** concurrently.
+
+### Local Debug Mode
+
+When running Mosaic **locally** (not on HuggingFace Spaces), the My Files and My Results tabs are still available for debugging:
+
+- All files are stored under a **universal "local_user"** username
+- Storage path: `/tmp/mosaic_user_data/local_user/`
+- UI shows **🔧 [Local Debug Mode]** indicator
+- Files are still ephemeral (cleared on system reboot)
+- No authentication required
+
+This mode is useful for:
+- Testing the storage feature locally
+- Debugging upload/result workflows
+- Development and testing
+
+**Enable local debug mode:**
+```bash
+# Simply run locally (not on HuggingFace Spaces)
+make run-ui
+# or
+mosaic
+```
+
+The tabs will automatically detect local mode and show the debug indicator.
+
 ## CSV File Format
 
 When processing multiple slides using the `--slide-csv` option, the CSV file must contain the following columns:

src/mosaic/gradio_app.py

@@ -312,7 +312,7 @@ def main():
                     args.sex,
                     args.tissue_site,
                     args.cancer_subtype,
-                    args.ihc_subtype,
+                    # args.ihc_subtype,  # Not yet in use
                     args.segmentation_config,
                 ]
             ],

src/mosaic/ui/app.py

@@ -189,6 +189,7 @@ def analyze_slides(
     ihc_subtype,
     seg_config,
     user_dir,
+    slide_ids=None,  # Mapping from filename to slide_id
     progress=gr.Progress(track_tqdm=True),
     request: gr.Request = None,
     profile: Optional[gr.OAuthProfile] = None,
@@ -507,6 +508,63 @@ def analyze_slides(
                             f"Results are still valid but won't be cached for future use."
                         )
 
+            # Save results for logged-in users (best-effort, non-blocking)
+            # On HF Spaces: only for logged-in users
+            # Locally: always save for 'local_user' for debugging
+            should_save_results = False
+            save_username = None
+
+            if IS_HF_SPACES:
+                if user_info.is_logged_in and user_info.username:
+                    should_save_results = True
+                    save_username = user_info.username
+            else:
+                # Local mode - always save for debugging
+                from mosaic.ui.user_tabs import LOCAL_DEBUG_USERNAME
+
+                should_save_results = True
+                save_username = LOCAL_DEBUG_USERNAME
+
+            if should_save_results and save_username:
+                try:
+                    from mosaic.user_results import (
+                        save_analysis_results as save_user_results,
+                    )
+
+                    # Prepare settings dict for metadata
+                    settings_dict = {
+                        "seg_config": row["Segmentation Config"],
+                        "site_type": row["Site Type"],
+                        "sex": row["Sex"],
+                        "tissue_site": row.get("Tissue Site", "Unknown"),
+                        "cancer_subtype": row["Cancer Subtype"],
+                        # "ihc_subtype": row.get("IHC Subtype", ""),  # Not yet in use
+                    }
+
+                    # Use analysis_id + slide index for unique ID per slide
+                    slide_analysis_id = f"{analysis_id}_{idx}"
+
+                    # Get slide_id from tracking (if available)
+                    file_slide_id = ""
+                    if slide_ids and slide_name in slide_ids:
+                        file_slide_id = slide_ids[slide_name]
+
+                    save_user_results(
+                        username=save_username,
+                        analysis_id=slide_analysis_id,
+                        slide_id=file_slide_id,
+                        slide_name=slide_name,
+                        settings=settings_dict,
+                        aeon_results=aeon_results,
+                        paladin_results=paladin_results,
+                        slide_mask=slide_mask,
+                    )
+                    logger.debug(
+                        f"Saved results for user {save_username}, slide {slide_name}"
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to save user results (non-fatal): {e}")
+
             if slide_mask is not None:
                 mask_filename = f"{Path(slide_name).stem}_mask.png"
                 saved = _save_mask_as_png(slide_mask, mask_filename)
@@ -679,6 +737,9 @@ def launch_gradio(server_name, server_port, share):
 
     with gr.Blocks(title="Mosaic") as demo:
         user_dir_state = gr.State(None)
+        slide_ids_state = gr.State(
+            {}
+        )  # Maps slide filename to slide_id for user storage
 
         # Add login button for OAuth (only active on HF Spaces)
         gr.LoginButton()
@@ -879,6 +940,24 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                     file_count="multiple",
                 )
 
+                # Storage usage indicator (shown for logged-in users or local mode)
+                storage_usage_warning = gr.Markdown(visible=False)
+
+                # Analyze Existing File option (shown for logged-in users or local mode)
+                with gr.Row(visible=False) as existing_file_row:
+                    gr.Markdown("**Or select an existing slide:**")
+                    existing_slides_dropdown = gr.Dropdown(
+                        label="Previously Uploaded Slides",
+                        choices=[],
+                        value=None,
+                        interactive=True,
+                        multiselect=True,
+                        info="Select one or more slides you've already uploaded to re-analyze",
+                    )
+                    refresh_existing_btn = gr.Button(
+                        "🔄 Refresh List", size="sm", variant="secondary"
+                    )
+
                 # TCGA fetch components (hidden by default)
                 with gr.Group(visible=False) as tcga_input_group:
                     tcga_id_input = gr.Textbox(
@@ -1002,7 +1081,7 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                 )
 
         def get_settings(
-            files, site_type, sex, tissue_site, cancer_subtype, ihc_subtype, seg_config
+            files, site_type, sex, tissue_site, cancer_subtype, seg_config
         ):
             """Generate initial settings DataFrame from uploaded files and dropdown values."""
             if files is None:
@@ -1018,7 +1097,6 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                         sex if sex is not None else "",
                         tissue_site,
                         cancer_subtype,
-                        ihc_subtype,
                         seg_config,
                     ]
                 )
@@ -1062,6 +1140,148 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                     gr.File(visible=False),
                 )
 
+        # Load storage usage and show warnings
+        def load_storage_usage(request: gr.Request = None):
+            """Load and display storage usage with warnings."""
+            from mosaic.ui.user_tabs import _get_username
+
+            username, is_local = _get_username(request)
+
+            if not username:
+                # Not logged in on HF Spaces - hide storage info
+                return gr.Markdown(visible=False), gr.Row(visible=False)
+
+            try:
+                from mosaic.user_storage import get_storage_usage
+
+                usage = get_storage_usage(username)
+                quota_gb = usage.quota_bytes / (1024**3)
+                used_gb = usage.total_bytes / (1024**3)
+                percent = (
+                    (usage.total_bytes / usage.quota_bytes * 100)
+                    if usage.quota_bytes > 0
+                    else 0
+                )
+
+                mode_indicator = " 🔧 [Local Debug]" if is_local else ""
+
+                # Build warning message
+                if percent >= 100:
+                    warning_md = (
+                        f"⛔ **Storage quota exceeded!** {used_gb:.2f} GB / {quota_gb:.0f} GB "
+                        f"({percent:.0f}%){mode_indicator}\n\n"
+                        f"Delete old files from the **My Files** tab before uploading."
+                    )
+                    warning_color = "red"
+                elif percent >= 80:
+                    warning_md = (
+                        f"⚠️ **Storage nearly full:** {used_gb:.2f} GB / {quota_gb:.0f} GB "
+                        f"({percent:.0f}%){mode_indicator}\n\n"
+                        f"Consider deleting old files from the **My Files** tab."
+                    )
+                    warning_color = "orange"
+                else:
+                    warning_md = (
+                        f"💾 **Storage:** {used_gb:.2f} GB / {quota_gb:.0f} GB "
+                        f"({percent:.0f}%) | {usage.file_count} files{mode_indicator}"
+                    )
+                    warning_color = "gray"
+
+                return gr.Markdown(value=warning_md, visible=True), gr.Row(visible=True)
+
+            except Exception as e:
+                logger.error(f"Failed to load storage usage: {e}")
+                return gr.Markdown(visible=False), gr.Row(visible=False)
+
+        # Load list of existing slides for re-analysis
+        def load_existing_slides(request: gr.Request = None):
+            """Load dropdown with user's existing slides."""
+            from mosaic.ui.user_tabs import _get_username
+
+            username, _ = _get_username(request)
+
+            if not username:
+                return gr.Dropdown(choices=[], value=None)
+
+            try:
+                from mosaic.user_storage import list_user_slides
+
+                slides = list_user_slides(username)
+
+                if not slides:
+                    return gr.Dropdown(
+                        choices=[], value=None, info="No slides uploaded yet"
+                    )
+
+                # Create dropdown choices: display name → slide_id
+                choices = [
+                    (
+                        f"{slide.original_filename} ({slide.size_bytes / (1024**2):.1f} MB)",
+                        slide.slide_id,
+                    )
+                    for slide in slides
+                ]
+
+                return gr.Dropdown(
+                    choices=choices,
+                    value=None,
+                    info=f"{len(slides)} slide(s) available for re-analysis",
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to load existing slides: {e}")
+                return gr.Dropdown(choices=[], value=None)
+
+        # Handle slide upload and save to user storage
+        def handle_slide_upload(files, slide_ids, request: gr.Request = None):
+            """Save uploaded slides to user storage and track slide IDs."""
+            if not files:
+                return files, slide_ids or {}
+
+            # Determine username
+            if IS_HF_SPACES:
+                if not request or not request.username:
+                    # Not logged in on HF Spaces - don't save
+                    return files, slide_ids or {}
+                username = request.username
+            else:
+                # Local mode - always use local_user for debugging
+                from mosaic.ui.user_tabs import LOCAL_DEBUG_USERNAME
+
+                username = LOCAL_DEBUG_USERNAME
+
+            try:
+                from mosaic.user_storage import save_uploaded_slide
+
+                new_slide_ids = slide_ids.copy() if slide_ids else {}
+
+                for file in files:
+                    try:
+                        # Save slide to user storage
+                        slide_id, _ = save_uploaded_slide(username, file)
+
+                        # Track mapping from filename to slide_id
+                        filename = (
+                            Path(file.name).name if hasattr(file, "name") else str(file)
+                        )
+                        new_slide_ids[filename] = slide_id
+
+                        logger.info(
+                            f"Saved slide {filename} with ID {slide_id} for user {username}"
+                        )
+                    except Exception as e:
+                        # Best effort - don't fail upload if storage fails
+                        logger.warning(
+                            f"Failed to save slide {file} to user storage: {e}"
+                        )
+
+                return files, new_slide_ids
+
+            except Exception as e:
+                logger.error(f"Error in slide upload handler: {e}")
+                # Don't fail the upload, just log the error
+                return files, slide_ids or {}
+
         # Handle TCGA slide fetch
         def fetch_tcga_slide(tcga_id, seg_config, progress=gr.Progress()):
             """Fetch a slide from TCGA and pre-fill metadata."""
@@ -1191,6 +1411,97 @@ This tool is for research purposes only and not approved for clinical diagnosis.
         )
 
         # Handle file uploads - regenerate entire settings table
+        # Save uploaded slides to user storage (HF Spaces only)
+        input_slides.upload(
+            handle_slide_upload,
+            inputs=[input_slides, slide_ids_state],
+            outputs=[input_slides, slide_ids_state],
+        ).then(
+            # Refresh storage usage after upload
+            load_storage_usage,
+            inputs=None,
+            outputs=[storage_usage_warning, existing_file_row],
+        ).then(
+            # Refresh existing slides list after upload
+            load_existing_slides,
+            inputs=None,
+            outputs=[existing_slides_dropdown],
+        )
+
+        # Refresh existing slides dropdown
+        refresh_existing_btn.click(
+            load_existing_slides,
+            inputs=None,
+            outputs=[existing_slides_dropdown],
+        )
+
+        # Handle selection of existing slide(s) for re-analysis
+        def select_existing_slide(slide_ids, request: gr.Request = None):
+            """When user selects existing slide(s), load them for analysis.
+
+            Args:
+                slide_ids: Single slide_id (str) or list of slide_ids (multiselect)
+                request: Gradio request object
+
+            Returns:
+                gr.File update with selected slide(s)
+            """
+            if not slide_ids:
+                return None
+
+            # Handle both single selection and multiselect
+            if isinstance(slide_ids, str):
+                slide_ids = [slide_ids]
+
+            from mosaic.ui.user_tabs import _get_username
+
+            username, _ = _get_username(request)
+            if not username:
+                return None
+
+            try:
+                from mosaic.user_storage import get_slide_path, _load_slide_metadata
+
+                metadata = _load_slide_metadata(username)
+                slide_paths = []
+
+                for slide_id in slide_ids:
+                    slide_path = get_slide_path(username, slide_id)
+                    if slide_path is None:
+                        logger.warning(
+                            f"Slide {slide_id} not found for user {username}"
+                        )
+                        continue
+
+                    # Create a symlink with the original filename so the File
+                    # component displays the real name instead of the UUID storage name
+                    if slide_id in metadata:
+                        original_name = metadata[slide_id].original_filename
+                        if slide_path.name != original_name:
+                            tmp_dir = Path(tempfile.mkdtemp(prefix="mosaic_slide_"))
+                            symlink_path = tmp_dir / original_name
+                            symlink_path.symlink_to(slide_path)
+                            slide_paths.append(str(symlink_path))
+                        else:
+                            slide_paths.append(str(slide_path))
+                    else:
+                        slide_paths.append(str(slide_path))
+
+                if not slide_paths:
+                    return None
+
+                return gr.File(value=slide_paths)
+
+            except Exception as e:
+                logger.error(f"Failed to load existing slides {slide_ids}: {e}")
+                return None
+
+        existing_slides_dropdown.change(
+            select_existing_slide,
+            inputs=[existing_slides_dropdown],
+            outputs=[input_slides],
+        )
+
         @input_slides.change(
             inputs=[
                 input_slides,
@@ -1216,7 +1527,6 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                 sex,
                 tissue_site,
                 cancer_subtype,
-                ihc_subtype,
                 seg_config,
             )
             # if settings_df is not None:
@@ -1326,6 +1636,7 @@ This tool is for research purposes only and not approved for clinical diagnosis.
             ihc_subtype,
             seg_config,
             user_dir,
+            slide_ids,
             progress=gr.Progress(track_tqdm=True),
             request: gr.Request = None,
             profile: Optional[gr.OAuthProfile] = None,
@@ -1371,6 +1682,7 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                 ihc_subtype,
                 seg_config,
                 user_dir,
+                slide_ids=slide_ids,
                 progress=progress,
                 request=request,
                 profile=profile,
@@ -1390,6 +1702,7 @@ This tool is for research purposes only and not approved for clinical diagnosis.
                 ihc_subtype_dropdown,
                 seg_config_dropdown,
                 user_dir_state,
+                slide_ids_state,
             ],
             outputs=[
                 settings_input,
@@ -1456,6 +1769,70 @@ This tool is for research purposes only and not approved for clinical diagnosis.
             outputs=[user_dir_state],
         )
 
+        # Load storage usage on page load
+        demo.load(
+            load_storage_usage,
+            inputs=None,
+            outputs=[storage_usage_warning, existing_file_row],
+        )
+
+        # Load existing slides dropdown on page load
+        demo.load(
+            load_existing_slides,
+            inputs=None,
+            outputs=[existing_slides_dropdown],
+        )
+
+        # Add My Files and My Results tabs for user storage
+        # On HF Spaces: visible for logged-in users
+        # Locally: always visible with "local_user" for debugging
+        gr.Markdown("---")
+        if IS_HF_SPACES:
+            gr.Markdown("## User Storage (Logged-In Users Only)")
+            gr.Markdown(
+                "The tabs below are only accessible to logged-in users. "
+                "Upload and view your slides and analysis results."
+            )
+        else:
+            gr.Markdown("## User Storage (Local Debug Mode)")
+            gr.Markdown(
+                "🔧 **Debug Mode**: Files stored as user 'local_user' in `/tmp/mosaic_user_data/local_user/`"
+            )
+
+        with gr.Tabs():
+            with gr.Tab("My Files"):
+                from mosaic.ui.user_tabs import create_my_files_tab
+
+                my_files_components = create_my_files_tab()
+
+                # Load files on demo load
+                demo.load(
+                    my_files_components["load_files"],
+                    inputs=None,
+                    outputs=[
+                        my_files_components["storage_usage"],
+                        my_files_components["files_table"],
+                        my_files_components["file_action_status"],
+                        my_files_components["slide_download_file"],
+                    ],
+                )
+
+            with gr.Tab("My Results"):
+                from mosaic.ui.user_tabs import create_my_results_tab
+
+                my_results_components = create_my_results_tab()
+
+                # Load results on demo load
+                demo.load(
+                    my_results_components["load_results"],
+                    inputs=None,
+                    outputs=[
+                        my_results_components["results_table"],
+                        my_results_components["result_action_status"],
+                        my_results_components["result_download_file"],
+                    ],
+                )
+
     # Use hardware-specific concurrency limit
     # T4 GPUs (16GB) can only handle one analysis at a time to prevent OOM
     # Higher-memory GPUs and ZeroGPU can handle multiple concurrent analyses

src/mosaic/ui/user_tabs.py

@@ -0,0 +1,600 @@
+"""My Files and My Results tabs for HuggingFace Spaces user storage.
+
+This module provides UI components for browsing and managing user-uploaded
+slides and analysis results in ephemeral storage.
+"""
+
+import gradio as gr
+import pandas as pd
+from loguru import logger
+from pathlib import Path
+
+from mosaic.hardware import IS_HF_SPACES
+from mosaic.user_storage import (
+    list_user_slides,
+    get_storage_usage,
+    delete_user_slide,
+    get_slide_path,
+    find_slide_by_name,
+    DEFAULT_QUOTA_BYTES,
+)
+from mosaic.user_results import (
+    list_user_results,
+    load_analysis_results,
+    delete_analysis_results,
+    create_results_zip,
+)
+
+# Local debug username for non-HF Spaces environments
+LOCAL_DEBUG_USERNAME = "local_user"
+
+
+def _get_username(request: gr.Request) -> tuple[str, bool]:
+    """Get username for storage operations.
+
+    Returns:
+        Tuple of (username, is_local_mode)
+        - In HF Spaces: (request.username, False) if logged in
+        - Locally: (LOCAL_DEBUG_USERNAME, True)
+        - HF Spaces not logged in: (None, False)
+    """
+    if IS_HF_SPACES:
+        # HF Spaces - use OAuth username if available
+        if request and request.username:
+            return (request.username, False)
+        return (None, False)
+    else:
+        # Local mode - use debug username
+        return (LOCAL_DEBUG_USERNAME, True)
+
+
+def create_my_files_tab():
+    """Create the My Files tab UI for managing uploaded slides.
+
+    Returns:
+        Dictionary of UI components for event handlers
+    """
+    with gr.Column():
+        gr.Markdown("### My Uploaded Files")
+        gr.Markdown(
+            "View and manage your uploaded slides. Files are stored temporarily "
+            "and cleared when the instance restarts."
+        )
+
+        # Storage usage indicator
+        storage_usage_md = gr.Markdown("**Storage:** Loading...")
+
+        # Files table
+        files_table = gr.Dataframe(
+            headers=["Slide ID", "Filename", "Size (MB)", "Upload Date", "# Analyses"],
+            datatype=["str", "str", "number", "str", "number"],
+            label="Uploaded Slides",
+            interactive=False,
+            column_widths=["3fr", "3fr", "1fr", "2fr", "1fr"],
+        )
+
+        # Action buttons
+        with gr.Row():
+            refresh_files_btn = gr.Button("Refresh", variant="secondary")
+            selected_slide_id = gr.Textbox(
+                label="Selected Slide ID",
+                placeholder="Click a row in the table to select a slide",
+            )
+
+        with gr.Row():
+            download_slide_btn = gr.Button("Download Original", variant="secondary")
+            delete_slide_btn = gr.Button("Delete Slide", variant="stop")
+
+        # Status messages
+        file_action_status = gr.Textbox(
+            label="Status",
+            interactive=False,
+            visible=False,
+        )
+
+        # Download output
+        slide_download_file = gr.File(label="Download", visible=False)
+
+        def load_files(request: gr.Request):
+            """Load user's uploaded files."""
+            username, is_local = _get_username(request)
+
+            if not username:
+                return (
+                    "**Storage:** Not logged in (login required on HF Spaces)",
+                    [],
+                    gr.Textbox(visible=False),
+                    gr.File(visible=False),
+                )
+
+            try:
+                # Add debug indicator for local mode
+                mode_indicator = " 🔧 **[Local Debug Mode]**" if is_local else ""
+
+                # Get storage usage
+                usage = get_storage_usage(username)
+                quota_gb = usage.quota_bytes / (1024**3)
+                used_gb = usage.total_bytes / (1024**3)
+                percent = (
+                    (usage.total_bytes / usage.quota_bytes * 100)
+                    if usage.quota_bytes > 0
+                    else 0
+                )
+
+                storage_md = (
+                    f"**Storage:** {used_gb:.2f} GB / {quota_gb:.0f} GB ({percent:.1f}%) | "
+                    f"{usage.file_count} files{mode_indicator}"
+                )
+
+                if percent > 80:
+                    storage_md += " ⚠️ **Nearly full!**"
+
+                # Get files list
+                slides = list_user_slides(username)
+
+                if not slides:
+                    return (
+                        storage_md,
+                        [],
+                        gr.Textbox(visible=False),
+                        gr.File(visible=False),
+                    )
+
+                # Get result counts
+                from mosaic.user_results import list_user_results as list_results
+
+                files_data = []
+                for slide in slides:
+                    # Count results for this slide
+                    results = list_results(username, slide_id=slide.slide_id)
+
+                    files_data.append(
+                        [
+                            Path(slide.original_filename).stem,
+                            slide.original_filename,
+                            round(slide.size_bytes / (1024**2), 2),  # Convert to MB
+                            slide.upload_time[:19],  # Truncate to datetime
+                            len(results),
+                        ]
+                    )
+
+                return (
+                    storage_md,
+                    files_data,
+                    gr.Textbox(visible=False),
+                    gr.File(visible=False),
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to load user files: {e}")
+                return (
+                    "**Storage:** Error loading files",
+                    [],
+                    gr.Textbox(value=f"Error: {str(e)}", visible=True),
+                    gr.File(visible=False),
+                )
+
+        def download_slide(slide_id_or_name, request: gr.Request):
+            """Download the original slide file."""
+            username, _ = _get_username(request)
+
+            if not username or not slide_id_or_name:
+                return gr.File(visible=False), gr.Textbox(
+                    value="Not logged in or no slide selected", visible=True
+                )
+
+            try:
+                # Resolve name/stem to UUID if needed
+                resolved_id = find_slide_by_name(username, slide_id_or_name)
+                if resolved_id is None:
+                    return gr.File(visible=False), gr.Textbox(
+                        value="Slide not found", visible=True
+                    )
+
+                slide_path = get_slide_path(username, resolved_id)
+
+                if slide_path is None:
+                    return gr.File(visible=False), gr.Textbox(
+                        value="Slide not found", visible=True
+                    )
+
+                return gr.File(value=str(slide_path), visible=True), gr.Textbox(
+                    value="Download ready", visible=True
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to download slide {slide_id_or_name}: {e}")
+                return gr.File(visible=False), gr.Textbox(
+                    value=f"Error: {str(e)}", visible=True
+                )
+
+        def delete_slide(slide_id_or_name, request: gr.Request):
+            """Delete a slide and all associated results."""
+            username, _ = _get_username(request)
+
+            if not username or not slide_id_or_name:
+                return gr.Textbox(
+                    value="Not logged in or no slide selected", visible=True
+                )
+
+            try:
+                # Resolve name/stem to UUID if needed
+                resolved_id = find_slide_by_name(username, slide_id_or_name)
+                if resolved_id is None:
+                    return gr.Textbox(value="Slide not found", visible=True)
+
+                success = delete_user_slide(username, resolved_id)
+
+                if success:
+                    return gr.Textbox(
+                        value=f"Deleted slide '{slide_id_or_name}' and all associated results",
+                        visible=True,
+                    )
+                else:
+                    return gr.Textbox(value="Slide not found", visible=True)
+
+            except Exception as e:
+                logger.error(f"Failed to delete slide {slide_id_or_name}: {e}")
+                return gr.Textbox(value=f"Error: {str(e)}", visible=True)
+
+        # Wire up events
+        refresh_files_btn.click(
+            load_files,
+            inputs=None,
+            outputs=[
+                storage_usage_md,
+                files_table,
+                file_action_status,
+                slide_download_file,
+            ],
+        )
+
+        download_slide_btn.click(
+            download_slide,
+            inputs=[selected_slide_id],
+            outputs=[slide_download_file, file_action_status],
+        )
+
+        delete_slide_btn.click(
+            delete_slide,
+            inputs=[selected_slide_id],
+            outputs=[file_action_status],
+        ).then(
+            load_files,  # Refresh after delete
+            inputs=None,
+            outputs=[
+                storage_usage_md,
+                files_table,
+                file_action_status,
+                slide_download_file,
+            ],
+        )
+
+        def on_file_row_select(evt: gr.SelectData, table_data):
+            """Auto-fill slide ID when a row is clicked."""
+            if table_data is not None and len(table_data) > 0:
+                row = evt.index[0]
+                return str(table_data.iloc[row, 0])  # Slide ID column
+            return ""
+
+        files_table.select(
+            on_file_row_select,
+            inputs=[files_table],
+            outputs=[selected_slide_id],
+        )
+
+    return {
+        "storage_usage": storage_usage_md,
+        "files_table": files_table,
+        "refresh_btn": refresh_files_btn,
+        "load_files": load_files,
+        "file_action_status": file_action_status,
+        "slide_download_file": slide_download_file,
+    }
+
+
+def create_my_results_tab():
+    """Create the My Results tab UI for browsing analysis results.
+
+    Returns:
+        Dictionary of UI components for event handlers
+    """
+    with gr.Column():
+        gr.Markdown("### My Analysis Results")
+        gr.Markdown(
+            "View and download results from previous analyses. "
+            "Results are stored temporarily and cleared when the instance restarts."
+        )
+
+        # Results table
+        results_table = gr.Dataframe(
+            headers=["Analysis ID", "Slide Name", "Date", "Cancer Subtype", "Settings"],
+            datatype=["str", "str", "str", "str", "str"],
+            label="Analysis Results",
+            interactive=False,
+        )
+
+        # Action buttons
+        with gr.Row():
+            refresh_results_btn = gr.Button("Refresh", variant="secondary")
+            selected_analysis_id = gr.Textbox(
+                label="Selected Analysis ID",
+                placeholder="Click a row in the table to select a result",
+            )
+
+        with gr.Row():
+            view_result_btn = gr.Button("View Details", variant="secondary")
+            download_zip_btn = gr.Button("Download ZIP", variant="primary")
+            delete_result_btn = gr.Button("Delete Result", variant="stop")
+
+        # Result detail section (hidden by default)
+        with gr.Accordion("Result Details", open=False) as result_details:
+            result_metadata_md = gr.Markdown("No result selected")
+            result_mask_img = gr.Image(label="Tissue Segmentation Mask", visible=False)
+            result_aeon_df = gr.Dataframe(
+                label="Cancer Subtype Predictions", visible=False
+            )
+            result_paladin_df = gr.Dataframe(
+                label="Biomarker Predictions", visible=False
+            )
+
+        # Status and download
+        result_action_status = gr.Textbox(
+            label="Status", interactive=False, visible=False
+        )
+        result_download_file = gr.File(label="Download", visible=False)
+
+        def load_results(request: gr.Request):
+            """Load user's analysis results."""
+            username, _ = _get_username(request)
+
+            if not username:
+                return [], gr.Textbox(visible=False), gr.File(visible=False)
+
+            try:
+                results = list_user_results(username)
+
+                if not results:
+                    return [], gr.Textbox(visible=False), gr.File(visible=False)
+
+                results_data = []
+                for result in results:
+                    # Format settings as short string
+                    settings_str = f"{result.settings.get('site_type', 'N/A')} | {result.settings.get('sex', 'N/A')}"
+
+                    results_data.append(
+                        [
+                            result.analysis_id,
+                            result.slide_name,
+                            result.timestamp[:19],  # Truncate to datetime
+                            result.cancer_subtype or "Unknown",
+                            settings_str,
+                        ]
+                    )
+
+                return results_data, gr.Textbox(visible=False), gr.File(visible=False)
+
+            except Exception as e:
+                logger.error(f"Failed to load user results: {e}")
+                return (
+                    [],
+                    gr.Textbox(value=f"Error: {str(e)}", visible=True),
+                    gr.File(visible=False),
+                )
+
+        def view_result_details(analysis_id, request: gr.Request):
+            """Load and display result details."""
+            username, _ = _get_username(request)
+
+            if not username or not analysis_id:
+                return (
+                    gr.Accordion(open=False),
+                    "No result selected",
+                    gr.Image(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.Textbox(visible=False),
+                )
+
+            try:
+                loaded = load_analysis_results(username, analysis_id)
+
+                if loaded is None:
+                    return (
+                        gr.Accordion(open=False),
+                        "Result not found",
+                        gr.Image(visible=False),
+                        gr.Dataframe(visible=False),
+                        gr.Dataframe(visible=False),
+                        gr.Textbox(value="Result not found", visible=True),
+                    )
+
+                metadata, mask, aeon_df, paladin_df = loaded
+
+                # Format aeon results with human-readable cancer subtype names
+                if aeon_df is not None and len(aeon_df) > 0:
+                    from mosaic.ui.utils import get_oncotree_code_name
+
+                    aeon_df = aeon_df.reset_index()
+                    # Rename index column to "Cancer Subtype" if needed
+                    if aeon_df.columns[0] != "Cancer Subtype":
+                        aeon_df = aeon_df.rename(
+                            columns={aeon_df.columns[0]: "Cancer Subtype"}
+                        )
+                    # Add human-readable names
+                    aeon_df["Cancer Subtype"] = [
+                        f"{get_oncotree_code_name(code)} ({code})"
+                        for code in aeon_df["Cancer Subtype"]
+                    ]
+                    # Round confidence scores
+                    for col in aeon_df.columns[1:]:
+                        aeon_df[col] = pd.to_numeric(
+                            aeon_df[col], errors="coerce"
+                        ).round(3)
+
+                # Round paladin scores
+                if paladin_df is not None and "Score" in paladin_df.columns:
+                    paladin_df["Score"] = pd.to_numeric(
+                        paladin_df["Score"], errors="coerce"
+                    ).round(3)
+
+                # Format metadata
+                settings_md = "### Analysis Settings\n\n"
+                for key, value in metadata.settings.items():
+                    settings_md += f"- **{key}**: {value}\n"
+
+                # Format cancer subtype with readable name
+                subtype_display = metadata.cancer_subtype or "Unknown"
+                if subtype_display and subtype_display != "Unknown":
+                    from mosaic.ui.utils import get_oncotree_code_name
+
+                    name = get_oncotree_code_name(subtype_display)
+                    if name and name != subtype_display:
+                        subtype_display = f"{name} ({subtype_display})"
+
+                metadata_text = (
+                    f"### {metadata.slide_name}\n\n"
+                    f"**Analysis ID:** {metadata.analysis_id}\n\n"
+                    f"**Date:** {metadata.timestamp[:19]}\n\n"
+                    f"**Predicted Subtype:** {subtype_display}\n\n"
+                    f"{settings_md}"
+                )
+
+                return (
+                    gr.Accordion(open=True),
+                    metadata_text,
+                    (
+                        gr.Image(value=mask, visible=True)
+                        if mask
+                        else gr.Image(visible=False)
+                    ),
+                    (
+                        gr.Dataframe(value=aeon_df, visible=True)
+                        if aeon_df is not None
+                        else gr.Dataframe(visible=False)
+                    ),
+                    (
+                        gr.Dataframe(value=paladin_df, visible=True)
+                        if paladin_df is not None
+                        else gr.Dataframe(visible=False)
+                    ),
+                    gr.Textbox(visible=False),
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to load result details {analysis_id}: {e}")
+                return (
+                    gr.Accordion(open=False),
+                    "Error loading result",
+                    gr.Image(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.Textbox(value=f"Error: {str(e)}", visible=True),
+                )
+
+        def download_result_zip(analysis_id, request: gr.Request):
+            """Create and download ZIP of result files."""
+            username, _ = _get_username(request)
+
+            if not username or not analysis_id:
+                return gr.File(visible=False), gr.Textbox(
+                    value="Not logged in or no result selected", visible=True
+                )
+
+            try:
+                zip_path = create_results_zip(username, analysis_id)
+
+                if zip_path is None:
+                    return gr.File(visible=False), gr.Textbox(
+                        value="Result not found", visible=True
+                    )
+
+                return gr.File(value=str(zip_path), visible=True), gr.Textbox(
+                    value="ZIP ready for download", visible=True
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to create ZIP for {analysis_id}: {e}")
+                return gr.File(visible=False), gr.Textbox(
+                    value=f"Error: {str(e)}", visible=True
+                )
+
+        def delete_result(analysis_id, request: gr.Request):
+            """Delete an analysis result."""
+            username, _ = _get_username(request)
+
+            if not username or not analysis_id:
+                return gr.Textbox(
+                    value="Not logged in or no result selected", visible=True
+                )
+
+            try:
+                success = delete_analysis_results(username, analysis_id)
+
+                if success:
+                    return gr.Textbox(
+                        value=f"Deleted result {analysis_id}", visible=True
+                    )
+                else:
+                    return gr.Textbox(value="Result not found", visible=True)
+
+            except Exception as e:
+                logger.error(f"Failed to delete result {analysis_id}: {e}")
+                return gr.Textbox(value=f"Error: {str(e)}", visible=True)
+
+        # Wire up events
+        refresh_results_btn.click(
+            load_results,
+            inputs=None,
+            outputs=[results_table, result_action_status, result_download_file],
+        )
+
+        view_result_btn.click(
+            view_result_details,
+            inputs=[selected_analysis_id],
+            outputs=[
+                result_details,
+                result_metadata_md,
+                result_mask_img,
+                result_aeon_df,
+                result_paladin_df,
+                result_action_status,
+            ],
+        )
+
+        download_zip_btn.click(
+            download_result_zip,
+            inputs=[selected_analysis_id],
+            outputs=[result_download_file, result_action_status],
+        )
+
+        delete_result_btn.click(
+            delete_result,
+            inputs=[selected_analysis_id],
+            outputs=[result_action_status],
+        ).then(
+            load_results,  # Refresh after delete
+            inputs=None,
+            outputs=[results_table, result_action_status, result_download_file],
+        )
+
+        def on_result_row_select(evt: gr.SelectData, table_data):
+            """Auto-fill analysis ID when a row is clicked."""
+            if table_data is not None and len(table_data) > 0:
+                row = evt.index[0]
+                return str(table_data.iloc[row, 0])  # Analysis ID column
+            return ""
+
+        results_table.select(
+            on_result_row_select,
+            inputs=[results_table],
+            outputs=[selected_analysis_id],
+        )
+
+    return {
+        "results_table": results_table,
+        "refresh_btn": refresh_results_btn,
+        "load_results": load_results,
+        "result_action_status": result_action_status,
+        "result_download_file": result_download_file,
+    }

src/mosaic/ui/utils.py

@@ -27,7 +27,7 @@ SETTINGS_COLUMNS = [
     "Sex",
     "Tissue Site",
     "Cancer Subtype",
-    "IHC Subtype",
+    # "IHC Subtype",  # Not yet in use
     "Segmentation Config",
 ]
 
@@ -154,8 +154,8 @@ def load_settings(slide_csv_path):
         settings_df["Segmentation Config"] = "Biopsy"
     if "Cancer Subtype" not in settings_df.columns:
         settings_df["Cancer Subtype"] = "Unknown"
-    if "IHC Subtype" not in settings_df.columns:
-        settings_df["IHC Subtype"] = ""
+    # if "IHC Subtype" not in settings_df.columns:  # Not yet in use
+    #     settings_df["IHC Subtype"] = ""
     if "Tissue Site" not in settings_df.columns:
         settings_df["Tissue Site"] = "Unknown"
     if not set(SETTINGS_COLUMNS).issubset(settings_df.columns):
@@ -225,19 +225,20 @@ def validate_settings(
                 f"Slide {slide_name}: Unknown tissue site. Valid tissue sites are: {', '.join(tissue_sites)}. "
             )
             settings_df.at[idx, "Tissue Site"] = "Unknown"
-        if (
-            "Breast" not in settings_df.at[idx, "Cancer Subtype"]
-            and row["IHC Subtype"] != ""
-        ):
-            warnings.append(
-                f"Slide {slide_name}: IHC subtype should be empty for non-breast cancer subtypes. "
-            )
-            settings_df.at[idx, "IHC Subtype"] = ""
-        if row["IHC Subtype"] not in IHC_SUBTYPES:
-            warnings.append(
-                f"Slide {slide_name}: Unknown IHC subtype. Valid subtypes are: {', '.join(IHC_SUBTYPES)}. "
-            )
-            settings_df.at[idx, "IHC Subtype"] = ""
+        # IHC Subtype validation - not yet in use
+        # if (
+        #     "Breast" not in settings_df.at[idx, "Cancer Subtype"]
+        #     and row["IHC Subtype"] != ""
+        # ):
+        #     warnings.append(
+        #         f"Slide {slide_name}: IHC subtype should be empty for non-breast cancer subtypes. "
+        #     )
+        #     settings_df.at[idx, "IHC Subtype"] = ""
+        # if row["IHC Subtype"] not in IHC_SUBTYPES:
+        #     warnings.append(
+        #         f"Slide {slide_name}: Unknown IHC subtype. Valid subtypes are: {', '.join(IHC_SUBTYPES)}. "
+        #     )
+        #     settings_df.at[idx, "IHC Subtype"] = ""
         if row["Segmentation Config"] not in ["Biopsy", "Resection", "TCGA"]:
             warnings.append(
                 f"Slide {slide_name}: Unknown segmentation config. Valid configs are: Biopsy, Resection, TCGA. "

src/mosaic/user_results.py

@@ -0,0 +1,328 @@
+"""User analysis results management for HuggingFace Spaces.
+
+This module provides ephemeral storage for analysis results, linked to uploaded
+slides. Results are cleared on instance restart (no persistence).
+
+Storage structure:
+    /tmp/mosaic_user_data/{username}/
+        results/
+            {analysis_id}/
+                metadata.json       # Result metadata
+                slide_mask.png      # Tissue segmentation
+                aeon_results.csv    # Cancer subtype predictions
+                paladin_results.csv # Biomarker predictions
+"""
+
+import json
+import shutil
+import zipfile
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import pandas as pd
+from loguru import logger
+from PIL import Image
+
+from mosaic.user_storage import get_user_storage_dir
+
+
+@dataclass
+class ResultMetadata:
+    """Metadata for an analysis result.
+
+    Attributes:
+        analysis_id: Unique identifier for this analysis
+        slide_id: ID of the slide that was analyzed
+        slide_name: Original slide filename
+        timestamp: ISO timestamp of analysis
+        settings: Dict of analysis settings (site_type, cancer_subtype, etc.)
+        cancer_subtype: Predicted cancer subtype (for quick display)
+    """
+
+    analysis_id: str
+    slide_id: str
+    slide_name: str
+    timestamp: str
+    settings: dict
+    cancer_subtype: Optional[str] = None
+
+
+def _get_results_dir(username: str, analysis_id: str) -> Path:
+    """Get the directory for a specific analysis result.
+
+    Args:
+        username: Username
+        analysis_id: Analysis ID
+
+    Returns:
+        Path to results directory
+    """
+    user_dir = get_user_storage_dir(username)
+    return user_dir / "results" / analysis_id
+
+
+def save_analysis_results(
+    username: str,
+    analysis_id: str,
+    slide_id: str,
+    slide_name: str,
+    settings: dict,
+    aeon_results: Optional[pd.DataFrame],
+    paladin_results: Optional[pd.DataFrame],
+    slide_mask: Optional[Image.Image],
+) -> bool:
+    """Save analysis results for a user.
+
+    Best-effort operation: logs errors but doesn't raise exceptions.
+
+    Args:
+        username: Username
+        analysis_id: Unique analysis ID
+        slide_id: ID of the analyzed slide
+        slide_name: Original slide filename
+        settings: Dict of analysis settings
+        aeon_results: Aeon predictions DataFrame
+        paladin_results: Paladin predictions DataFrame
+        slide_mask: Tissue segmentation mask
+
+    Returns:
+        True if saved successfully, False otherwise
+    """
+    try:
+        results_dir = _get_results_dir(username, analysis_id)
+        results_dir.mkdir(parents=True, exist_ok=True)
+
+        # Extract cancer subtype from aeon results (top prediction)
+        cancer_subtype = None
+        if aeon_results is not None and len(aeon_results) > 0:
+            # Aeon results are sorted by confidence, first row is top prediction
+            cancer_subtype = (
+                aeon_results.index[0] if hasattr(aeon_results, "index") else None
+            )
+
+        # Save metadata
+        metadata = ResultMetadata(
+            analysis_id=analysis_id,
+            slide_id=slide_id,
+            slide_name=slide_name,
+            timestamp=datetime.utcnow().isoformat(),
+            settings=settings,
+            cancer_subtype=cancer_subtype,
+        )
+        metadata_path = results_dir / "metadata.json"
+        with open(metadata_path, "w") as f:
+            json.dump(asdict(metadata), f, indent=2)
+
+        # Save aeon results (with index - "Cancer Subtype")
+        if aeon_results is not None:
+            aeon_path = results_dir / "aeon_results.csv"
+            aeon_results.to_csv(aeon_path, index=True)
+
+        # Save paladin results (no index)
+        if paladin_results is not None:
+            paladin_path = results_dir / "paladin_results.csv"
+            paladin_results.to_csv(paladin_path, index=False)
+
+        # Save slide mask
+        if slide_mask is not None:
+            mask_path = results_dir / "slide_mask.png"
+            slide_mask.save(mask_path)
+
+        logger.info(
+            f"Saved analysis results for user {username}, "
+            f"analysis {analysis_id}, slide {slide_id}"
+        )
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"Failed to save analysis results for user {username}, "
+            f"analysis {analysis_id}: {e}"
+        )
+        return False
+
+
+def load_analysis_results(
+    username: str, analysis_id: str
+) -> Optional[
+    tuple[ResultMetadata, Image.Image | None, pd.DataFrame | None, pd.DataFrame | None]
+]:
+    """Load analysis results for a user.
+
+    Args:
+        username: Username
+        analysis_id: Analysis ID
+
+    Returns:
+        Tuple of (metadata, slide_mask, aeon_results, paladin_results) or None if not found
+    """
+    try:
+        results_dir = _get_results_dir(username, analysis_id)
+        if not results_dir.exists():
+            return None
+
+        # Load metadata
+        metadata_path = results_dir / "metadata.json"
+        if not metadata_path.exists():
+            return None
+
+        with open(metadata_path, "r") as f:
+            metadata = ResultMetadata(**json.load(f))
+
+        # Load mask
+        mask_path = results_dir / "slide_mask.png"
+        slide_mask = Image.open(mask_path) if mask_path.exists() else None
+
+        # Load aeon results (restore index)
+        aeon_path = results_dir / "aeon_results.csv"
+        aeon_results = (
+            pd.read_csv(aeon_path, index_col=0) if aeon_path.exists() else None
+        )
+
+        # Load paladin results
+        paladin_path = results_dir / "paladin_results.csv"
+        paladin_results = pd.read_csv(paladin_path) if paladin_path.exists() else None
+
+        return metadata, slide_mask, aeon_results, paladin_results
+
+    except Exception as e:
+        logger.error(
+            f"Failed to load analysis results for user {username}, "
+            f"analysis {analysis_id}: {e}"
+        )
+        return None
+
+
+def list_user_results(
+    username: str, slide_id: Optional[str] = None
+) -> list[ResultMetadata]:
+    """List all analysis results for a user.
+
+    Returns results sorted by timestamp (newest first).
+
+    Args:
+        username: Username
+        slide_id: Optional slide ID to filter by
+
+    Returns:
+        List of ResultMetadata objects
+    """
+    user_dir = get_user_storage_dir(username)
+    results_base = user_dir / "results"
+
+    if not results_base.exists():
+        return []
+
+    results = []
+    for result_dir in results_base.iterdir():
+        if not result_dir.is_dir():
+            continue
+
+        metadata_path = result_dir / "metadata.json"
+        if not metadata_path.exists():
+            continue
+
+        try:
+            with open(metadata_path, "r") as f:
+                metadata = ResultMetadata(**json.load(f))
+
+            # Filter by slide_id if provided
+            if slide_id is not None and metadata.slide_id != slide_id:
+                continue
+
+            results.append(metadata)
+        except Exception as e:
+            logger.warning(f"Failed to load metadata from {result_dir}: {e}")
+            continue
+
+    # Sort by timestamp, newest first
+    results.sort(key=lambda r: r.timestamp, reverse=True)
+    return results
+
+
+def delete_analysis_results(username: str, analysis_id: str) -> bool:
+    """Delete analysis results.
+
+    Args:
+        username: Username
+        analysis_id: Analysis ID
+
+    Returns:
+        True if deleted successfully, False if not found
+    """
+    try:
+        results_dir = _get_results_dir(username, analysis_id)
+        if not results_dir.exists():
+            return False
+
+        shutil.rmtree(results_dir)
+        logger.info(f"Deleted analysis results {analysis_id} for user {username}")
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"Failed to delete analysis results {analysis_id} for user {username}: {e}"
+        )
+        return False
+
+
+def delete_results_for_slide(username: str, slide_id: str) -> int:
+    """Delete all analysis results for a specific slide.
+
+    Args:
+        username: Username
+        slide_id: Slide ID
+
+    Returns:
+        Number of results deleted
+    """
+    results = list_user_results(username, slide_id=slide_id)
+    deleted_count = 0
+
+    for result in results:
+        if delete_analysis_results(username, result.analysis_id):
+            deleted_count += 1
+
+    if deleted_count > 0:
+        logger.info(
+            f"Deleted {deleted_count} analysis results for slide {slide_id}, "
+            f"user {username}"
+        )
+
+    return deleted_count
+
+
+def create_results_zip(username: str, analysis_id: str) -> Optional[Path]:
+    """Create a ZIP file containing all result files.
+
+    Args:
+        username: Username
+        analysis_id: Analysis ID
+
+    Returns:
+        Path to ZIP file, or None if failed
+    """
+    try:
+        results_dir = _get_results_dir(username, analysis_id)
+        if not results_dir.exists():
+            return None
+
+        # Create ZIP in parent directory
+        zip_path = results_dir.parent / f"{analysis_id}_results.zip"
+
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            # Add all files in results directory
+            for file_path in results_dir.iterdir():
+                if file_path.is_file():
+                    zipf.write(file_path, arcname=file_path.name)
+
+        logger.info(f"Created results ZIP for {analysis_id}, user {username}")
+        return zip_path
+
+    except Exception as e:
+        logger.error(
+            f"Failed to create results ZIP for {analysis_id}, user {username}: {e}"
+        )
+        return None

src/mosaic/user_storage.py

@@ -0,0 +1,447 @@
+"""User storage management for HuggingFace Spaces.
+
+This module provides ephemeral storage for uploaded slide files, enforcing
+per-user quotas and providing cleanup utilities. Storage is cleared on
+instance restart (no persistence).
+
+Storage structure:
+    /tmp/mosaic_user_data/{username}/
+        slides/
+            {slide_id}.{ext}    # Uploaded slide files
+            metadata.json       # Slide metadata
+        storage_info.json       # Usage tracking
+"""
+
+import json
+import os
+import shutil
+import uuid
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+# Default per-user storage quota (5GB)
+DEFAULT_QUOTA_GB = int(os.environ.get("MOSAIC_USER_STORAGE_QUOTA_GB", "5"))
+DEFAULT_QUOTA_BYTES = DEFAULT_QUOTA_GB * 1024 * 1024 * 1024
+
+# Base directory for user storage (ephemeral)
+USER_STORAGE_BASE = Path("/tmp/mosaic_user_data")
+
+
+@dataclass
+class SlideMetadata:
+    """Metadata for an uploaded slide.
+
+    Attributes:
+        slide_id: Unique identifier for the slide
+        original_filename: Original filename when uploaded
+        upload_time: ISO timestamp of upload
+        size_bytes: File size in bytes
+        file_extension: File extension (e.g., '.svs', '.tif')
+    """
+
+    slide_id: str
+    original_filename: str
+    upload_time: str
+    size_bytes: int
+    file_extension: str
+
+
+@dataclass
+class StorageInfo:
+    """Storage usage information for a user.
+
+    Attributes:
+        total_bytes: Total bytes used by all files
+        file_count: Number of slide files stored
+        quota_bytes: Storage quota in bytes
+        last_cleanup: ISO timestamp of last cleanup (or None)
+    """
+
+    total_bytes: int
+    file_count: int
+    quota_bytes: int
+    last_cleanup: Optional[str] = None
+
+
+def get_user_storage_dir(username: str) -> Path:
+    """Get the storage directory for a user.
+
+    Creates the directory structure if it doesn't exist:
+        /tmp/mosaic_user_data/{username}/
+            slides/
+            results/
+
+    Args:
+        username: Username from HF Spaces OAuth
+
+    Returns:
+        Path to user's storage directory
+    """
+    user_dir = USER_STORAGE_BASE / username
+    slides_dir = user_dir / "slides"
+    results_dir = user_dir / "results"
+
+    slides_dir.mkdir(parents=True, exist_ok=True)
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    return user_dir
+
+
+def _load_slide_metadata(username: str) -> dict[str, SlideMetadata]:
+    """Load slide metadata from disk.
+
+    Args:
+        username: Username
+
+    Returns:
+        Dict mapping slide_id to SlideMetadata
+    """
+    user_dir = get_user_storage_dir(username)
+    metadata_path = user_dir / "slides" / "metadata.json"
+
+    if not metadata_path.exists():
+        return {}
+
+    try:
+        with open(metadata_path, "r") as f:
+            data = json.load(f)
+        return {k: SlideMetadata(**v) for k, v in data.items()}
+    except Exception as e:
+        logger.error(f"Failed to load slide metadata for {username}: {e}")
+        return {}
+
+
+def _save_slide_metadata(username: str, metadata: dict[str, SlideMetadata]) -> None:
+    """Save slide metadata to disk.
+
+    Args:
+        username: Username
+        metadata: Dict mapping slide_id to SlideMetadata
+    """
+    user_dir = get_user_storage_dir(username)
+    metadata_path = user_dir / "slides" / "metadata.json"
+
+    try:
+        data = {k: asdict(v) for k, v in metadata.items()}
+        with open(metadata_path, "w") as f:
+            json.dump(data, f, indent=2)
+    except Exception as e:
+        logger.error(f"Failed to save slide metadata for {username}: {e}")
+
+
+def _load_storage_info(username: str) -> StorageInfo:
+    """Load storage info from disk.
+
+    Args:
+        username: Username
+
+    Returns:
+        StorageInfo object
+    """
+    user_dir = get_user_storage_dir(username)
+    info_path = user_dir / "storage_info.json"
+
+    if not info_path.exists():
+        return StorageInfo(total_bytes=0, file_count=0, quota_bytes=DEFAULT_QUOTA_BYTES)
+
+    try:
+        with open(info_path, "r") as f:
+            data = json.load(f)
+        return StorageInfo(**data)
+    except Exception as e:
+        logger.error(f"Failed to load storage info for {username}: {e}")
+        return StorageInfo(total_bytes=0, file_count=0, quota_bytes=DEFAULT_QUOTA_BYTES)
+
+
+def _save_storage_info(username: str, info: StorageInfo) -> None:
+    """Save storage info to disk.
+
+    Args:
+        username: Username
+        info: StorageInfo object
+    """
+    user_dir = get_user_storage_dir(username)
+    info_path = user_dir / "storage_info.json"
+
+    try:
+        with open(info_path, "w") as f:
+            json.dump(asdict(info), f, indent=2)
+    except Exception as e:
+        logger.error(f"Failed to save storage info for {username}: {e}")
+
+
+def get_storage_usage(username: str) -> StorageInfo:
+    """Calculate current storage usage for a user.
+
+    Recalculates from actual files to ensure accuracy.
+
+    Args:
+        username: Username
+
+    Returns:
+        StorageInfo with current usage
+    """
+    user_dir = get_user_storage_dir(username)
+    slides_dir = user_dir / "slides"
+
+    total_bytes = 0
+    file_count = 0
+
+    # Calculate from actual files
+    for slide_file in slides_dir.glob("*"):
+        if slide_file.is_file() and slide_file.name != "metadata.json":
+            total_bytes += slide_file.stat().st_size
+            file_count += 1
+
+    info = _load_storage_info(username)
+    info.total_bytes = total_bytes
+    info.file_count = file_count
+
+    _save_storage_info(username, info)
+    return info
+
+
+def save_uploaded_slide(
+    username: str, slide_path: str | Path, quota_bytes: Optional[int] = None
+) -> tuple[str, str]:
+    """Save an uploaded slide to user storage.
+
+    Enforces per-user quota. If quota would be exceeded, raises ValueError.
+
+    Args:
+        username: Username
+        slide_path: Path to the uploaded slide file
+        quota_bytes: Optional override for quota (uses default if None)
+
+    Returns:
+        Tuple of (slide_id, saved_path)
+
+    Raises:
+        ValueError: If quota would be exceeded
+        OSError: If file operations fail
+    """
+    slide_path = Path(slide_path)
+    file_size = slide_path.stat().st_size
+    file_extension = slide_path.suffix
+
+    # Check quota
+    quota = quota_bytes or DEFAULT_QUOTA_BYTES
+    current_usage = get_storage_usage(username)
+
+    if current_usage.total_bytes + file_size > quota:
+        quota_gb = quota / (1024**3)
+        current_gb = current_usage.total_bytes / (1024**3)
+        raise ValueError(
+            f"Storage quota exceeded. Used: {current_gb:.2f} GB / {quota_gb:.2f} GB. "
+            f"Delete old files before uploading."
+        )
+
+    # Generate unique slide ID
+    slide_id = str(uuid.uuid4())
+    user_dir = get_user_storage_dir(username)
+    dest_path = user_dir / "slides" / f"{slide_id}{file_extension}"
+
+    # Copy file
+    shutil.copy2(slide_path, dest_path)
+    logger.info(f"Saved slide {slide_id} for user {username} ({file_size} bytes)")
+
+    # Update metadata
+    metadata = _load_slide_metadata(username)
+    metadata[slide_id] = SlideMetadata(
+        slide_id=slide_id,
+        original_filename=slide_path.name,
+        upload_time=datetime.utcnow().isoformat(),
+        size_bytes=file_size,
+        file_extension=file_extension,
+    )
+    _save_slide_metadata(username, metadata)
+
+    # Update storage info
+    current_usage.total_bytes += file_size
+    current_usage.file_count += 1
+    _save_storage_info(username, current_usage)
+
+    return slide_id, str(dest_path)
+
+
+def list_user_slides(username: str) -> list[SlideMetadata]:
+    """List all uploaded slides for a user.
+
+    Returns slides sorted by upload time (newest first).
+
+    Args:
+        username: Username
+
+    Returns:
+        List of SlideMetadata objects
+    """
+    metadata = _load_slide_metadata(username)
+    slides = list(metadata.values())
+    # Sort by upload time, newest first
+    slides.sort(key=lambda s: s.upload_time, reverse=True)
+    return slides
+
+
+def get_slide_path(username: str, slide_id: str) -> Optional[Path]:
+    """Get the file path for a slide.
+
+    Args:
+        username: Username
+        slide_id: Slide ID
+
+    Returns:
+        Path to slide file, or None if not found
+    """
+    metadata = _load_slide_metadata(username)
+    if slide_id not in metadata:
+        return None
+
+    user_dir = get_user_storage_dir(username)
+    slide_meta = metadata[slide_id]
+    slide_path = user_dir / "slides" / f"{slide_id}{slide_meta.file_extension}"
+
+    if slide_path.exists():
+        return slide_path
+    return None
+
+
+def delete_user_slide(username: str, slide_id: str) -> bool:
+    """Delete a slide and all associated results.
+
+    Args:
+        username: Username
+        slide_id: Slide ID to delete
+
+    Returns:
+        True if deleted successfully, False if not found
+    """
+    metadata = _load_slide_metadata(username)
+    if slide_id not in metadata:
+        logger.warning(f"Slide {slide_id} not found for user {username}")
+        return False
+
+    user_dir = get_user_storage_dir(username)
+    slide_meta = metadata[slide_id]
+    slide_path = user_dir / "slides" / f"{slide_id}{slide_meta.file_extension}"
+
+    # Delete the file
+    try:
+        if slide_path.exists():
+            slide_path.unlink()
+            logger.info(f"Deleted slide {slide_id} for user {username}")
+    except Exception as e:
+        logger.error(f"Failed to delete slide file {slide_id}: {e}")
+        return False
+
+    # Delete associated results (import here to avoid circular dependency)
+    try:
+        from mosaic.user_results import delete_results_for_slide
+
+        delete_results_for_slide(username, slide_id)
+    except Exception as e:
+        logger.warning(f"Failed to delete results for slide {slide_id}: {e}")
+
+    # Update metadata
+    del metadata[slide_id]
+    _save_slide_metadata(username, metadata)
+
+    # Update storage info
+    current_usage = get_storage_usage(username)
+    _save_storage_info(username, current_usage)
+
+    return True
+
+
+def find_slide_by_name(username: str, name: str) -> Optional[str]:
+    """Find a slide UUID by original filename or filename stem.
+
+    Searches for an exact filename match first, then tries stem match,
+    then falls back to treating the input as a UUID.
+
+    Args:
+        username: Username
+        name: Original filename, filename stem, or slide UUID
+
+    Returns:
+        slide_id (UUID) if found, None otherwise
+    """
+    metadata = _load_slide_metadata(username)
+
+    # Try exact filename match
+    for slide_id, meta in metadata.items():
+        if meta.original_filename == name:
+            return slide_id
+
+    # Try stem match
+    for slide_id, meta in metadata.items():
+        if Path(meta.original_filename).stem == name:
+            return slide_id
+
+    # Try as UUID (backward compat)
+    if name in metadata:
+        return name
+
+    return None
+
+
+def cleanup_old_files(username: str, target_bytes: int) -> int:
+    """Remove oldest files until storage is under target.
+
+    Uses FIFO strategy (oldest files deleted first).
+
+    Args:
+        username: Username
+        target_bytes: Target storage size in bytes
+
+    Returns:
+        Number of files deleted
+    """
+    current_usage = get_storage_usage(username)
+    if current_usage.total_bytes <= target_bytes:
+        return 0
+
+    slides = list_user_slides(username)
+    # Sort by upload time, oldest first
+    slides.sort(key=lambda s: s.upload_time)
+
+    deleted_count = 0
+    current_bytes = current_usage.total_bytes
+
+    for slide in slides:
+        if current_bytes <= target_bytes:
+            break
+
+        delete_user_slide(username, slide.slide_id)
+        current_bytes -= slide.size_bytes
+        deleted_count += 1
+
+    # Update last cleanup time
+    info = _load_storage_info(username)
+    info.last_cleanup = datetime.utcnow().isoformat()
+    _save_storage_info(username, info)
+
+    logger.info(
+        f"Cleanup for user {username}: deleted {deleted_count} files, "
+        f"now using {current_bytes / (1024**3):.2f} GB"
+    )
+
+    return deleted_count
+
+
+def check_disk_space() -> tuple[int, int, float]:
+    """Check global disk space on the instance.
+
+    Returns:
+        Tuple of (used_bytes, total_bytes, percent_used)
+    """
+    try:
+        stat = shutil.disk_usage("/tmp")
+        percent_used = (stat.used / stat.total) * 100
+        return stat.used, stat.total, percent_used
+    except Exception as e:
+        logger.error(f"Failed to check disk space: {e}")
+        return 0, 0, 0.0

tests/benchmark_batch_performance.py

@@ -219,7 +219,7 @@ def main():
                 "Sex": ["Unknown"] * len(slides),
                 "Tissue Site": ["Unknown"] * len(slides),
                 "Cancer Subtype": ["Unknown"] * len(slides),
-                "IHC Subtype": [""] * len(slides),
+                # "IHC Subtype": [""] * len(slides),
                 "Segmentation Config": ["Biopsy"] * len(slides),
             }
         )

tests/test_cli.py

@@ -74,7 +74,7 @@ class TestArgumentParsing:
                 "Sex": ["Unknown"],
                 "Tissue Site": ["Unknown"],
                 "Cancer Subtype": ["Unknown"],
-                "IHC Subtype": [""],
+                # "IHC Subtype": [""],  # Not yet in use
                 "Segmentation Config": ["Biopsy"],
             }
         )

tests/test_fixtures.py

@@ -90,7 +90,7 @@ def sample_settings_df():
             "Sex": ["Male", "Female", "Male"],
             "Tissue Site": ["Lung", "Liver", "Unknown"],
             "Cancer Subtype": ["Unknown", "Lung Adenocarcinoma (LUAD)", "Unknown"],
-            "IHC Subtype": ["", "", ""],
+            # "IHC Subtype": ["", "", ""],  # Not yet in use
             "Segmentation Config": ["Biopsy", "Resection", "TCGA"],
         }
     )
@@ -112,7 +112,7 @@ def create_settings_df(n_rows, **kwargs):
         "Sex": ["Unknown"] * n_rows,
         "Tissue Site": ["Unknown"] * n_rows,
         "Cancer Subtype": ["Unknown"] * n_rows,
-        "IHC Subtype": [""] * n_rows,
+        # "IHC Subtype": [""] * n_rows,  # Not yet in use
         "Segmentation Config": ["Biopsy"] * n_rows,
     }
 
@@ -137,14 +137,12 @@ def create_settings_df(n_rows, **kwargs):
 def sample_csv_valid():
     """Temporary CSV file with valid settings."""
     with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
+        f.write("Slide,Site Type,Sex,Tissue Site,Cancer Subtype,Segmentation Config\n")
+        f.write("slide1.svs,Primary,Unknown,Lung,Unknown,Biopsy\n")
         f.write(
-            "Slide,Site Type,Sex,Tissue Site,Cancer Subtype,IHC Subtype,Segmentation Config\n"
+            "slide2.svs,Metastatic,Female,Liver,Lung Adenocarcinoma (LUAD),Resection\n"
         )
-        f.write("slide1.svs,Primary,Unknown,Lung,Unknown,,Biopsy\n")
-        f.write(
-            "slide2.svs,Metastatic,Female,Liver,Lung Adenocarcinoma (LUAD),,Resection\n"
-        )
-        f.write("slide3.svs,Primary,Male,Unknown,Unknown,,TCGA\n")
+        f.write("slide3.svs,Primary,Male,Unknown,Unknown,TCGA\n")
         f.flush()
         yield f.name
     Path(f.name).unlink(missing_ok=True)
@@ -154,11 +152,9 @@ def sample_csv_valid():
 def sample_csv_invalid():
     """Temporary CSV file with invalid values (for validation testing)."""
     with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
+        f.write("Slide,Site Type,Sex,Tissue Site,Cancer Subtype,Segmentation Config\n")
         f.write(
-            "Slide,Site Type,Sex,Tissue Site,Cancer Subtype,IHC Subtype,Segmentation Config\n"
-        )
-        f.write(
-            "slide1.svs,InvalidSite,InvalidSex,InvalidTissue,InvalidSubtype,InvalidIHC,InvalidConfig\n"
+            "slide1.svs,InvalidSite,InvalidSex,InvalidTissue,InvalidSubtype,InvalidConfig\n"
         )
         f.write(
             "slide2.svs,Primary,Unknown,Lung,BRCA,HR+/HER2+,Biopsy\n"

tests/test_gradio_app.py

@@ -48,7 +48,7 @@ class TestConstants:
             "Slide",
             "Site Type",
             "Cancer Subtype",
-            "IHC Subtype",
+            # "IHC Subtype",  # Not yet in use
             "Segmentation Config",
         ]
         for field in required_fields:
@@ -81,11 +81,9 @@ class TestLoadSettings:
     def temp_settings_csv(self):
         """Create a temporary settings CSV file with all columns."""
         with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".csv") as f:
-            f.write(
-                "Slide,Site Type,Sex,Cancer Subtype,IHC Subtype,Segmentation Config\n"
-            )
-            f.write("slide1.svs,Primary,Male,Unknown,,Biopsy\n")
-            f.write("slide2.svs,Metastatic,Female,Unknown,,Resection\n")
+            f.write("Slide,Site Type,Sex,Cancer Subtype,Segmentation Config\n")
+            f.write("slide1.svs,Primary,Male,Unknown,Biopsy\n")
+            f.write("slide2.svs,Metastatic,Female,Unknown,Resection\n")
             temp_path = f.name
         yield temp_path
         Path(temp_path).unlink()
@@ -117,10 +115,10 @@ class TestLoadSettings:
         df = load_settings(temp_minimal_settings_csv)
         assert "Segmentation Config" in df.columns
         assert "Cancer Subtype" in df.columns
-        assert "IHC Subtype" in df.columns
+        # assert "IHC Subtype" in df.columns  # Not yet in use
         assert df["Segmentation Config"].iloc[0] == "Biopsy"
         assert df["Cancer Subtype"].iloc[0] == "Unknown"
-        assert df["IHC Subtype"].iloc[0] == ""
+        # assert df["IHC Subtype"].iloc[0] == ""  # Not yet in use
 
     def test_load_settings_preserves_data(self, temp_settings_csv):
         """Test that data is preserved correctly."""

tests/test_regression_single_slide.py

@@ -143,7 +143,7 @@ class TestSingleSlideRegression:
                     "Sex": ["Male"],
                     "Tissue Site": ["Lung"],
                     "Cancer Subtype": ["Unknown"],
-                    "IHC Subtype": [""],
+                    # "IHC Subtype": [""],
                     "Segmentation Config": ["Biopsy"],
                 }
             )

tests/test_settings_upload.py

@@ -234,11 +234,9 @@ class TestCsvFormatEdgeCases:
         from mosaic.ui.utils import load_settings
 
         with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
-            f.write(
-                "Slide,Site Type,Sex,Cancer Subtype,IHC Subtype,Segmentation Config\n"
-            )
+            f.write("Slide,Site Type,Sex,Cancer Subtype,Segmentation Config\n")
             # Empty values for optional columns
-            f.write("slide1.svs,Primary,Male,Unknown,,\n")
+            f.write("slide1.svs,Primary,Male,Unknown,\n")
             f.flush()
             temp_path = f.name
 
@@ -250,7 +248,7 @@ class TestCsvFormatEdgeCases:
             assert len(df) == 1
             # Empty strings should be preserved (validation will handle defaults later)
             assert df["Segmentation Config"].iloc[0] == ""
-            assert df["IHC Subtype"].iloc[0] == ""
+            # assert df["IHC Subtype"].iloc[0] == ""  # Not yet in use
         finally:
             Path(temp_path).unlink(missing_ok=True)
 

tests/test_ui_components.py

@@ -40,7 +40,7 @@ class TestSettingsValidation:
                 "Sex": ["Male"],
                 "Tissue Site": ["Unknown"],
                 "Cancer Subtype": ["InvalidSubtype"],
-                "IHC Subtype": [""],
+                # "IHC Subtype": [""],
                 "Segmentation Config": ["Biopsy"],
             }
         )
@@ -72,7 +72,7 @@ class TestSettingsValidation:
                 "Sex": ["Male"],
                 "Tissue Site": ["Unknown"],
                 "Cancer Subtype": ["Unknown"],
-                "IHC Subtype": [""],
+                # "IHC Subtype": [""],
                 "Segmentation Config": ["Biopsy"],
             }
         )
@@ -117,7 +117,7 @@ class TestAnalysisWorkflow:
                 "Sex": ["Male"],
                 "Tissue Site": ["Unknown"],
                 "Cancer Subtype": ["Unknown"],
-                "IHC Subtype": [""],
+                # "IHC Subtype": [""],
                 "Segmentation Config": ["Biopsy"],
             }
         )
@@ -197,7 +197,7 @@ class TestAnalysisWorkflow:
                 "Sex": ["Male", "Female", "Male"],
                 "Tissue Site": ["Unknown", "Unknown", "Unknown"],
                 "Cancer Subtype": ["Unknown", "Unknown", "Unknown"],
-                "IHC Subtype": ["", "", ""],
+                # "IHC Subtype": ["", "", ""],
                 "Segmentation Config": ["Biopsy", "Biopsy", "Biopsy"],
             }
         )

tests/test_ui_events.py

@@ -72,7 +72,7 @@ class TestGeneratorBehavior:
                 "Sex": ["Male"],
                 "Tissue Site": ["Unknown"],
                 "Cancer Subtype": ["Unknown"],
-                "IHC Subtype": [""],
+                # "IHC Subtype": [""],
                 "Segmentation Config": ["Biopsy"],
             }
         )
@@ -141,7 +141,7 @@ class TestGeneratorBehavior:
                 "Sex": ["Male", "Female", "Male"],
                 "Tissue Site": ["Unknown", "Unknown", "Unknown"],
                 "Cancer Subtype": ["Unknown", "Unknown", "Unknown"],
-                "IHC Subtype": ["", "", ""],
+                # "IHC Subtype": ["", "", ""],
                 "Segmentation Config": ["Biopsy", "Biopsy", "Biopsy"],
             }
         )
@@ -237,7 +237,7 @@ class TestGeneratorBehavior:
                 "Sex": ["Male", "Female", "Male"],
                 "Tissue Site": ["Unknown", "Unknown", "Unknown"],
                 "Cancer Subtype": ["Unknown", "Unknown", "Unknown"],
-                "IHC Subtype": ["", "", ""],
+                # "IHC Subtype": ["", "", ""],
                 "Segmentation Config": ["Biopsy", "Biopsy", "Biopsy"],
             }
         )
@@ -337,7 +337,7 @@ class TestGeneratorBehavior:
                 "Sex": ["Male", "Female", "Male"],
                 "Tissue Site": ["Lung", "Lung", "Lung"],
                 "Cancer Subtype": ["LUAD", "LUAD", "LUAD"],
-                "IHC Subtype": ["", "", ""],
+                # "IHC Subtype": ["", "", ""],
                 "Segmentation Config": ["Biopsy", "Biopsy", "Biopsy"],
             }
         )
@@ -418,7 +418,7 @@ class TestErrorDisplay:
                 "Sex": ["Male", "InvalidSex"],
                 "Tissue Site": ["Unknown", "Unknown"],
                 "Cancer Subtype": ["InvalidSubtype", "Unknown"],
-                "IHC Subtype": ["", ""],
+                # "IHC Subtype": ["", ""],
                 "Segmentation Config": ["Biopsy", "InvalidConfig"],
             }
         )
@@ -614,7 +614,7 @@ class TestTCGASegmentationConfig:
                 "Sex": ["Male", "Female", "Male"],
                 "Tissue Site": ["Lung", "Breast", "Liver"],
                 "Cancer Subtype": ["LUAD", "BRCA", "LIHC"],
-                "IHC Subtype": ["", "", ""],
+                # "IHC Subtype": ["", "", ""],
                 "Segmentation Config": ["Biopsy", "Resection", "Biopsy"],
             }
         )

tests/test_ui_user_storage.py

@@ -0,0 +1,428 @@
+"""Integration tests for user storage management in Gradio UI.
+
+Tests end-to-end workflows including upload, analysis, viewing, and deletion
+of slides and results through the UI components.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import pytest
+
+from mosaic.ui.app import launch_gradio
+from mosaic.ui.user_tabs import (
+    LOCAL_DEBUG_USERNAME,
+    _get_username,
+    create_my_files_tab,
+    create_my_results_tab,
+)
+from mosaic.user_results import save_analysis_results
+from mosaic.user_storage import save_uploaded_slide
+
+
+@pytest.fixture
+def temp_storage_dir(tmp_path):
+    """Create temporary storage directory for testing."""
+    storage_dir = tmp_path / "mosaic_user_data"
+    storage_dir.mkdir()
+
+    # Mock the storage base directory
+    # Note: user_results imports from user_storage, so only mock user_storage
+    with patch("mosaic.user_storage.USER_STORAGE_BASE", storage_dir):
+        yield storage_dir
+
+
+@pytest.fixture
+def mock_request_local():
+    """Mock Gradio request for local mode (non-HF Spaces)."""
+    request = MagicMock()
+    request.username = None
+    request.session_hash = "test_session"
+    return request
+
+
+@pytest.fixture
+def mock_request_hf_logged_in():
+    """Mock Gradio request for HF Spaces logged-in user."""
+    request = MagicMock()
+    request.username = "test_user"
+    request.session_hash = "test_session"
+    return request
+
+
+@pytest.fixture
+def mock_request_hf_not_logged_in():
+    """Mock Gradio request for HF Spaces not logged in."""
+    request = MagicMock()
+    request.username = None
+    request.session_hash = "test_session"
+    return request
+
+
+@pytest.fixture
+def sample_slide_file(tmp_path):
+    """Create a sample slide file for testing."""
+    slide_file = tmp_path / "sample_slide.svs"
+    slide_file.write_text("fake slide data" * 1000)  # ~15KB
+
+    # Return the actual Path object (save_uploaded_slide expects a file-like object)
+    # We need to mock it properly
+
+    return MockFile(slide_file)
+
+
+class TestUsernameExtraction:
+    """Test username extraction in different modes."""
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_local_mode_returns_debug_username(self, mock_request_local):
+        """Local mode should return LOCAL_DEBUG_USERNAME."""
+        username, is_local = _get_username(mock_request_local)
+        assert username == LOCAL_DEBUG_USERNAME
+        assert is_local is True
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", True)
+    def test_hf_logged_in_returns_username(self, mock_request_hf_logged_in):
+        """HF Spaces logged in should return request username."""
+        username, is_local = _get_username(mock_request_hf_logged_in)
+        assert username == "test_user"
+        assert is_local is False
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", True)
+    def test_hf_not_logged_in_returns_none(self, mock_request_hf_not_logged_in):
+        """HF Spaces not logged in should return None."""
+        username, is_local = _get_username(mock_request_hf_not_logged_in)
+        assert username is None
+        assert is_local is False
+
+
+class TestEndToEndUserStorage:
+    """Test complete user storage workflow."""
+
+    def test_upload_analyze_view_delete_workflow(
+        self, temp_storage_dir, mock_request_local
+    ):
+        """Test complete workflow: upload → analyze → view → delete."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Create a slide file
+        temp_file = temp_storage_dir / "sample_slide.svs"
+        temp_file.write_text("fake slide data" * 1000)
+
+        # Step 1: Upload slide (use Path directly, not MockFile)
+        slide_id, _ = save_uploaded_slide(username, temp_file)
+        assert slide_id is not None
+
+        # Verify slide saved
+        from mosaic.user_storage import list_user_slides
+
+        slides = list_user_slides(username)
+        assert len(slides) == 1
+        assert slides[0].slide_id == slide_id
+
+        # Verify slide saved
+        from mosaic.user_storage import list_user_slides
+
+        slides = list_user_slides(username)
+        assert len(slides) == 1
+        assert slides[0].slide_id == slide_id
+
+        # Step 2: Save analysis results
+        settings = {
+            "seg_config": "Biopsy",
+            "site_type": "Primary",
+            "sex": "Male",
+            "tissue_site": "Lung",
+            "cancer_subtype": "LUAD",
+        }
+
+        aeon_df = pd.DataFrame(
+            {
+                "cancer_type": ["LUAD", "LUSC"],
+                "confidence": [0.85, 0.10],
+            }
+        )
+
+        analysis_id = "test_analysis_001"
+        save_analysis_results(
+            username=username,
+            analysis_id=analysis_id,
+            slide_id=slide_id,
+            slide_name="sample_slide.svs",
+            settings=settings,
+            aeon_results=aeon_df,
+            paladin_results=None,
+            slide_mask=None,
+        )
+
+        # Step 3: Verify results saved
+        from mosaic.user_results import list_user_results, load_analysis_results
+
+        results = list_user_results(username)
+        assert len(results) == 1
+        assert results[0].analysis_id == analysis_id
+        assert results[0].slide_id == slide_id
+
+        # Step 4: Load result details
+        loaded = load_analysis_results(username, analysis_id)
+        assert loaded is not None
+        metadata, mask, aeon, paladin = loaded
+        assert metadata.slide_name == "sample_slide.svs"
+        assert aeon is not None
+        assert len(aeon) == 2
+
+        # Step 5: Delete slide (should also delete results)
+        from mosaic.user_storage import delete_user_slide
+
+        success = delete_user_slide(username, slide_id)
+        assert success is True
+
+        # Verify slide deleted
+        slides = list_user_slides(username)
+        assert len(slides) == 0
+
+        # Verify results also deleted
+        results = list_user_results(username, slide_id=slide_id)
+        assert len(results) == 0
+
+    def test_quota_enforcement_and_cleanup(self, temp_storage_dir, mock_request_local):
+        """Test quota enforcement triggers FIFO cleanup."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Set very small quota (30KB)
+        with patch("mosaic.user_storage.DEFAULT_QUOTA_BYTES", 30 * 1024):
+            # Upload multiple files (each ~10KB)
+            slide_ids = []
+            for i in range(5):
+                temp_file = temp_storage_dir / f"slide_{i}.svs"
+                temp_file.write_text("fake data " * 1000)  # ~10KB each
+
+                try:
+                    slide_id, _ = save_uploaded_slide(username, temp_file)
+                    slide_ids.append(slide_id)
+                except ValueError:
+                    # Quota exceeded, cleanup should have happened
+                    pass
+
+            # Should have some slides (older ones cleaned up)
+            from mosaic.user_storage import list_user_slides, get_storage_usage
+
+            slides = list_user_slides(username)
+            usage = get_storage_usage(username)
+
+            # Total should be under quota after cleanup
+            assert usage.total_bytes <= 30 * 1024
+            # Some files should have been cleaned up (only 3 should fit)
+            assert len(slides) <= 3
+
+    def test_multiple_analyses_same_slide(self, temp_storage_dir, mock_request_local):
+        """Test multiple analyses can reference the same slide."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Upload slide once
+        temp_file = temp_storage_dir / "multi_analysis.svs"
+        temp_file.write_text("fake slide data" * 1000)
+
+        slide_id, _ = save_uploaded_slide(username, temp_file)
+
+        # Save multiple analysis results for same slide
+        settings1 = {"seg_config": "Biopsy", "site_type": "Primary", "sex": "Male"}
+        settings2 = {"seg_config": "Resection", "site_type": "Primary", "sex": "Male"}
+
+        save_analysis_results(
+            username=username,
+            analysis_id="analysis_001",
+            slide_id=slide_id,
+            slide_name="sample.svs",
+            settings=settings1,
+            aeon_results=None,
+            paladin_results=None,
+            slide_mask=None,
+        )
+
+        save_analysis_results(
+            username=username,
+            analysis_id="analysis_002",
+            slide_id=slide_id,
+            slide_name="sample.svs",
+            settings=settings2,
+            aeon_results=None,
+            paladin_results=None,
+            slide_mask=None,
+        )
+
+        # Verify both results saved
+        from mosaic.user_results import list_user_results
+
+        results = list_user_results(username, slide_id=slide_id)
+        assert len(results) == 2
+
+        # Delete slide should delete both results
+        from mosaic.user_storage import delete_user_slide
+
+        delete_user_slide(username, slide_id)
+
+        results = list_user_results(username, slide_id=slide_id)
+        assert len(results) == 0
+
+
+class TestMyFilesTabIntegration:
+    """Test My Files tab UI integration."""
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_load_files_local_mode(self, temp_storage_dir, mock_request_local):
+        """Test loading files in local debug mode."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Upload a slide first
+        temp_file = temp_storage_dir / "sample_slide.svs"
+        temp_file.write_text("fake slide data" * 1000)
+
+        save_uploaded_slide(username, temp_file)
+
+        # Test the loading logic
+        from mosaic.ui.user_tabs import _get_username
+        from mosaic.user_storage import list_user_slides, get_storage_usage
+
+        username_returned, is_local = _get_username(mock_request_local)
+        assert username_returned == LOCAL_DEBUG_USERNAME
+        assert is_local is True
+
+        # Verify slides can be listed
+        slides = list_user_slides(username)
+        assert len(slides) == 1
+        assert slides[0].original_filename == "sample_slide.svs"
+
+        # Verify storage usage
+        usage = get_storage_usage(username)
+        assert usage.file_count == 1
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", True)
+    def test_load_files_hf_not_logged_in(self, mock_request_hf_not_logged_in):
+        """Test loading files when not logged in on HF Spaces."""
+        # Import the load_files logic directly (would be in create_my_files_tab)
+        from mosaic.ui.user_tabs import _get_username
+        from mosaic.user_storage import list_user_slides, get_storage_usage
+
+        username, _ = _get_username(mock_request_hf_not_logged_in)
+
+        # Should return None for not logged in
+        assert username is None
+
+        # Verify behavior would show "not logged in" message
+        # (actual function would return empty data)
+
+
+class TestMyResultsTabIntegration:
+    """Test My Results tab UI integration."""
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_load_results_local_mode(self, temp_storage_dir, mock_request_local):
+        """Test loading results in local debug mode."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Create analysis result
+        temp_file = temp_storage_dir / "sample_slide.svs"
+        temp_file.write_text("fake slide data" * 1000)
+
+        slide_id, _ = save_uploaded_slide(username, temp_file)
+        save_analysis_results(
+            username=username,
+            analysis_id="test_001",
+            slide_id=slide_id,
+            slide_name="sample.svs",
+            settings={"sex": "Male", "site_type": "Primary"},
+            aeon_results=None,
+            paladin_results=None,
+            slide_mask=None,
+        )
+
+        # Test the loading logic
+        from mosaic.ui.user_tabs import _get_username
+        from mosaic.user_results import list_user_results
+
+        username_returned, _ = _get_username(mock_request_local)
+        assert username_returned == LOCAL_DEBUG_USERNAME
+
+        # Verify results can be listed
+        results = list_user_results(username)
+        assert len(results) == 1
+        assert results[0].analysis_id == "test_001"
+        assert results[0].slide_name == "sample.svs"
+
+
+class TestStorageWarningsUI:
+    """Test storage warning display in main analysis tab."""
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_normal_storage_usage(self, temp_storage_dir, mock_request_local):
+        """Test normal storage usage display (< 80%)."""
+        # Import the function (would normally be in app.py)
+        from mosaic.ui.user_tabs import _get_username
+        from mosaic.user_storage import get_storage_usage
+
+        username, _ = _get_username(mock_request_local)
+        usage = get_storage_usage(username)
+
+        # Should be 0% initially
+        percent = (
+            (usage.total_bytes / usage.quota_bytes * 100)
+            if usage.quota_bytes > 0
+            else 0
+        )
+        assert percent == 0
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_warning_threshold_storage(self, temp_storage_dir, mock_request_local):
+        """Test storage warning at 80% threshold."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Set quota to force warning threshold
+        with patch("mosaic.user_storage.DEFAULT_QUOTA_BYTES", 18 * 1024):  # 18KB quota
+            # Upload file to reach warning threshold
+            temp_file = temp_storage_dir / "large_slide.svs"
+            temp_file.write_text("large fake data" * 1000)  # ~16KB
+
+            save_uploaded_slide(username, temp_file)
+
+            from mosaic.user_storage import get_storage_usage
+
+            usage = get_storage_usage(username)
+            percent = usage.total_bytes / usage.quota_bytes * 100
+
+            # Should be > 80%
+            assert percent > 80
+
+
+class TestReAnalysisWorkflow:
+    """Test re-analyzing existing slides without re-uploading."""
+
+    @patch("mosaic.ui.user_tabs.IS_HF_SPACES", False)
+    def test_select_existing_slide_for_analysis(
+        self, temp_storage_dir, mock_request_local
+    ):
+        """Test selecting an existing slide from dropdown."""
+        username = LOCAL_DEBUG_USERNAME
+
+        # Upload slide
+        temp_file = temp_storage_dir / "sample_slide.svs"
+        temp_file.write_text("fake slide data" * 1000)
+
+        slide_id, _ = save_uploaded_slide(username, temp_file)
+
+        # Get slide path (simulating dropdown selection)
+        from mosaic.user_storage import get_slide_path
+
+        slide_path = get_slide_path(username, slide_id)
+        assert slide_path is not None
+        assert slide_path.exists()
+
+        # Slide can now be analyzed without re-upload
+        # (In actual UI, this would populate input_slides component)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_user_results.py

@@ -0,0 +1,347 @@
+"""Unit tests for user_results module."""
+
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+import pandas as pd
+import pytest
+from PIL import Image
+
+from mosaic.user_results import (
+    ResultMetadata,
+    create_results_zip,
+    delete_analysis_results,
+    delete_results_for_slide,
+    list_user_results,
+    load_analysis_results,
+    save_analysis_results,
+)
+
+
+@pytest.fixture
+def temp_storage_base(tmp_path, monkeypatch):
+    """Temporarily override storage base to tmp_path."""
+    monkeypatch.setattr("mosaic.user_storage.USER_STORAGE_BASE", tmp_path)
+    return tmp_path
+
+
+@pytest.fixture
+def test_user():
+    """Test username."""
+    return "test_user"
+
+
+@pytest.fixture
+def test_analysis_id():
+    """Test analysis ID."""
+    return "analysis-123"
+
+
+@pytest.fixture
+def test_slide_id():
+    """Test slide ID."""
+    return "slide-456"
+
+
+@pytest.fixture
+def test_results():
+    """Test analysis results."""
+    aeon_df = pd.DataFrame(
+        {"Confidence": [0.95, 0.03, 0.02]}, index=["BRCA", "LUAD", "COAD"]
+    )
+    paladin_df = pd.DataFrame(
+        {"Biomarker": ["ER", "PR", "HER2"], "Prediction": [1, 1, 0]}
+    )
+    mask = Image.new("RGB", (100, 100), color="red")
+
+    return aeon_df, paladin_df, mask
+
+
+def test_save_analysis_results(
+    temp_storage_base, test_user, test_analysis_id, test_slide_id, test_results
+):
+    """Test saving analysis results."""
+    aeon_df, paladin_df, mask = test_results
+
+    settings = {
+        "site_type": "Primary",
+        "cancer_subtype": "Unknown",
+        "ihc_subtype": "",
+        "seg_config": "Biopsy",
+    }
+
+    result = save_analysis_results(
+        username=test_user,
+        analysis_id=test_analysis_id,
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    assert result is True
+
+    # Verify files were created
+    from mosaic.user_results import _get_results_dir
+
+    results_dir = _get_results_dir(test_user, test_analysis_id)
+    assert (results_dir / "metadata.json").exists()
+    assert (results_dir / "aeon_results.csv").exists()
+    assert (results_dir / "paladin_results.csv").exists()
+    assert (results_dir / "slide_mask.png").exists()
+
+
+def test_save_analysis_results_partial(
+    temp_storage_base, test_user, test_analysis_id, test_slide_id
+):
+    """Test saving results with some None values."""
+    settings = {"site_type": "Primary"}
+
+    result = save_analysis_results(
+        username=test_user,
+        analysis_id=test_analysis_id,
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=None,
+        paladin_results=None,
+        slide_mask=None,
+    )
+
+    assert result is True
+
+    # Metadata should still exist
+    from mosaic.user_results import _get_results_dir
+
+    results_dir = _get_results_dir(test_user, test_analysis_id)
+    assert (results_dir / "metadata.json").exists()
+
+
+def test_load_analysis_results(
+    temp_storage_base, test_user, test_analysis_id, test_slide_id, test_results
+):
+    """Test loading analysis results."""
+    aeon_df, paladin_df, mask = test_results
+    settings = {"site_type": "Primary"}
+
+    # Save results first
+    save_analysis_results(
+        username=test_user,
+        analysis_id=test_analysis_id,
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # Load results
+    loaded = load_analysis_results(test_user, test_analysis_id)
+    assert loaded is not None
+
+    metadata, loaded_mask, loaded_aeon, loaded_paladin = loaded
+
+    # Check metadata
+    assert isinstance(metadata, ResultMetadata)
+    assert metadata.analysis_id == test_analysis_id
+    assert metadata.slide_id == test_slide_id
+    assert metadata.slide_name == "test_slide.svs"
+    assert metadata.cancer_subtype == "BRCA"  # Top prediction
+
+    # Check results
+    assert isinstance(loaded_mask, Image.Image)
+    assert isinstance(loaded_aeon, pd.DataFrame)
+    assert isinstance(loaded_paladin, pd.DataFrame)
+
+
+def test_load_analysis_results_not_found(temp_storage_base, test_user):
+    """Test loading non-existent results."""
+    result = load_analysis_results(test_user, "nonexistent")
+    assert result is None
+
+
+def test_list_user_results(temp_storage_base, test_user, test_slide_id, test_results):
+    """Test listing user results."""
+    aeon_df, paladin_df, mask = test_results
+    settings = {"site_type": "Primary"}
+
+    # Save multiple results
+    save_analysis_results(
+        username=test_user,
+        analysis_id="analysis-1",
+        slide_id=test_slide_id,
+        slide_name="slide1.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    save_analysis_results(
+        username=test_user,
+        analysis_id="analysis-2",
+        slide_id="slide-other",
+        slide_name="slide2.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # List all results
+    all_results = list_user_results(test_user)
+    assert len(all_results) == 2
+
+    # List results for specific slide
+    slide_results = list_user_results(test_user, slide_id=test_slide_id)
+    assert len(slide_results) == 1
+    assert slide_results[0].analysis_id == "analysis-1"
+
+
+def test_delete_analysis_results(
+    temp_storage_base, test_user, test_analysis_id, test_slide_id, test_results
+):
+    """Test deleting analysis results."""
+    aeon_df, paladin_df, mask = test_results
+    settings = {"site_type": "Primary"}
+
+    # Save results
+    save_analysis_results(
+        username=test_user,
+        analysis_id=test_analysis_id,
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # Verify results exist
+    from mosaic.user_results import _get_results_dir
+
+    results_dir = _get_results_dir(test_user, test_analysis_id)
+    assert results_dir.exists()
+
+    # Delete results
+    assert delete_analysis_results(test_user, test_analysis_id) is True
+
+    # Verify results are gone
+    assert not results_dir.exists()
+
+    # Try deleting again (should return False)
+    assert delete_analysis_results(test_user, test_analysis_id) is False
+
+
+def test_delete_results_for_slide(
+    temp_storage_base, test_user, test_slide_id, test_results
+):
+    """Test deleting all results for a slide."""
+    aeon_df, paladin_df, mask = test_results
+    settings = {"site_type": "Primary"}
+
+    # Save multiple results for the same slide
+    save_analysis_results(
+        username=test_user,
+        analysis_id="analysis-1",
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    save_analysis_results(
+        username=test_user,
+        analysis_id="analysis-2",
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # Save result for different slide
+    save_analysis_results(
+        username=test_user,
+        analysis_id="analysis-3",
+        slide_id="other-slide",
+        slide_name="other.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # Delete results for test_slide_id
+    deleted = delete_results_for_slide(test_user, test_slide_id)
+    assert deleted == 2
+
+    # Verify correct results were deleted
+    remaining = list_user_results(test_user)
+    assert len(remaining) == 1
+    assert remaining[0].slide_id == "other-slide"
+
+
+def test_create_results_zip(
+    temp_storage_base, test_user, test_analysis_id, test_slide_id, test_results
+):
+    """Test creating ZIP file from results."""
+    aeon_df, paladin_df, mask = test_results
+    settings = {"site_type": "Primary"}
+
+    # Save results
+    save_analysis_results(
+        username=test_user,
+        analysis_id=test_analysis_id,
+        slide_id=test_slide_id,
+        slide_name="test_slide.svs",
+        settings=settings,
+        aeon_results=aeon_df,
+        paladin_results=paladin_df,
+        slide_mask=mask,
+    )
+
+    # Create ZIP
+    zip_path = create_results_zip(test_user, test_analysis_id)
+    assert zip_path is not None
+    assert zip_path.exists()
+    assert zip_path.suffix == ".zip"
+
+    # Verify ZIP contains expected files
+    import zipfile
+
+    with zipfile.ZipFile(zip_path, "r") as zipf:
+        names = zipf.namelist()
+        assert "metadata.json" in names
+        assert "aeon_results.csv" in names
+        assert "paladin_results.csv" in names
+        assert "slide_mask.png" in names
+
+
+def test_create_results_zip_not_found(temp_storage_base, test_user):
+    """Test creating ZIP for non-existent results."""
+    zip_path = create_results_zip(test_user, "nonexistent")
+    assert zip_path is None
+
+
+def test_result_metadata_dataclass():
+    """Test ResultMetadata dataclass."""
+    metadata = ResultMetadata(
+        analysis_id="test-analysis",
+        slide_id="test-slide",
+        slide_name="test.svs",
+        timestamp="2024-01-01T00:00:00",
+        settings={"site_type": "Primary"},
+        cancer_subtype="BRCA",
+    )
+
+    assert metadata.analysis_id == "test-analysis"
+    assert metadata.slide_id == "test-slide"
+    assert metadata.cancer_subtype == "BRCA"

tests/test_user_storage.py

@@ -0,0 +1,246 @@
+"""Unit tests for user_storage module."""
+
+import json
+import tempfile
+import uuid
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from mosaic.user_storage import (
+    DEFAULT_QUOTA_BYTES,
+    SlideMetadata,
+    StorageInfo,
+    cleanup_old_files,
+    delete_user_slide,
+    get_slide_path,
+    get_storage_usage,
+    get_user_storage_dir,
+    list_user_slides,
+    save_uploaded_slide,
+)
+
+
+@pytest.fixture
+def temp_storage_base(tmp_path, monkeypatch):
+    """Temporarily override storage base to tmp_path."""
+    monkeypatch.setattr("mosaic.user_storage.USER_STORAGE_BASE", tmp_path)
+    return tmp_path
+
+
+@pytest.fixture
+def test_user():
+    """Test username."""
+    return "test_user"
+
+
+@pytest.fixture
+def test_slide_file(tmp_path):
+    """Create a temporary test slide file."""
+    slide_path = tmp_path / "test_slide.svs"
+    # Create a 1KB test file
+    slide_path.write_bytes(b"x" * 1024)
+    return slide_path
+
+
+def test_get_user_storage_dir(temp_storage_base, test_user):
+    """Test creating user storage directory."""
+    user_dir = get_user_storage_dir(test_user)
+
+    assert user_dir.exists()
+    assert user_dir == temp_storage_base / test_user
+    assert (user_dir / "slides").exists()
+    assert (user_dir / "results").exists()
+
+
+def test_save_uploaded_slide(temp_storage_base, test_user, test_slide_file):
+    """Test saving an uploaded slide."""
+    slide_id, saved_path = save_uploaded_slide(test_user, test_slide_file)
+
+    # Check slide ID is a valid UUID
+    assert uuid.UUID(slide_id)
+
+    # Check file was copied
+    saved_path = Path(saved_path)
+    assert saved_path.exists()
+    assert saved_path.stat().st_size == 1024
+
+    # Check metadata was created
+    user_dir = get_user_storage_dir(test_user)
+    metadata_path = user_dir / "slides" / "metadata.json"
+    assert metadata_path.exists()
+
+    with open(metadata_path, "r") as f:
+        metadata = json.load(f)
+
+    assert slide_id in metadata
+    assert metadata[slide_id]["original_filename"] == "test_slide.svs"
+    assert metadata[slide_id]["size_bytes"] == 1024
+
+
+def test_save_uploaded_slide_quota_exceeded(
+    temp_storage_base, test_user, test_slide_file
+):
+    """Test quota enforcement when saving slides."""
+    # Set quota to 512 bytes (smaller than test file)
+    with pytest.raises(ValueError, match="Storage quota exceeded"):
+        save_uploaded_slide(test_user, test_slide_file, quota_bytes=512)
+
+
+def test_list_user_slides(temp_storage_base, test_user, test_slide_file):
+    """Test listing user slides."""
+    # Save two slides
+    slide_id1, _ = save_uploaded_slide(test_user, test_slide_file)
+    slide_id2, _ = save_uploaded_slide(test_user, test_slide_file)
+
+    slides = list_user_slides(test_user)
+
+    assert len(slides) == 2
+    # Should be sorted by upload time, newest first
+    assert slides[0].slide_id == slide_id2
+    assert slides[1].slide_id == slide_id1
+    assert all(isinstance(s, SlideMetadata) for s in slides)
+
+
+def test_get_slide_path(temp_storage_base, test_user, test_slide_file):
+    """Test getting slide file path."""
+    slide_id, saved_path = save_uploaded_slide(test_user, test_slide_file)
+
+    retrieved_path = get_slide_path(test_user, slide_id)
+    assert retrieved_path == Path(saved_path)
+    assert retrieved_path.exists()
+
+    # Test non-existent slide
+    assert get_slide_path(test_user, "nonexistent") is None
+
+
+def test_delete_user_slide(temp_storage_base, test_user, test_slide_file):
+    """Test deleting a slide."""
+    slide_id, saved_path = save_uploaded_slide(test_user, test_slide_file)
+
+    # Verify file exists
+    assert Path(saved_path).exists()
+
+    # Delete slide
+    assert delete_user_slide(test_user, slide_id) is True
+
+    # Verify file is gone
+    assert not Path(saved_path).exists()
+
+    # Verify metadata is updated
+    slides = list_user_slides(test_user)
+    assert len(slides) == 0
+
+    # Test deleting non-existent slide
+    assert delete_user_slide(test_user, "nonexistent") is False
+
+
+def test_get_storage_usage(temp_storage_base, test_user, test_slide_file):
+    """Test calculating storage usage."""
+    # Initially empty
+    usage = get_storage_usage(test_user)
+    assert usage.total_bytes == 0
+    assert usage.file_count == 0
+    assert usage.quota_bytes == DEFAULT_QUOTA_BYTES
+
+    # Save a slide
+    save_uploaded_slide(test_user, test_slide_file)
+
+    # Check updated usage
+    usage = get_storage_usage(test_user)
+    assert usage.total_bytes == 1024
+    assert usage.file_count == 1
+
+
+def test_cleanup_old_files(temp_storage_base, test_user, tmp_path):
+    """Test FIFO cleanup of old files."""
+    # Create three test files of different sizes
+    slide1 = tmp_path / "slide1.svs"
+    slide2 = tmp_path / "slide2.svs"
+    slide3 = tmp_path / "slide3.svs"
+
+    slide1.write_bytes(b"x" * 1024)  # 1KB
+    slide2.write_bytes(b"x" * 2048)  # 2KB
+    slide3.write_bytes(b"x" * 3072)  # 3KB
+
+    # Save slides (oldest to newest)
+    id1, _ = save_uploaded_slide(test_user, slide1)
+    id2, _ = save_uploaded_slide(test_user, slide2)
+    id3, _ = save_uploaded_slide(test_user, slide3)
+
+    # Total usage: 6KB (1KB + 2KB + 3KB)
+    usage = get_storage_usage(test_user)
+    assert usage.total_bytes == 6144
+
+    # Cleanup to 4KB target
+    # Should delete oldest files: slide1 (1KB) + slide2 (2KB) = 3KB deleted
+    # Remaining: slide3 (3KB) which is ≤ 4KB target
+    deleted = cleanup_old_files(test_user, target_bytes=4096)
+    assert deleted == 2
+
+    # Verify slide1 and slide2 are gone, slide3 remains
+    assert get_slide_path(test_user, id1) is None
+    assert get_slide_path(test_user, id2) is None
+    assert get_slide_path(test_user, id3) is not None
+
+    # Check final usage
+    usage = get_storage_usage(test_user)
+    assert usage.total_bytes == 3072  # 3KB only
+
+
+def test_cleanup_old_files_no_action_needed(
+    temp_storage_base, test_user, test_slide_file
+):
+    """Test cleanup when already under target."""
+    save_uploaded_slide(test_user, test_slide_file)
+
+    # Target is higher than current usage
+    deleted = cleanup_old_files(test_user, target_bytes=10240)
+    assert deleted == 0
+
+    # Slide should still exist
+    slides = list_user_slides(test_user)
+    assert len(slides) == 1
+
+
+def test_storage_info_persistence(temp_storage_base, test_user, test_slide_file):
+    """Test that storage info persists across function calls."""
+    save_uploaded_slide(test_user, test_slide_file)
+
+    # Get usage first time
+    usage1 = get_storage_usage(test_user)
+
+    # Get usage again (should load from saved file)
+    usage2 = get_storage_usage(test_user)
+
+    assert usage1.total_bytes == usage2.total_bytes
+    assert usage1.file_count == usage2.file_count
+
+
+def test_slide_metadata_dataclass():
+    """Test SlideMetadata dataclass."""
+    metadata = SlideMetadata(
+        slide_id="test-id",
+        original_filename="test.svs",
+        upload_time="2024-01-01T00:00:00",
+        size_bytes=1024,
+        file_extension=".svs",
+    )
+
+    assert metadata.slide_id == "test-id"
+    assert metadata.original_filename == "test.svs"
+    assert metadata.size_bytes == 1024
+
+
+def test_storage_info_dataclass():
+    """Test StorageInfo dataclass."""
+    info = StorageInfo(
+        total_bytes=1024, file_count=5, quota_bytes=5368709120, last_cleanup=None
+    )
+
+    assert info.total_bytes == 1024
+    assert info.file_count == 5
+    assert info.quota_bytes == 5368709120
+    assert info.last_cleanup is None