diff --git a/.gitignore b/.gitignore
index a6868a12..8b4424cc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -185,3 +185,14 @@ examples/*_vector_store/
 
 dump.rdb
 celerybeat-schedule.db
+
+# Runtime data (uploads, persisted file lists, scratch test data)
+data/
+
+# Runtime-generated custom metrics & remedy data (package keeps __init__.py + base_dr.py)
+aidrin/custom_metrics/customDR_*.py
+aidrin/custom_metrics/remedy_data/
+
+# session/local artifacts
+AIDRIN-gtag/
+claude.session
diff --git a/aidrin/__init__.py b/aidrin/__init__.py
index 4a637a87..c9676768 100644
--- a/aidrin/__init__.py
+++ b/aidrin/__init__.py
@@ -334,8 +334,20 @@ def compute_entropy_risk(quasi_identifiers, file_info):
     return _fn(quasi_identifiers, file_info)
 
 
+# ---------------------------------------------------------------------------
+# Batch / Structural Overview
+# ---------------------------------------------------------------------------
+
+def summarize_files(file_infos):
+    """Per-file structural overview + totals for a batch of files (no metrics)."""
+    from aidrin.batch import summarize_files as _fn
+    return _fn(file_infos)
+
+
 __all__ = [
     "__version__",
+    # Batch / Structural Overview
+    "summarize_files",
     # Data Quality
     "calculate_completeness",
     "calculate_duplicates",
diff --git a/aidrin/agentic/retriever.py b/aidrin/agentic/retriever.py
index a6c9a54c..cd3ca8d6 100644
--- a/aidrin/agentic/retriever.py
+++ b/aidrin/agentic/retriever.py
@@ -304,7 +304,7 @@ def _compress_one(item: dict[str, Any]) -> str:
             context_texts = [item.get("full_text", "") for item in retrieved]
 
         prompt_context = "\n\n".join(
-            f"[Source: {item.get('source','unknown')}]\n{self._sanitize(text)}"
+            f"[Source: {item.get('source', 'unknown')}]\n{self._sanitize(text)}"
             for item, text in zip(retrieved, context_texts)
         )
 
diff --git a/aidrin/batch.py b/aidrin/batch.py
new file mode 100644
index 00000000..a4a3105e
--- /dev/null
+++ b/aidrin/batch.py
@@ -0,0 +1,71 @@
+"""Session-free batch helpers shared by the web UI, CLI, and library users."""
+
+import os
+
+import pandas as pd
+
+from aidrin.file_handling.file_parser import read_file
+
+
+def _summarize_one(file_info):
+    path, name, file_type = file_info
+    if not path:
+        return {
+            "name": name, "type": file_type,
+            "records": None, "features": None,
+            "numerical": None, "categorical": None,
+            "size_bytes": None, "status": "error",
+            "error": "No file path provided.",
+        }
+    size = None
+    try:
+        if path and os.path.exists(path):
+            size = os.path.getsize(path)
+    except OSError:
+        size = None
+
+    result = read_file(file_info)  # DataFrame | None | str
+    if isinstance(result, pd.DataFrame):
+        # Same dtype convention as the Data Overview panel: numeric vs string.
+        numerical = int(sum(pd.api.types.is_numeric_dtype(d) for d in result.dtypes))
+        categorical = int(sum(pd.api.types.is_string_dtype(d) for d in result.dtypes))
+        return {
+            "name": name, "type": file_type,
+            "records": int(len(result)),
+            "features": int(len(result.columns)),
+            "numerical": numerical, "categorical": categorical,
+            "size_bytes": size, "status": "ok", "error": None,
+        }
+
+    message = result if isinstance(result, str) else (
+        "Could not read the file. The format may be unsupported or the file "
+        "may be corrupted."
+    )
+    return {
+        "name": name, "type": file_type,
+        "records": None, "features": None,
+        "numerical": None, "categorical": None,
+        "size_bytes": size, "status": "error", "error": message,
+    }
+
+
+def summarize_files(file_infos):
+    """Return {"files": [per_file, ...], "totals": {...}} for a list of files.
+
+    Computes structural facts only (records, features, size, load status) — no
+    metrics. A file that fails to load becomes a status:"error" row and never
+    aborts the batch. ``file_infos`` is a list of (path, name, type) tuples.
+    """
+    files = [_summarize_one(fi) for fi in file_infos]
+    by_type = {}
+    for f in files:
+        by_type[f["type"]] = by_type.get(f["type"], 0) + 1
+    totals = {
+        "file_count": len(files),
+        "ok_count": sum(1 for f in files if f["status"] == "ok"),
+        "error_count": sum(1 for f in files if f["status"] == "error"),
+        "total_records": sum(f["records"] or 0 for f in files),
+        "total_size_bytes": sum(f["size_bytes"] or 0 for f in files),
+        "by_type": by_type,
+    }
+    return {"files": files, "totals": totals}
diff --git a/aidrin/file_handling/file_parser.py b/aidrin/file_handling/file_parser.py
index a51e9cb2..68cce7ec 100644
--- a/aidrin/file_handling/file_parser.py
+++ b/aidrin/file_handling/file_parser.py
@@ -38,6 +38,37 @@
     # (file_type,file_type_name)
 ]
 
+# Map a real file extension to the READER_MAP key that handles it.
+# Excel uses a single combined reader key, so all its extensions point at it.
+_EXCEL_KEY = ".xls, .xlsb, .xlsx, .xlsm"
+EXTENSION_MAP = {
+    ".csv": ".csv",
+    ".json": ".json",
+    ".npz": ".npz",
+    ".h5": ".h5",
+    ".parquet": ".parquet",   # resolves only once a parquet reader is registered in READER_MAP
+    ".xls": _EXCEL_KEY,
+    ".xlsb": _EXCEL_KEY,
+    ".xlsx": _EXCEL_KEY,
+    ".xlsm": _EXCEL_KEY,
+}
+
+
+def file_extension(filename):
+    """Return the lowercased real extension (e.g. ``.csv``), or ``""``."""
+    return os.path.splitext(filename or "")[1].lower()
+
+
+def infer_file_type(filename):
+    """Return the READER_MAP key for a filename's extension, or None.
+
+    Only returns a key that is actually registered in READER_MAP on this
+    install (e.g. ``.parquet`` resolves only if the parquet reader exists).
+    """
+    key = EXTENSION_MAP.get(file_extension(filename))
+    return key if key in READER_MAP else None
+
+
 # logger config
 file_upload_time_log = logging.getLogger("file_upload")
 
diff --git a/aidrin/structured_data_metrics/privacy_measure.py b/aidrin/structured_data_metrics/privacy_measure.py
index 47d488a9..e5cb96d8 100644
--- a/aidrin/structured_data_metrics/privacy_measure.py
+++ b/aidrin/structured_data_metrics/privacy_measure.py
@@ -517,6 +517,8 @@ def compute_k_anonymity(quasi_identifiers: List[str], file_info):
         "k-Anonymity Visualization": base64_str}``
         or ``{"Error": str}`` on validation failure.
     """
+    if not quasi_identifiers:
+        return {"Error": "Please select at least one quasi-identifier."}
     # Handle both DataFrame and tuple inputs
     if isinstance(file_info, tuple):
         data = read_file(file_info)
@@ -634,6 +636,8 @@ def compute_l_diversity(
         "l-Diversity Visualization": base64_str}``
         or ``{"Error": str}`` on validation failure.
     """
+    if not quasi_identifiers:
+        return {"Error": "Please select at least one quasi-identifier."}
     # Handle both DataFrame and tuple inputs
     if isinstance(file_info, tuple):
         data = read_file(file_info)
@@ -765,6 +769,8 @@ def compute_t_closeness(
         where ``t-Value`` is in ``[0, 1]``,
         or ``{"Error": str}`` on validation failure.
     """
+    if not quasi_identifiers:
+        return {"Error": "Please select at least one quasi-identifier."}
     # Handle both DataFrame and tuple inputs
     if isinstance(file_info, tuple):
         data = read_file(file_info)
@@ -895,6 +901,8 @@ def compute_entropy_risk(quasi_identifiers, file_info):
         where ``Entropy-Value >= 0``,
         or ``{"Error": str}`` on validation failure.
     """
+    if not quasi_identifiers:
+        return {"Error": "Please select at least one quasi-identifier."}
     # Handle both DataFrame and tuple inputs
     if isinstance(file_info, tuple):
         data = read_file(file_info)
diff --git a/docs/superpowers/plans/2026-06-04-multi-file-batch-analysis.md b/docs/superpowers/plans/2026-06-04-multi-file-batch-analysis.md
new file mode 100644
index 00000000..c7e99c32
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-04-multi-file-batch-analysis.md
@@ -0,0 +1,1327 @@
+# Multi-File Batch Analysis Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Let AIDRIN analyze many independent files at once — an active-file switcher plus a "Batch Overview" landing summary — fed by both local multi-upload and Globus.
+
+**Architecture:** Two layers. (1) A session-free **core** primitive in `aidrin` (`summarize_files`, `infer_file_type`). (2) A **web** active-file shim: a server-side `uploaded_files` list + `active_file_id`; `set_active_file` mirrors the active file's identity into the existing `uploaded_file_*` (and, for Globus, `globus_file_*`) session keys so every existing route keeps working unchanged. Execution stays dispatched by source (local routes vs. remote `remote_metric_runner`).
+
+**Tech Stack:** Python 3.10+, Flask, pandas, pytest (unit + integration via `tests/integration/conftest.py`), vanilla JS + Tailwind.
+
+**Spec:** `docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md`
+
+---
+
+## Prerequisites & Cross-Branch Notes
+
+- This branch (`multi-file-analysis`) is off `develop`. It does **not** have
+  `MAX_CONTENT_LENGTH` (on `upload-size-limit`) or `load_dataframe` (on
+  `parquet-support`). This plan adds the small pieces it needs directly
+  (Milestone 4 adds the size cap + 413; `summarize_files` handles `read_file`'s
+  tri-state itself), so it is self-contained.
+- Run tests with the project venv: `.venv/bin/python -m pytest`.
+- Follow TDD: write the failing test, watch it fail, implement minimally, watch it pass, commit.
+
+## File Structure
+
+**Create**
+- `aidrin/batch.py` — `summarize_files(file_infos)` (session-free, no Celery).
+- `tests/unit/test_infer_file_type.py`
+- `tests/unit/test_summarize_files.py`
+- `web/routes/files.py` — file-management blueprint (`/files`, activate, remove, summary).
+- `web/templates/_components/file_switcher.html` — sidebar file list.
+- `web/templates/_panels/_batch_overview.html` — batch overview panel.
+- `tests/integration/test_files_routes.py`
+- `tests/integration/test_multi_upload.py`
+
+**Modify**
+- `aidrin/file_handling/file_parser.py` — add `EXTENSION_MAP` + `infer_file_type`.
+- `aidrin/__init__.py` — export `summarize_files`.
+- `web/routes/utils.py` — file-list store + `set_active_file`; cache key → file_id.
+- `web/routes/core.py` — multi-file `/inspector`; Globus-aware stale check; land on overview.
+- `web/routes/__init__.py` — register the `files` blueprint.
+- `web/routes/globus.py` — append selections into the shared list; fold `globus_file_*`.
+- `web/__init__.py` — `MAX_CONTENT_LENGTH`, `AIDRIN_MAX_UPLOAD_FILES`, 413 handler.
+- `web/templates/inspector.html` — include switcher + batch overview; default panel.
+- `web/templates/_components/upload_panel.html` — `multiple`; remove type `<select>`.
+- `web/static/js/main.js` — AJAX multi-file upload.
+- `web/static/js/inspector.js` — switcher, batch overview render, async Globus counts.
+
+---
+
+## Milestone 1 — Core batch layer (session-free)
+
+Independently testable; gives the library/CLI batch capability immediately.
+
+### Task 1: `infer_file_type` (extension → reader key)
+
+**Files:**
+- Modify: `aidrin/file_handling/file_parser.py`
+- Test: `tests/unit/test_infer_file_type.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/unit/test_infer_file_type.py
+import pytest
+from aidrin.file_handling.file_parser import infer_file_type, READER_MAP
+
+
+@pytest.mark.parametrize("filename,expected", [
+    ("data.csv", ".csv"),
+    ("DATA.CSV", ".csv"),                 # case-insensitive
+    ("set.json", ".json"),
+    ("a.npz", ".npz"),
+    ("b.h5", ".h5"),
+    ("c.parquet", ".parquet"),            # present only if parquet branch merged
+    ("sheet.xlsx", ".xls, .xlsb, .xlsx, .xlsm"),
+    ("sheet.xls", ".xls, .xlsb, .xlsx, .xlsm"),
+])
+def test_infer_known_extensions(filename, expected):
+    if expected not in READER_MAP:
+        pytest.skip(f"{expected} reader not registered on this branch")
+    assert infer_file_type(filename) == expected
+
+
+def test_infer_unknown_extension_returns_none():
+    assert infer_file_type("notes.txt") is None
+    assert infer_file_type("noext") is None
+
+
+def test_infer_real_extension_helper():
+    # The raw extension (for use as a real filename suffix) is exposed separately.
+    from aidrin.file_handling.file_parser import file_extension
+    assert file_extension("Sheet.XLSX") == ".xlsx"
+    assert file_extension("a.csv") == ".csv"
+    assert file_extension("noext") == ""
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_infer_file_type.py -v`
+Expected: FAIL — `ImportError: cannot import name 'infer_file_type'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add to `aidrin/file_handling/file_parser.py` (after `SUPPORTED_FILE_TYPES`):
+
+```python
+import os
+
+# Map a real file extension to the READER_MAP key that handles it.
+# Excel uses a single combined reader key, so all its extensions point at it.
+_EXCEL_KEY = ".xls, .xlsb, .xlsx, .xlsm"
+EXTENSION_MAP = {
+    ".csv": ".csv",
+    ".json": ".json",
+    ".npz": ".npz",
+    ".h5": ".h5",
+    ".parquet": ".parquet",
+    ".xls": _EXCEL_KEY,
+    ".xlsb": _EXCEL_KEY,
+    ".xlsx": _EXCEL_KEY,
+    ".xlsm": _EXCEL_KEY,
+}
+
+
+def file_extension(filename):
+    """Return the lowercased real extension (e.g. ``.csv``), or ``""``."""
+    return os.path.splitext(filename or "")[1].lower()
+
+
+def infer_file_type(filename):
+    """Return the READER_MAP key for a filename's extension, or None.
+
+    Only returns a key that is actually registered in READER_MAP on this
+    install (e.g. ``.parquet`` resolves only if the parquet reader exists).
+    """
+    key = EXTENSION_MAP.get(file_extension(filename))
+    return key if key in READER_MAP else None
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_infer_file_type.py -v`
+Expected: PASS (parquet case may `skip` if not merged).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add aidrin/file_handling/file_parser.py tests/unit/test_infer_file_type.py
+git commit -m "feat(core): infer reader type from file extension"
+```
+
+### Task 2: `summarize_files` (per-file structure + totals, no metrics)
+
+**Files:**
+- Create: `aidrin/batch.py`
+- Modify: `aidrin/__init__.py`
+- Test: `tests/unit/test_summarize_files.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/unit/test_summarize_files.py
+import os
+import tempfile
+
+import pandas as pd
+
+from aidrin.batch import summarize_files
+
+
+def _csv(rows="a,b\n1,2\n3,4\n"):
+    f = tempfile.NamedTemporaryFile(suffix=".csv", delete=False, mode="w")
+    f.write(rows)
+    f.close()
+    return f.name
+
+
+def test_ok_file_reports_structure_no_metrics():
+    path = _csv()
+    try:
+        out = summarize_files([(path, "data.csv", ".csv")])
+    finally:
+        os.unlink(path)
+    row = out["files"][0]
+    assert row["status"] == "ok"
+    assert row["records"] == 2
+    assert row["features"] == 2
+    assert row["size_bytes"] > 0
+    assert row["error"] is None
+    # No metric fields leak in:
+    assert set(row.keys()) == {"name", "type", "records", "features",
+                               "size_bytes", "status", "error"}
+
+
+def test_unsupported_type_is_error_not_crash():
+    out = summarize_files([("/nope/x.txt", "x.txt", ".txt")])
+    row = out["files"][0]
+    assert row["status"] == "error"
+    assert row["records"] is None and row["features"] is None
+    assert row["error"]
+
+
+def test_missing_file_is_error():
+    out = summarize_files([("/nope/missing.csv", "missing.csv", ".csv")])
+    assert out["files"][0]["status"] == "error"
+
+
+def test_one_bad_file_does_not_abort_batch():
+    good = _csv()
+    try:
+        out = summarize_files([
+            (good, "good.csv", ".csv"),
+            ("/nope/bad.csv", "bad.csv", ".csv"),
+        ])
+    finally:
+        os.unlink(good)
+    statuses = [f["status"] for f in out["files"]]
+    assert statuses == ["ok", "error"]
+
+
+def test_totals():
+    a = _csv("a,b\n1,2\n3,4\n5,6\n")   # 3 rows
+    b = _csv("x\n1\n")                  # 1 row
+    try:
+        out = summarize_files([
+            (a, "a.csv", ".csv"),
+            (b, "b.csv", ".csv"),
+            ("/nope/c.csv", "c.csv", ".csv"),
+        ])
+    finally:
+        os.unlink(a); os.unlink(b)
+    t = out["totals"]
+    assert t["file_count"] == 3
+    assert t["ok_count"] == 2
+    assert t["error_count"] == 1
+    assert t["total_records"] == 4
+    assert t["by_type"] == {".csv": 3}
+
+
+def test_empty_input():
+    out = summarize_files([])
+    assert out["files"] == []
+    assert out["totals"]["file_count"] == 0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_summarize_files.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'aidrin.batch'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+```python
+# aidrin/batch.py
+"""Session-free batch helpers shared by the web UI, CLI, and library users."""
+
+import os
+
+import pandas as pd
+
+from aidrin.file_handling.file_parser import read_file
+
+
+def _summarize_one(file_info):
+    path, name, ftype = file_info
+    size = None
+    try:
+        if path and os.path.exists(path):
+            size = os.path.getsize(path)
+    except OSError:
+        size = None
+
+    result = read_file(file_info)  # DataFrame | None | str
+    if isinstance(result, pd.DataFrame):
+        return {
+            "name": name, "type": ftype,
+            "records": int(len(result)),
+            "features": int(len(result.columns)),
+            "size_bytes": size, "status": "ok", "error": None,
+        }
+
+    message = result if isinstance(result, str) else (
+        "Could not read the file. The format may be unsupported or the file "
+        "may be corrupted."
+    )
+    return {
+        "name": name, "type": ftype,
+        "records": None, "features": None,
+        "size_bytes": size, "status": "error", "error": message,
+    }
+
+
+def summarize_files(file_infos):
+    """Return {"files": [per_file, ...], "totals": {...}} for a list of files.
+
+    Computes structural facts only (records, features, size, load status) — no
+    metrics. A file that fails to load becomes a status:"error" row and never
+    aborts the batch. ``file_infos`` is a list of (path, name, type) tuples.
+    """
+    files = [_summarize_one(fi) for fi in file_infos]
+    by_type = {}
+    for f in files:
+        by_type[f["type"]] = by_type.get(f["type"], 0) + 1
+    totals = {
+        "file_count": len(files),
+        "ok_count": sum(1 for f in files if f["status"] == "ok"),
+        "error_count": sum(1 for f in files if f["status"] == "error"),
+        "total_records": sum(f["records"] or 0 for f in files),
+        "by_type": by_type,
+    }
+    return {"files": files, "totals": totals}
+```
+
+- [ ] **Step 4: Export from the package**
+
+Add to `aidrin/__init__.py` (near the other public functions):
+
+```python
+def summarize_files(file_infos):
+    """Per-file structural overview + totals for a batch of files (no metrics)."""
+    from aidrin.batch import summarize_files as _fn
+    return _fn(file_infos)
+```
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_summarize_files.py -v`
+Expected: PASS (all 6).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add aidrin/batch.py aidrin/__init__.py tests/unit/test_summarize_files.py
+git commit -m "feat(core): summarize_files batch structural overview"
+```
+
+---
+
+## Milestone 2 — Web file-list store + active-file shim
+
+Server-side `uploaded_files` (avoids the cookie-size limit) and the compatibility shim.
+
+### Task 3: File-list store + `set_active_file`
+
+**Files:**
+- Modify: `web/routes/utils.py`
+- Test: `tests/integration/test_files_routes.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/integration/test_files_routes.py
+def test_set_active_file_mirrors_legacy_keys(app):
+    from web.routes.utils import (
+        save_uploaded_files, set_active_file, get_uploaded_files,
+    )
+    with app.test_request_context("/"):
+        from flask import session
+        save_uploaded_files([
+            {"id": "f1", "name": "a.csv", "type": ".csv",
+             "path": "/tmp/a.csv", "source": "local"},
+            {"id": "f2", "name": "b.csv", "type": ".csv",
+             "path": "/tmp/b.csv", "source": "local"},
+        ])
+        ok = set_active_file("f2")
+        assert ok is True
+        assert session["active_file_id"] == "f2"
+        # Legacy keys mirror the active file so existing routes keep working:
+        assert session["uploaded_file_path"] == "/tmp/b.csv"
+        assert session["uploaded_file_name"] == "b.csv"
+        assert session["uploaded_file_type"] == ".csv"
+        assert len(get_uploaded_files()) == 2
+
+
+def test_set_active_globus_mirrors_globus_keys(app):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with app.test_request_context("/"):
+        from flask import session
+        save_uploaded_files([
+            {"id": "g1", "name": "r.csv", "type": ".csv",
+             "path": "/remote/r.csv", "source": "globus",
+             "endpoint_id": "ep-123"},
+        ])
+        set_active_file("g1")
+        assert session["uploaded_file_path"] == "/remote/r.csv"
+        assert session["globus_file_path"] == "/remote/r.csv"
+        assert session["globus_file_name"] == "r.csv"
+        assert session["globus_file_type"] == ".csv"
+        assert session["globus_endpoint_id"] == "ep-123"
+
+
+def test_set_active_unknown_id_returns_false(app):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with app.test_request_context("/"):
+        save_uploaded_files([])
+        assert set_active_file("nope") is False
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -v`
+Expected: FAIL — `ImportError: cannot import name 'save_uploaded_files'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add to `web/routes/utils.py` (after `get_current_user_id`):
+
+```python
+def _files_cache_key():
+    return f"uploaded_files:{get_current_user_id()}"
+
+
+def get_uploaded_files():
+    """Return the server-side list of uploaded files for the current user."""
+    return current_app.TEMP_RESULTS_CACHE.get(_files_cache_key(), [])
+
+
+def save_uploaded_files(files):
+    """Persist the file list server-side (kept out of the session cookie)."""
+    current_app.TEMP_RESULTS_CACHE[_files_cache_key()] = files
+
+
+def get_active_file():
+    """Return the active file entry dict, or None."""
+    active_id = session.get("active_file_id")
+    for f in get_uploaded_files():
+        if f["id"] == active_id:
+            return f
+    return None
+
+
+def set_active_file(file_id):
+    """Make file_id active and mirror its identity into the legacy session keys.
+
+    Returns True if the file exists, else False. For a Globus entry, also
+    repopulates the globus_* keys that the remote path + cache still read.
+    """
+    entry = next((f for f in get_uploaded_files() if f["id"] == file_id), None)
+    if entry is None:
+        return False
+    session["active_file_id"] = file_id
+    session["uploaded_file_path"] = entry["path"]
+    session["uploaded_file_name"] = entry["name"]
+    session["uploaded_file_type"] = entry["type"]
+    if entry.get("source") == "globus":
+        session["globus_file_path"] = entry["path"]
+        session["globus_file_name"] = entry["name"]
+        session["globus_file_type"] = entry["type"]
+        session["globus_endpoint_id"] = entry.get("endpoint_id")
+    else:
+        for k in ("globus_file_path", "globus_file_name",
+                  "globus_file_type", "globus_endpoint_id"):
+            session.pop(k, None)
+    return True
+
+
+def clear_uploaded_files():
+    """Remove the file list and all active/legacy file pointers."""
+    current_app.TEMP_RESULTS_CACHE.pop(_files_cache_key(), None)
+    for k in ("active_file_id", "uploaded_file_path", "uploaded_file_name",
+              "uploaded_file_type", "globus_file_path", "globus_file_name",
+              "globus_file_type", "globus_endpoint_id"):
+        session.pop(k, None)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -v`
+Expected: PASS (3).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/utils.py tests/integration/test_files_routes.py
+git commit -m "feat(web): server-side file list + active-file shim"
+```
+
+### Task 4: Re-key the metric cache to file_id
+
+**Files:**
+- Modify: `web/routes/utils.py` (`generate_metric_cache_key`, `store_result`), `web/routes/core.py` (`cached_result` lookup)
+- Test: `tests/integration/test_files_routes.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_cache_key_uses_active_file_id_not_display_name(app):
+    from web.routes.utils import save_uploaded_files, set_active_file, generate_metric_cache_key
+    with app.test_request_context("/"):
+        save_uploaded_files([
+            {"id": "f1", "name": "dup.csv", "type": ".csv", "path": "/a/dup.csv", "source": "local"},
+            {"id": "f2", "name": "dup.csv", "type": ".csv", "path": "/b/dup.csv", "source": "local"},
+        ])
+        set_active_file("f1")
+        k1 = generate_metric_cache_key("dup.csv", "classimbalance", classes="y")
+        set_active_file("f2")
+        k2 = generate_metric_cache_key("dup.csv", "classimbalance", classes="y")
+        assert k1 != k2  # same display name, different files → different keys
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py::test_cache_key_uses_active_file_id_not_display_name -v`
+Expected: FAIL — keys are equal (keyed on display name).
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `web/routes/utils.py`, change `generate_metric_cache_key`'s file part to prefer the active file id:
+
+```python
+def generate_metric_cache_key(file_name, metric_type, **params):
+    """Generate a user-specific cache key for metrics."""
+    user_id = get_current_user_id()
+    file_token = session.get("active_file_id") or file_name
+    cache_parts = [f"user:{user_id}", f"file:{file_token}"]
+    # ... (rest unchanged)
+```
+
+And in `store_result`, key the user-scoped copy by the same token:
+
+```python
+    file_token = session.get("active_file_id") or (
+        session.get("uploaded_file_name") or session.get("globus_file_name") or "unknown"
+    )
+    user_key = f"user:{user_id}:file:{file_token}:{metric_short}"
+```
+
+In `web/routes/core.py` `cached_result`, build the lookup key from `active_file_id` the same way (locate the `f"user:{user_id}:file:{file_name}:..."` construction and replace `file_name` with `session.get("active_file_id") or file_name`).
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -v`
+Expected: PASS. Also run the existing cache tests:
+Run: `.venv/bin/python -m pytest tests/integration -k cache -v`
+Expected: PASS (no regressions).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/utils.py web/routes/core.py
+git commit -m "fix(web): key metric cache by active file id"
+```
+
+---
+
+## Milestone 3 — File-management endpoints + multi-file upload
+
+### Task 5: `files` blueprint — list, activate, remove, summary
+
+**Files:**
+- Create: `web/routes/files.py`
+- Modify: `web/routes/__init__.py`
+- Test: `tests/integration/test_files_routes.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def _seed(app, client, entries):
+    from web.routes.utils import save_uploaded_files
+    with client.session_transaction() as sess:
+        sess["user_id"] = "u-test"
+    with app.test_request_context("/"):
+        from flask import session
+        session["user_id"] = "u-test"
+        save_uploaded_files(entries)
+
+
+def test_files_list_and_activate(app, client):
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": "/a.csv", "source": "local"},
+        {"id": "f2", "name": "b.csv", "type": ".csv", "path": "/b.csv", "source": "local"},
+    ])
+    r = client.get("/files")
+    data = r.get_json()
+    assert {f["id"] for f in data["files"]} == {"f1", "f2"}
+    r = client.post("/files/f2/activate")
+    assert r.get_json()["success"] is True
+    with client.session_transaction() as sess:
+        assert sess["active_file_id"] == "f2"
+
+
+def test_files_remove_active_activates_next(app, client, tmp_path):
+    p = tmp_path / "a.csv"; p.write_text("x\n1\n")
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": str(p), "source": "local"},
+        {"id": "f2", "name": "b.csv", "type": ".csv", "path": "/b.csv", "source": "local"},
+    ])
+    client.post("/files/f1/activate")
+    r = client.post("/files/f1/remove")
+    assert r.get_json()["success"] is True
+    with client.session_transaction() as sess:
+        assert sess["active_file_id"] == "f2"   # next file became active
+    assert not p.exists()                       # local file deleted from disk
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -k "files_list or remove_active" -v`
+Expected: FAIL — 404 (routes not registered).
+
+- [ ] **Step 3: Write minimal implementation**
+
+```python
+# web/routes/files.py
+"""File-management endpoints for multi-file batches."""
+
+import os
+
+from flask import Blueprint, jsonify
+
+from web.routes.utils import (
+    get_uploaded_files, save_uploaded_files, set_active_file, get_active_file,
+)
+
+files_bp = Blueprint("files", __name__)
+
+
+@files_bp.route("/files", methods=["GET"])
+def list_files():
+    from flask import session
+    files = get_uploaded_files()
+    public = [{k: f.get(k) for k in ("id", "name", "type", "source")} for f in files]
+    return jsonify({"files": public, "active_file_id": session.get("active_file_id")})
+
+
+@files_bp.route("/files/<file_id>/activate", methods=["POST"])
+def activate(file_id):
+    if set_active_file(file_id):
+        return jsonify({"success": True})
+    return jsonify({"success": False, "message": "Unknown file"}), 404
+
+
+@files_bp.route("/files/<file_id>/remove", methods=["POST"])
+def remove(file_id):
+    from flask import session
+    files = get_uploaded_files()
+    entry = next((f for f in files if f["id"] == file_id), None)
+    if entry is None:
+        return jsonify({"success": False, "message": "Unknown file"}), 404
+    # Delete the local file from disk (not remote Globus files).
+    if entry.get("source") == "local":
+        try:
+            if entry["path"] and os.path.exists(entry["path"]):
+                os.remove(entry["path"])
+        except OSError:
+            pass
+    remaining = [f for f in files if f["id"] != file_id]
+    save_uploaded_files(remaining)
+    if session.get("active_file_id") == file_id:
+        if remaining:
+            set_active_file(remaining[0]["id"])
+        else:
+            from web.routes.utils import clear_uploaded_files
+            clear_uploaded_files()
+    return jsonify({"success": True})
+```
+
+Register it in `web/routes/__init__.py` (follow the existing `register_blueprints` pattern — import `files_bp` and add `app.register_blueprint(files_bp)`).
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/files.py web/routes/__init__.py tests/integration/test_files_routes.py
+git commit -m "feat(web): files blueprint (list/activate/remove)"
+```
+
+### Task 6: `/files/summary` endpoint
+
+**Files:**
+- Modify: `web/routes/files.py`
+- Test: `tests/integration/test_files_routes.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_files_summary_local(app, client, tmp_path):
+    a = tmp_path / "a.csv"; a.write_text("x,y\n1,2\n3,4\n")
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": str(a), "source": "local"},
+    ])
+    r = client.get("/files/summary")
+    data = r.get_json()
+    assert data["totals"]["file_count"] == 1
+    row = data["files"][0]
+    assert row["records"] == 2 and row["features"] == 2
+    assert row["source"] == "local"
+    assert "completeness" not in row          # no metrics in phase 1
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py::test_files_summary_local -v`
+Expected: FAIL — 404.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add to `web/routes/files.py`:
+
+```python
+@files_bp.route("/files/summary", methods=["GET"])
+def summary():
+    import aidrin
+    files = get_uploaded_files()
+    local = [f for f in files if f.get("source") == "local"]
+    globus = [f for f in files if f.get("source") == "globus"]
+
+    local_summary = aidrin.summarize_files(
+        [(f["path"], f["name"], f["type"]) for f in local]
+    )
+    # decorate local rows with source + id (sorted by name later in JS)
+    rows = []
+    for f, row in zip(local, local_summary["files"]):
+        rows.append({**row, "id": f["id"], "source": "local"})
+    # Globus rows: metadata now; records/features fetched async by the client.
+    for f in globus:
+        rows.append({
+            "id": f["id"], "name": f["name"], "type": f["type"], "source": "globus",
+            "records": None, "features": None, "size_bytes": None,
+            "status": "remote", "error": None,
+        })
+    totals = dict(local_summary["totals"])
+    totals["file_count"] = len(files)
+    totals["by_source"] = {
+        "local": len(local), "globus": len(globus),
+    }
+    return jsonify({"files": rows, "totals": totals})
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_files_routes.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/files.py tests/integration/test_files_routes.py
+git commit -m "feat(web): /files/summary batch overview endpoint"
+```
+
+### Task 7: Multi-file upload in `/inspector`
+
+**Files:**
+- Modify: `web/routes/core.py`
+- Test: `tests/integration/test_multi_upload.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/integration/test_multi_upload.py
+import io
+
+
+def _upload(client, names):
+    data = {}
+    files = [(io.BytesIO(b"a,b\n1,2\n3,4\n"), n) for n in names]
+    data["file"] = files
+    return client.post("/inspector", data=data,
+                       content_type="multipart/form-data", follow_redirects=False)
+
+
+def test_multi_upload_builds_list_and_activates_first(client):
+    r = _upload(client, ["one.csv", "two.csv"])
+    assert r.status_code == 302
+    files = client.get("/files").get_json()
+    assert {f["name"] for f in files["files"]} == {"one.csv", "two.csv"}
+    # first (by name) is active
+    assert files["active_file_id"] is not None
+
+
+def test_upload_infers_type_from_extension(client):
+    _upload(client, ["data.csv"])
+    f = client.get("/files").get_json()["files"][0]
+    assert f["type"] == ".csv"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py -v`
+Expected: FAIL — only one file stored / no `/files` list populated.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `web/routes/core.py`, replace the single-file save block in `inspector()` POST with multi-file handling:
+
+```python
+    if request.method == "POST":
+        from web.routes.utils import (
+            save_uploaded_files, get_uploaded_files, set_active_file,
+        )
+        from aidrin.file_handling.file_parser import infer_file_type
+        uploads = request.files.getlist("file")
+        uploads = [u for u in uploads if u and u.filename]
+        if uploads:
+            clear_all_user_cache()
+            entries = get_uploaded_files()  # append to any existing batch
+            existing_ids = {e["id"] for e in entries}
+            new_entries = []
+            for up in uploads:
+                display_name = up.filename
+                stored = f"{uuid.uuid4().hex}_{secure_filename(up.filename)}"
+                path = os.path.join(current_app.config["UPLOAD_FOLDER"], stored)
+                up.save(path)
+                entry = {
+                    "id": uuid.uuid4().hex,
+                    "name": display_name,
+                    "type": infer_file_type(display_name) or "",
+                    "path": path,
+                    "source": "local",
+                }
+                entries.append(entry)
+                new_entries.append(entry)
+            save_uploaded_files(entries)
+            # activate the first NEW file (by name) so the user lands meaningfully
+            first = sorted(new_entries, key=lambda e: e["name"].lower())[0]
+            set_active_file(first["id"])
+            return redirect(url_for("core.inspector"))
+```
+
+(Keep the existing GET rendering; later tasks make it land on the overview.)
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py -v`
+Expected: PASS. Also run existing inspector tests:
+Run: `.venv/bin/python -m pytest tests/integration/test_inspector.py tests/integration/test_inspector_upload.py -v`
+Expected: PASS (single-file upload still works — one-item list).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/core.py tests/integration/test_multi_upload.py
+git commit -m "feat(web): accept multiple files on upload, infer types"
+```
+
+### Task 8: Globus-aware stale-session check
+
+**Files:**
+- Modify: `web/routes/core.py`
+- Test: `tests/integration/test_multi_upload.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_globus_active_file_not_wiped_by_local_existence_check(app, client):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with client.session_transaction() as sess:
+        sess["user_id"] = "u-g"
+    with app.test_request_context("/"):
+        from flask import session
+        session["user_id"] = "u-g"
+        save_uploaded_files([{
+            "id": "g1", "name": "r.csv", "type": ".csv",
+            "path": "/remote/only/r.csv", "source": "globus", "endpoint_id": "ep",
+        }])
+        set_active_file("g1")
+    # GET inspector must NOT clear the session just because the remote path
+    # doesn't exist locally.
+    r = client.get("/inspector")
+    assert r.status_code == 200
+    with client.session_transaction() as sess:
+        assert sess.get("active_file_id") == "g1"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py::test_globus_active_file_not_wiped_by_local_existence_check -v`
+Expected: FAIL — session cleared (active_file_id gone) because `os.path.exists` is False.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `web/routes/core.py` `inspector()`, guard the stale-session validation so Globus files bypass the local existence check:
+
+```python
+    from web.routes.utils import get_active_file
+    active = get_active_file()
+    is_globus = bool(active and active.get("source") == "globus")
+    if uploaded_file_path and not is_globus and (
+        not os.path.exists(uploaded_file_path) or not file_type
+    ):
+        # ... existing stale-session clearing ...
+```
+
+(Apply the same `is_globus` bypass to the other `os.path.exists(uploaded_file_path)` guards used for rendering in this route.)
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py tests/integration/test_inspector.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/core.py
+git commit -m "fix(web): don't wipe active Globus file on local existence check"
+```
+
+---
+
+## Milestone 4 — Limits (size cap + file count)
+
+### Task 9: `MAX_CONTENT_LENGTH`, `AIDRIN_MAX_UPLOAD_FILES`, 413 handler
+
+**Files:**
+- Modify: `web/__init__.py`, `web/routes/core.py`
+- Test: `tests/integration/test_multi_upload.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_too_many_files_rejected(client, app):
+    app.config["AIDRIN_MAX_UPLOAD_FILES"] = 2
+    r = _upload(client, ["a.csv", "b.csv", "c.csv"])
+    data = r.get_json() if r.is_json else None
+    assert r.status_code == 400
+    assert data and data["success"] is False
+    assert "50" in data["message"] or "many" in data["message"].lower() or "2" in data["message"]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py::test_too_many_files_rejected -v`
+Expected: FAIL — 3 files accepted (302), not rejected.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `web/__init__.py` `create_app()`, after `app.config.from_prefixed_env()`:
+
+```python
+    try:
+        max_upload_mb = int(os.environ.get("AIDRIN_MAX_UPLOAD_MB", 1024))
+    except ValueError:
+        max_upload_mb = 1024
+    app.config["MAX_CONTENT_LENGTH"] = max_upload_mb * 1024 * 1024
+    try:
+        app.config["AIDRIN_MAX_UPLOAD_FILES"] = int(
+            os.environ.get("AIDRIN_MAX_UPLOAD_FILES", 50)
+        )
+    except ValueError:
+        app.config["AIDRIN_MAX_UPLOAD_FILES"] = 50
+
+    @app.errorhandler(413)
+    def _too_large(error):
+        from flask import jsonify, request
+        msg = "Upload too large for the server limit."
+        if request.accept_mimetypes.accept_json and not request.accept_mimetypes.accept_html:
+            return jsonify({"success": False, "message": msg}), 413
+        return msg, 413
+```
+
+In `core.py` `inspector()` POST, after collecting `uploads` and before saving:
+
+```python
+            max_files = current_app.config.get("AIDRIN_MAX_UPLOAD_FILES", 50)
+            if len(get_uploaded_files()) + len(uploads) > max_files:
+                return jsonify({
+                    "success": False,
+                    "message": f"Too many files. The maximum is {max_files} per batch.",
+                }), 400
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_multi_upload.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/__init__.py web/routes/core.py
+git commit -m "feat(web): upload size cap + AIDRIN_MAX_UPLOAD_FILES=50 + 413"
+```
+
+---
+
+## Milestone 5 — Globus unification
+
+### Task 10: Globus selection appends to the shared list
+
+**Files:**
+- Modify: `web/routes/globus.py`
+- Test: `tests/integration/test_globus.py`
+
+- [ ] **Step 1: Write the failing test** (mock transfer; assert the selected file lands in `/files`)
+
+```python
+def test_globus_selection_appends_to_shared_list(app, client, monkeypatch):
+    # The route that records a chosen Globus file should append an entry to the
+    # shared uploaded_files list with source="globus" and endpoint_id.
+    from web.routes.utils import get_uploaded_files
+    with client.session_transaction() as sess:
+        sess["user_id"] = "u-gx"
+        sess["globus_authenticated"] = True
+    # POST the existing "select file" route with endpoint + path + name + type
+    r = client.post("/globus/select-file", json={
+        "endpoint_id": "ep-9", "file_path": "/remote/x.csv",
+        "file_name": "x.csv", "file_type": ".csv",
+    })
+    assert r.status_code in (200, 302)
+    with app.test_request_context("/"):
+        from flask import session
+        session["user_id"] = "u-gx"
+        names = [f["name"] for f in get_uploaded_files()]
+    assert "x.csv" in names
+```
+
+> Note: adjust the route path/payload to match the actual Globus select endpoint in `web/routes/globus.py` (around line 198 where `globus_file_*` are set). The test asserts the **new** behavior: in addition to (or instead of) setting `globus_file_*` directly, it appends to the shared list and calls `set_active_file`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_globus.py::test_globus_selection_appends_to_shared_list -v`
+Expected: FAIL — name not in the shared list.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `web/routes/globus.py`, where a selected Globus file currently sets
+`session["globus_file_path"/name/type"]` and `globus_endpoint_id` (~line 198),
+replace that with an append to the shared list + activate:
+
+```python
+    from web.routes.utils import get_uploaded_files, save_uploaded_files, set_active_file
+    import uuid
+    entries = get_uploaded_files()
+    entry = {
+        "id": uuid.uuid4().hex,
+        "name": file_name, "type": file_type, "path": file_path,
+        "source": "globus", "endpoint_id": endpoint_id,
+    }
+    entries.append(entry)
+    save_uploaded_files(entries)
+    set_active_file(entry["id"])   # repopulates globus_* keys via the shim
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `.venv/bin/python -m pytest tests/integration/test_globus.py -v`
+Expected: PASS (existing Globus tests still pass — the shim sets the same `globus_*` keys they rely on).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/routes/globus.py tests/integration/test_globus.py
+git commit -m "feat(web): Globus selections feed the shared file list"
+```
+
+---
+
+## Milestone 6 — Frontend (AJAX upload, switcher, batch overview)
+
+> These tasks touch templates/JS that aren't unit-tested in this repo. Verify each
+> with the running app (`flask --app 'web:create_app()' run --debug`) and keep
+> prettier clean: `npx prettier --check web/static/js web/static/css`.
+
+### Task 11: Multi-file dropzone + remove the type `<select>`
+
+**Files:**
+- Modify: `web/templates/_components/upload_panel.html`, `web/static/js/main.js`
+
+- [ ] **Step 1: Edit the template** — add `multiple` and drop the select.
+
+In `web/templates/_components/upload_panel.html`: delete the `<label for="fileTypeSelector">` + `<select id="fileTypeSelector">…</select>` block, and change the file input to:
+
+```html
+<input id="file" name="file" type="file" multiple class="hidden"
+       required onchange="uploadForm();" />
+```
+
+- [ ] **Step 2: Rewrite `uploadForm()` for AJAX multi-file** in `web/static/js/main.js`:
+
+```javascript
+function uploadForm() {
+  const form = document.getElementById("uploadForm");
+  const fileInput = document.getElementById("file");
+  if (!fileInput.files || fileInput.files.length === 0) {
+    if (typeof showToast === "function")
+      showToast("Please select at least one file", "error");
+    return;
+  }
+  const data = new FormData();
+  for (const f of fileInput.files) data.append("file", f);
+  fetch(form.action, { method: "POST", body: data })
+    .then((r) => {
+      if (r.redirected) {
+        window.location.href = r.url;
+        return null;
+      }
+      return r.json();
+    })
+    .then((body) => {
+      if (body && body.success === false && typeof showToast === "function")
+        showToast(body.message || "Upload failed", "error");
+    })
+    .catch((err) => {
+      if (typeof showToast === "function")
+        showToast("Upload failed: " + err.message, "error");
+    });
+}
+```
+
+- [ ] **Step 3: Verify in the app** — upload 2–3 files; confirm the page lands on the inspector and `/files` lists them. Check prettier.
+
+Run: `npx prettier --check web/static/js`
+Expected: "All matched files use Prettier code style!"
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add web/templates/_components/upload_panel.html web/static/js/main.js
+git commit -m "feat(ui): multi-file AJAX upload; drop manual type dropdown"
+```
+
+### Task 12: File switcher component
+
+**Files:**
+- Create: `web/templates/_components/file_switcher.html`
+- Modify: `web/templates/inspector.html` (include it), `web/static/js/inspector.js`
+
+- [ ] **Step 1: Create the switcher markup** — a container the JS fills:
+
+```html
+<!-- web/templates/_components/file_switcher.html -->
+<div id="file-switcher" class="px-3 py-2 border-b border-gray-200 dark:border-gray-700">
+  <div class="text-xs font-semibold uppercase text-gray-500 mb-2">Files</div>
+  <ul id="file-switcher-list" class="space-y-1"></ul>
+</div>
+```
+
+- [ ] **Step 2: Include it** in `web/templates/inspector.html` inside the sidebar
+(near the top, only when `uploaded_file_path`): `{% include '_components/file_switcher.html' %}`.
+
+- [ ] **Step 3: Render + wire it** in `web/static/js/inspector.js` (call from `initWorkspace()`):
+
+```javascript
+function loadFileSwitcher() {
+  fetch("/files")
+    .then((r) => r.json())
+    .then((data) => {
+      const ul = document.getElementById("file-switcher-list");
+      if (!ul) return;
+      const files = [...data.files].sort((a, b) =>
+        a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+      );
+      ul.innerHTML = "";
+      files.forEach((f) => {
+        const li = document.createElement("li");
+        const active = f.id === data.active_file_id;
+        li.className =
+          "flex items-center gap-2 px-2 py-1 rounded cursor-pointer text-sm " +
+          (active
+            ? "bg-blue-50 text-blue-700 dark:bg-blue-900/30"
+            : "hover:bg-gray-100 dark:hover:bg-gray-700");
+        li.innerHTML =
+          `<span class="truncate flex-1">${f.name}</span>` +
+          `<span class="text-xs text-gray-400">${f.type || "?"}</span>`;
+        li.addEventListener("click", () => activateFile(f.id));
+        ul.appendChild(li);
+      });
+    });
+}
+
+function activateFile(fileId) {
+  fetch(`/files/${fileId}/activate`, { method: "POST" })
+    .then((r) => r.json())
+    .then((b) => {
+      if (b.success) window.location.reload();
+    });
+}
+```
+
+- [ ] **Step 4: Verify in the app** — upload several files; confirm the list shows sorted, the active one highlighted, and clicking switches the active file (page reloads on the new file). Check prettier.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/templates/_components/file_switcher.html web/templates/inspector.html web/static/js/inspector.js
+git commit -m "feat(ui): file switcher sidebar"
+```
+
+### Task 13: Batch Overview panel (default landing) + async Globus counts
+
+**Files:**
+- Create: `web/templates/_panels/_batch_overview.html`
+- Modify: `web/templates/inspector.html` (include panel + default to it), `web/static/js/inspector.js`
+
+- [ ] **Step 1: Create the panel markup**:
+
+```html
+<!-- web/templates/_panels/_batch_overview.html -->
+<div id="panel-batch-overview" class="metric-panel">
+  <h2 class="text-lg font-semibold mb-3">Batch Overview</h2>
+  <div id="batch-totals" class="grid grid-cols-2 sm:grid-cols-4 gap-3 mb-4"></div>
+  <div class="overflow-x-auto rounded-lg shadow-sm">
+    <table class="w-full text-sm text-left">
+      <thead class="text-xs uppercase bg-gray-50 dark:bg-gray-700">
+        <tr>
+          <th class="px-3 py-2">File</th><th class="px-3 py-2">Type</th>
+          <th class="px-3 py-2">Source</th><th class="px-3 py-2 text-right">Records</th>
+          <th class="px-3 py-2 text-right">Features</th><th class="px-3 py-2 text-right">Size</th>
+          <th class="px-3 py-2">Status</th>
+        </tr>
+      </thead>
+      <tbody id="batch-rows"></tbody>
+    </table>
+  </div>
+</div>
+```
+
+- [ ] **Step 2: Include + default to it** in `web/templates/inspector.html`:
+add `{% include '_panels/_batch_overview.html' %}` to `#panels-container`, and in
+the `DOMContentLoaded` script call `showPanel('batch-overview')` (instead of a
+metric panel) when `uploaded_file_path` and not `globus_mode`, then
+`loadBatchOverview()` and `loadFileSwitcher()`.
+
+- [ ] **Step 3: Render the overview** in `web/static/js/inspector.js`:
+
+```javascript
+function fmtBytes(n) {
+  if (!n && n !== 0) return "—";
+  const u = ["B", "KB", "MB", "GB"];
+  let i = 0, v = n;
+  while (v >= 1024 && i < u.length - 1) { v /= 1024; i++; }
+  return `${v.toFixed(v < 10 && i > 0 ? 1 : 0)} ${u[i]}`;
+}
+
+function loadBatchOverview() {
+  fetch("/files/summary")
+    .then((r) => r.json())
+    .then((data) => {
+      const t = data.totals;
+      const totals = document.getElementById("batch-totals");
+      if (totals)
+        totals.innerHTML = [
+          ["Files", t.file_count],
+          ["Loaded OK", t.ok_count ?? "—"],
+          ["Failed", t.error_count ?? "—"],
+          ["Total records", (t.total_records ?? 0).toLocaleString()],
+        ]
+          .map(
+            ([k, v]) =>
+              `<div class="p-3 bg-gray-50 dark:bg-gray-700/50 rounded text-center">
+                 <div class="text-2xl font-bold">${v}</div>
+                 <div class="text-xs uppercase text-gray-500">${k}</div>
+               </div>`,
+          )
+          .join("");
+
+      const rows = [...data.files].sort((a, b) =>
+        a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+      );
+      const tbody = document.getElementById("batch-rows");
+      tbody.innerHTML = "";
+      rows.forEach((f) => {
+        const tr = document.createElement("tr");
+        tr.className = "border-b dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-700/50 cursor-pointer";
+        const isGlobus = f.source === "globus";
+        const recCell = isGlobus
+          ? `<span class="globus-count" data-id="${f.id}">loading…</span>`
+          : f.records ?? "—";
+        const featCell = isGlobus
+          ? `<span class="globus-feat" data-id="${f.id}">…</span>`
+          : f.features ?? "—";
+        const status =
+          f.status === "ok"
+            ? "✅"
+            : f.status === "remote"
+              ? "🌐 remote"
+              : `⚠️ ${f.error || "error"}`;
+        tr.innerHTML =
+          `<td class="px-3 py-2">${f.name}</td><td class="px-3 py-2">${f.type || "?"}</td>` +
+          `<td class="px-3 py-2">${f.source}</td>` +
+          `<td class="px-3 py-2 text-right">${recCell}</td>` +
+          `<td class="px-3 py-2 text-right">${featCell}</td>` +
+          `<td class="px-3 py-2 text-right">${fmtBytes(f.size_bytes)}</td>` +
+          `<td class="px-3 py-2">${status}</td>`;
+        tr.addEventListener("click", () => activateFile(f.id));
+        tbody.appendChild(tr);
+        if (isGlobus) fetchGlobusCount(f);
+      });
+    });
+}
+
+// Reuse the existing remote summary to fill a Globus row's counts.
+function fetchGlobusCount(f) {
+  fetchGlobusSummaryFor(f.id, f).then((summary) => {
+    if (!summary) return;
+    const rec = document.querySelector(`.globus-count[data-id="${f.id}"]`);
+    const feat = document.querySelector(`.globus-feat[data-id="${f.id}"]`);
+    if (rec) rec.textContent = (summary.records_count ?? "—").toLocaleString();
+    if (feat) feat.textContent = summary.features_count ?? "—";
+  });
+}
+```
+
+> `fetchGlobusSummaryFor(id, entry)` wraps the existing remote-summary call
+> (the same Globus Compute submit/poll used by `fetchGlobusSummary()`),
+> activating the entry's endpoint/path and returning the cached/awaited
+> `{records_count, features_count}`. Factor it from the current
+> `fetchGlobusSummary()` so both share the cache (`globus_summary:...`).
+
+- [ ] **Step 4: Verify in the app** — upload a mixed batch; confirm the overview is the landing view, totals + table render sorted by name, failed files show inline errors, and (with Globus configured) remote rows fill in their counts. Check prettier.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add web/templates/_panels/_batch_overview.html web/templates/inspector.html web/static/js/inspector.js
+git commit -m "feat(ui): batch overview landing view with async Globus counts"
+```
+
+---
+
+## Final Verification
+
+- [ ] Run the whole suite: `.venv/bin/python -m pytest tests/ -q` — all pass.
+- [ ] Prettier: `npx prettier --check web/static/js web/static/css` — clean.
+- [ ] Manual smoke: upload 1 file (single-file UX unchanged); upload 5 files (overview + switcher); remove the active file (next activates); a corrupt file shows an inline error; (if Globus configured) a remote file streams its counts.
+
+## Self-Review notes (for the implementer)
+
+- The `parquet-support` `load_dataframe` friendly-error mapping is **not** required here: `summarize_files` handles `read_file`'s tri-state itself, and the active-file detail routes are unchanged on this branch. If `parquet-support` merges first, no conflict — both only add helpers.
+- `infer_file_type` returns a READER_MAP key; when a real extension suffix is ever needed (e.g. `custom.py:137`), use `file_extension(name)` instead. Out of scope here but noted.
diff --git a/docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md b/docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md
new file mode 100644
index 00000000..1ab921c8
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md
@@ -0,0 +1,328 @@
+# Multi-File Batch Analysis — Design
+
+**Date:** 2026-06-04
+**Branch:** `multi-file-analysis` (off `develop`)
+**Status:** Approved design — pending implementation plan
+
+## Summary
+
+Let users analyze **multiple files at once** (a batch of independent datasets,
+with possibly different schemas) instead of a single file. Phase 1 treats each
+file independently: users analyze one **active file** at a time using the
+existing inspector, and can view a **combined cross-file summary**. A later
+**phase 2** will add relational/different-schema handling (joins across files);
+this design deliberately leaves the seams for it but does not implement it.
+
+## Goals (Phase 1)
+
+- Upload / select **many files** via local multi-select + drag-drop, and via
+  the existing **Globus** remote integration.
+- Per-file format is **inferred from the file extension** (mixed types allowed);
+  the manual "File type" dropdown is removed.
+- An **active-file switcher**: one file is active at a time and the entire
+  current inspector (summary, metrics, visualizations) operates on it.
+- A **combined summary**: a per-file overview table plus aggregate totals.
+- Local uploads and Globus transfers feed **one** source-agnostic file list.
+- The batch/aggregation logic is a **session-free core primitive** reused by the
+  web UI, the library, and the CLI.
+
+## Non-Goals (Phase 1 — YAGNI)
+
+- Directory upload (`webkitdirectory`) and zip-archive upload.
+- Same-schema column-level comparison across files.
+- Simultaneous side-by-side metric rendering for multiple files.
+- Relational joins / multi-table modeling (**phase 2**).
+
+## Background / Current State
+
+The single-file assumption is deep in the web layer:
+
+- The Flask session holds `uploaded_file_path` / `uploaded_file_name` /
+  `uploaded_file_type` (a single file). These keys are referenced ~74 times
+  across `web/routes/{core,metrics,custom,llm}.py`, `web/routes/utils.py`, and
+  the inspector templates.
+- `read_file((path, name, type))` returns one DataFrame; there are ~10
+  `read_file` / `load_dataframe` call sites.
+- The metric result cache key is built from a single `file_name`
+  (`generate_metric_cache_key`).
+- **Globus is remote *compute*, not just a remote file source.** `web/globus.py`
+  serialises `remote_metric_runner` and ships it to a Globus Compute **endpoint**,
+  where `aidrin` runs the metric next to the data. A Globus file's
+  `globus_file_path` is a path **on the remote endpoint**, not on the AIDRIN
+  server. It has its own session keys (`globus_file_path/name/type`,
+  `globus_endpoint_id`), its own execution path, and its own frontend mode
+  (`globus_mode` / `AIDRIN_GLOBUS_*` / `fetchGlobusSummary`). This execution path
+  must remain — local metric routes cannot run on a remote path.
+- The library API (`aidrin.calculate_*(file_info)`) is **session-free** and
+  already supports multiple files by iteration. The CLI/headless mode (on other
+  branches) is likewise config/arg driven and session-free.
+
+**Note on dependencies (two separate branches):**
+- The per-file error handling mirrors the `load_dataframe` helper + friendly-error
+  mapping on the **`parquet-support`** branch (`web/routes/utils.py`). It is a
+  non-trivial helper; if this feature lands first, replicate it here.
+- `MAX_CONTENT_LENGTH` (the request-size cap this spec relies on) is on the
+  **`upload-size-limit`** branch (`web/__init__.py`), *not* `parquet-support`. It
+  is absent on `develop`/this branch today.
+
+These are independent branches; neither is on `develop` yet, so this design must
+not assume either exists until merged.
+
+## Architecture: Two Layers
+
+The central decision is to split the feature into a presentation-agnostic core
+and a web-only state layer.
+
+### Layer 1 — Core batch primitive (session-free)
+
+A new `aidrin` function operates purely on a list of `file_info` tuples:
+
+```python
+def summarize_files(file_infos):
+    """Return {"files": [per_file, ...], "totals": {...}}.
+
+    per_file = {
+        "name": str, "type": str,
+        "records": int|None, "features": int|None,  # from a single read; NO metrics
+        "size_bytes": int|None,
+        "status": "ok"|"error",
+        "error": str|None,            # short message when status == "error"
+    }
+    totals = {
+        "file_count": int,
+        "ok_count": int, "error_count": int,
+        "total_records": int,
+        "by_type": {type: count, ...},
+    }
+    """
+```
+
+- Reads each file via `read_file`, which returns **`DataFrame | None | str`**.
+  `summarize_files` must branch on all three: a `DataFrame` → `status:"ok"`;
+  `None` (unsupported/missing name) or a `str` (read error message) →
+  `status:"error"` with that message. (This is the same tri-state the
+  `load_dataframe` helper handles — see dependency note.)
+- **Phase 1 computes NO metrics** — only structural facts available from a single
+  read: `records` (`len(df)`), `features` (`len(df.columns)`), `size_bytes`
+  (`os.path.getsize`, no parse), and load `status`. Completeness/duplicates/etc.
+  are deliberately excluded here; they remain in the per-file Data Quality view.
+  (Keeping metrics out also avoids the row-wise-vs-cell-wise completeness
+  question entirely for now.)
+- A file that fails to load becomes a `status: "error"` row with a short
+  message — **one bad file never aborts the batch**.
+- **Synchronous cost:** summarizing up to 50 files (combined up to the request
+  cap) can be slow. Phase 1 reads each file once; if this proves too heavy,
+  apply a per-file row/size cap for the summary pass (note, not yet enforced).
+- Lives in the core package (e.g. `aidrin/batch.py`), re-exported from
+  `aidrin/__init__.py`. Consumed by the web combined-summary endpoint, the CLI's
+  batch mode, and library users.
+
+### Layer 2 — Web active-file state (Approach A shim)
+
+A presentation-only construct in the Flask session:
+
+- `uploaded_files`: list of
+  `{"id": uuid, "name": str, "type": str, "path": str, "source": "local"|"globus"}`.
+  Globus entries additionally carry `endpoint_id` (and the remote path lives in
+  `path`). The previously top-level `globus_file_*` keys are **folded into the
+  entry**, not kept separately. **Stored server-side** (keyed by `user_id`), not
+  in the cookie — see Limits (session storage).
+- `session["active_file_id"]`: the currently selected file's id (small pointer,
+  kept in the cookie).
+- A `set_active_file(file_id)` helper sets `active_file_id` **and writes the
+  active file's path/name/type into the existing `uploaded_file_*` session
+  keys**. For a **Globus** entry it must ALSO repopulate the exact legacy keys
+  that downstream code still reads — `globus_file_path`, `globus_file_name`,
+  `globus_file_type`, and `globus_endpoint_id` — because `core.py:118-122,179-182,288`,
+  `utils.py:119`, `llm.py:218`, `routes/globus.py:131-143`, and the
+  `globus_summary:{endpoint_id}:{file_path}` cache key all depend on them. So
+  "folding `globus_file_*` into the list entry" means they are no longer the
+  *source of truth* (the list is) — but the shim re-derives them for the active
+  file so existing consumers keep working.
+
+This compatibility shim means every existing **local** metric route, the ~10
+read sites, and the templates keep working **unchanged** — they always operate on
+the active file. Execution stays **dispatched by source**: a local active file
+runs through the local routes; a Globus active file runs through the existing
+`remote_metric_runner` path. Only the upload/Globus entry points and a few new
+file-management endpoints need to be multi-file aware.
+
+## Data Flow
+
+1. **Upload (local):** `POST /inspector` reads `request.files.getlist("file")`.
+   For each file: enforce count/size limits → save with a unique stored name →
+   `infer_file_type(filename)` → append `{id, name, type, path, source:"local"}`
+   to `uploaded_files`. Set the first newly-added file active (via the shim).
+2. **Globus:** the Globus selection flow appends entries with `source:"globus"`
+   (carrying `endpoint_id` + remote `path`) to the **same** `uploaded_files`
+   list. The `globus_file_*` keys are folded into the entry. The **remote
+   execution path is unchanged** — activating a Globus file still dispatches
+   through `remote_metric_runner` (`globus_mode`), not the local routes.
+3. **Switch active file:** `POST /files/<id>/activate` → `set_active_file(id)` →
+   the frontend re-renders the inspector for the new active file, in local or
+   Globus mode depending on the entry's `source`.
+4. **Combined summary:** after a multi-file upload the inspector **lands on the
+   combined summary** (the batch overview), not a single file's panels.
+   `GET /files/summary`: **local** files go through `aidrin.summarize_files`
+   (one read → records, features, size, status — no metrics); the web route
+   decorates each row with `source`. **Globus** files appear immediately with
+   metadata (name, type, size, source); their records/features are fetched
+   **asynchronously** via the existing remote `_summary_statistics` (which already
+   returns `records_count`/`features_count`, `web/globus.py:144-145`) and stream
+   into the row when ready — reusing the `globus_summary:{endpoint_id}:{file_path}`
+   cache so already-viewed files are instant. Clicking any row activates that file
+   and drills into its per-file panels.
+5. **Metrics:** unchanged — they read the active file through the legacy keys
+   (local) or the restored Globus context (remote).
+
+## New / Changed Endpoints
+
+| Endpoint | Change |
+| --- | --- |
+| `POST /inspector` | Accept multiple files; build the list; infer types. |
+| `GET /files` | List `uploaded_files` (+ which is active) for the switcher. |
+| `POST /files/<id>/activate` | Set the active file. |
+| `POST /files/<id>/remove` | Remove a file (delete local file from disk + list). **If the removed file was active**, activate the next remaining file (or, if none remain, clear `uploaded_file_*` so the inspector returns to the upload panel). Always re-run `set_active_file`. |
+| `GET /files/summary` | Combined per-file overview + totals (local synchronous; Globus records/features fetched async via existing remote summary). |
+| Globus selection route | Append into the shared list (`source:"globus"`, `endpoint_id`); fold in `globus_file_*`. |
+| All metric / summary / feature routes | **Unchanged**; execution dispatched by source (local routes vs `remote_metric_runner`). |
+
+## Type Inference
+
+New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
+
+- Maps real extensions to reader keys via an explicit `EXTENSION_MAP`, resolving
+  the Excel quirk (`READER_MAP` currently uses the combined key
+  `".xls, .xlsb, .xlsx, .xlsm"`; the map points `.xls/.xlsb/.xlsx/.xlsm` at it).
+- Unknown extension → `None` → the file is listed with `status: "error"`
+  ("Unsupported file type") and cannot be made active.
+- **Caveat:** the inferred value is a READER_MAP *key*, which for Excel is the
+  combined string `".xls, .xlsb, .xlsx, .xlsm"` — and `uploaded_file_type` is
+  reused as a literal filename suffix in `custom.py:137`
+  (`remedied_{session_id}{file_type}`). That is already broken for Excel today;
+  this design must not make it worse — store a real extension alongside the
+  reader key (e.g. derive the suffix from the original filename, not the key).
+
+## Frontend (inspector)
+
+- **Upload dropzone:** add `multiple`; support multi-file drag-drop. **Remove**
+  the "File type" `<select>` (type is inferred). Note this is **not** a one-line
+  change: today the upload is a native full-page form POST → redirect
+  (`main.js:45` `form.submit()`, `core.py:58`). Multi-file upload with per-file
+  status/error rows implies an **AJAX upload** (`fetch` + `FormData`) and a
+  client-rendered file list — a real rewrite of `uploadForm()`. Removing the
+  `<select>` also drops its `accept`-attribute filtering and the existing
+  client-side "select a file type" validation guard (`main.js:31`); replace with
+  extension-based client validation.
+- **File switcher (top-bar selector):** the active-file chip already in the top
+  bar (`topbar.html`, the `{{ uploaded_file_name }}` block) becomes a
+  **searchable dropdown**. It shows the active file name + a count badge
+  (e.g. "3 ▾"); clicking opens a popover with a filter input and a scrollable
+  list of all files (name + type/status badge, active highlighted); click an
+  item → `POST /files/<id>/activate` → reload. This **replaces** the sidebar
+  file list (removed), so the sidebar stays focused on metric navigation. The
+  top-bar anchor is always visible and the searchable+scrollable list scales to
+  many files (virtualize/paginate for hundreds — out of phase-1 scope). The
+  Batch Overview table remains the place to browse/scan files (and the future
+  home for search/filter/bulk-remove). Reuses `GET /files` +
+  `POST /files/<id>/activate`; no new backend. With a single file it renders as
+  today (plain name, no dropdown affordance).
+- **Combined summary ("Batch Overview"):** the **default landing view** after a
+  multi-file upload. Two parts:
+  - **Totals strip** (cards): `# files`, `# loaded OK` / `# failed`,
+    `total records`, files-by-type, files-by-source, total size.
+  - **Per-file table**: columns **File · Type · Source · Records · Features ·
+    Size · Status** (no metrics column in phase 1), **sorted by file name**
+    (case-insensitive). Failed rows show the friendly error inline (`—` for
+    stats). Clicking a row activates that file → its per-file panels.
+  - **Local vs Globus rows:** local rows render fully on first paint (synchronous
+    read). Globus rows render with metadata immediately and a "loading…"
+    records/features cell that **fills in asynchronously** from the remote
+    `_summary_statistics` (cached per file). `total records` updates as remote
+    counts arrive.
+  - **Table + totals only** — no charts in phase 1.
+- **Globus panel:** allow selecting multiple remote files; each selected file is
+  appended to the shared list as a `source:"globus"` entry. Activating one keeps
+  the inspector in `globus_mode` (remote execution).
+
+## Caching
+
+- Per-file metric caching already works because the cache key includes the file.
+- **Change:** key the cache on the **unique stored filename / file_id** instead
+  of the display `file_name`, to prevent collisions when two files in a batch
+  share a display name. This must move **all four** file-name-derived sites
+  together or cached results become unretrievable: `generate_metric_cache_key`,
+  the `store_result` user-key (`user:{id}:file:{name}:{metric}`), the
+  `cached_result` lookup (`core.py:286-294`), and the `clear_all_user_cache`
+  prefix match. (Telemetry `trace_metric(file_name=...)` may keep the display
+  name — cosmetic only.)
+
+## Limits
+
+- `MAX_CONTENT_LENGTH` (from the `upload-size-limit` branch; default 1 GB) caps
+  the **whole** multipart request, bounding the combined batch size.
+- New `AIDRIN_MAX_UPLOAD_FILES` (default **50**) bounds the number of files per
+  batch.
+- **Enforcement ordering:** `MAX_CONTENT_LENGTH` is enforced by Flask **before**
+  the body is parsed (returns a bare 413); `AIDRIN_MAX_UPLOAD_FILES` can only be
+  checked **after** parsing `getlist("file")`. Add a friendly 413 handler and a
+  clear "too many files" message so the two limits don't produce confusing UX.
+- **Session storage (important):** Flask's default session is a client-side
+  signed cookie (~4 KB). A 50-entry `uploaded_files` list — especially with long
+  remote Globus paths — can exceed that and **silently drop the session**.
+  Therefore store `uploaded_files` **server-side** (e.g. in `TEMP_RESULTS_CACHE`
+  keyed by `user_id`), keeping only small pointers (`active_file_id`, the legacy
+  `uploaded_file_*`/`globus_file_*` shim values) in the cookie.
+
+## Error Handling
+
+- **Per-file load failure:** surfaced as a `status: "error"` row in the summary
+  with a short message; the batch continues. The active-file detail view shows
+  the friendly read error (existing `load_dataframe` behavior).
+- **Too many files / unsupported type:** clear, user-facing messages.
+- **Active Globus file vs. local existence check:** the inspector's stale-session
+  validation (`core.py:65-78`) and several routes guard on
+  `os.path.exists(uploaded_file_path)`. A Globus active file's path is **remote**,
+  so this is `False` on the AIDRIN server and would wrongly **wipe the session**.
+  Add a `source == "globus"` bypass to every such existence check (treat remote
+  files as present; let the Globus path handle reachability).
+- **Empty batch / no active file:** the inspector falls back to the upload panel
+  (existing stale-session handling generalizes to "no files").
+
+## Testing
+
+- **Core:** `summarize_files` — records/features/size/status + totals, mixed
+  types, a failing file among good ones, empty input, and `read_file` returning
+  each of `DataFrame`/`None`/`str`. Assert **no metric** fields are present
+  (records = `len(df)`, features = `len(df.columns)` only). `infer_file_type` —
+  each supported extension, Excel variants, unknown extension.
+- **Web (integration):** multi-file upload builds the list and sets an active
+  file; `activate` updates the legacy keys and an existing metric still works;
+  `/files/summary` shape + totals; `remove` deletes file + entry; **removing the
+  active file** activates the next (or returns to the upload panel); per-file
+  error appears in the summary without 500s; `AIDRIN_MAX_UPLOAD_FILES` enforced
+  (and ordering vs. the 413 size cap); cached metric results survive the file_id
+  re-key (store then retrieve).
+- **Globus:** multi-file selection appends to the shared list (mocked); a Globus
+  active file is **not** wiped by the local `os.path.exists` stale check, and the
+  shim repopulates `globus_file_*`/`globus_endpoint_id`; the batch overview
+  fills a Globus row's records/features from the remote `_summary_statistics`
+  result (mocked) and serves a second request from the `globus_summary` cache.
+- **Session storage:** a 50-file list with long remote paths persists (does not
+  overflow the cookie) — verifies the server-side storage decision.
+- Follow TDD (red → green) per the existing reader/route test patterns.
+
+## Phase 2 Seam (relational / different schemas)
+
+The `uploaded_files` list and the `summarize_files` primitive are the extension
+points. Phase 2 can add: schema fingerprinting, grouping files by schema,
+defining join keys across files, and cross-file/relational metrics — built on
+the same file list and core batch layer, without re-architecting phase 1.
+
+## Rollout / Compatibility
+
+- Single-file behavior is preserved: uploading one file yields a one-item list,
+  that file is active, and the experience is identical to today.
+- The shim keeps all existing routes/tests valid; changes concentrate in the
+  upload entry points, the new file-management endpoints, the Globus unification,
+  and the frontend switcher/summary.
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index daab1de8..3af5d4ba 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -9,7 +9,7 @@
 
 
 @pytest.fixture
-def app():
+def app(tmp_path):
     """Create a new Flask app instance for testing."""
     app = create_app()
     app.config.update(TESTING=True)
@@ -18,6 +18,18 @@ def app():
     app.config["CELERY"]["task_always_eager"] = True
     app.config["CELERY"]["task_eager_propagates"] = True
 
+    # Isolate runtime dirs from the real data/ folder so tests don't pollute it
+    # (uploads, the per-user file lists under <UPLOAD_FOLDER>/../filelists, and
+    # generated custom metrics).
+    uploads = tmp_path / "uploads"
+    custom_metrics = tmp_path / "custom_metrics"
+    remedy = custom_metrics / "remedy_data"
+    for d in (uploads, custom_metrics, remedy):
+        d.mkdir(parents=True, exist_ok=True)
+    app.config["UPLOAD_FOLDER"] = str(uploads)
+    app.config["CUSTOM_METRICS_FOLDER"] = str(custom_metrics)
+    app.config["REMEDY_FOLDER"] = str(remedy)
+
     return app
 
 
diff --git a/tests/integration/test_files_routes.py b/tests/integration/test_files_routes.py
new file mode 100644
index 00000000..c72718b1
--- /dev/null
+++ b/tests/integration/test_files_routes.py
@@ -0,0 +1,150 @@
+"""Tests for the server-side file list and active-file shim (Task 3)."""
+
+
+def test_set_active_file_mirrors_legacy_keys(app):
+    from web.routes.utils import (
+        save_uploaded_files, set_active_file, get_uploaded_files,
+    )
+    with app.test_request_context("/"):
+        from flask import session
+        save_uploaded_files([
+            {"id": "f1", "name": "a.csv", "type": ".csv",
+             "path": "/tmp/a.csv", "source": "local"},
+            {"id": "f2", "name": "b.csv", "type": ".csv",
+             "path": "/tmp/b.csv", "source": "local"},
+        ])
+        ok = set_active_file("f2")
+        assert ok is True
+        assert session["active_file_id"] == "f2"
+        assert session["uploaded_file_path"] == "/tmp/b.csv"
+        assert session["uploaded_file_name"] == "b.csv"
+        assert session["uploaded_file_type"] == ".csv"
+        assert len(get_uploaded_files()) == 2
+
+
+def test_set_active_globus_mirrors_globus_keys(app):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with app.test_request_context("/"):
+        from flask import session
+        save_uploaded_files([
+            {"id": "g1", "name": "r.csv", "type": ".csv",
+             "path": "/remote/r.csv", "source": "globus",
+             "endpoint_id": "ep-123"},
+        ])
+        set_active_file("g1")
+        assert session["uploaded_file_path"] == "/remote/r.csv"
+        assert session["globus_file_path"] == "/remote/r.csv"
+        assert session["globus_file_name"] == "r.csv"
+        assert session["globus_file_type"] == ".csv"
+        assert session["globus_endpoint_id"] == "ep-123"
+
+
+def test_set_active_local_clears_globus_keys(app):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with app.test_request_context("/"):
+        from flask import session
+        session["globus_file_path"] = "/old/remote.csv"
+        save_uploaded_files([
+            {"id": "f1", "name": "a.csv", "type": ".csv",
+             "path": "/tmp/a.csv", "source": "local"},
+        ])
+        set_active_file("f1")
+        assert "globus_file_path" not in session
+
+
+def test_set_active_unknown_id_returns_false(app):
+    from web.routes.utils import save_uploaded_files, set_active_file
+    with app.test_request_context("/"):
+        save_uploaded_files([])
+        assert set_active_file("nope") is False
+
+
+def test_cache_key_uses_active_file_id_not_display_name(app):
+    from web.routes.utils import (
+        save_uploaded_files, set_active_file, generate_metric_cache_key,
+    )
+    with app.test_request_context("/"):
+        save_uploaded_files([
+            {"id": "f1", "name": "dup.csv", "type": ".csv", "path": "/a/dup.csv", "source": "local"},
+            {"id": "f2", "name": "dup.csv", "type": ".csv", "path": "/b/dup.csv", "source": "local"},
+        ])
+        set_active_file("f1")
+        k1 = generate_metric_cache_key("dup.csv", "classimbalance", classes="y")
+        set_active_file("f2")
+        k2 = generate_metric_cache_key("dup.csv", "classimbalance", classes="y")
+        assert k1 != k2  # same display name, different files -> different keys
+
+
+def _seed(app, client, entries):
+    from web.routes.utils import save_uploaded_files
+    with client.session_transaction() as sess:
+        sess["user_id"] = "u-test"
+    with app.test_request_context("/"):
+        from flask import session
+        session["user_id"] = "u-test"
+        save_uploaded_files(entries)
+
+
+def test_files_list_and_activate(app, client):
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": "/a.csv", "source": "local"},
+        {"id": "f2", "name": "b.csv", "type": ".csv", "path": "/b.csv", "source": "local"},
+    ])
+    r = client.get("/files")
+    data = r.get_json()
+    assert {f["id"] for f in data["files"]} == {"f1", "f2"}
+    r = client.post("/files/f2/activate")
+    assert r.get_json()["success"] is True
+    with client.session_transaction() as sess:
+        assert sess["active_file_id"] == "f2"
+
+
+def test_files_activate_unknown_404(app, client):
+    _seed(app, client, [])
+    r = client.post("/files/nope/activate")
+    assert r.status_code == 404
+
+
+def test_files_remove_active_activates_next(app, client, tmp_path):
+    p = tmp_path / "a.csv"; p.write_text("x\n1\n")
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": str(p), "source": "local"},
+        {"id": "f2", "name": "b.csv", "type": ".csv", "path": "/b.csv", "source": "local"},
+    ])
+    client.post("/files/f1/activate")
+    r = client.post("/files/f1/remove")
+    assert r.get_json()["success"] is True
+    with client.session_transaction() as sess:
+        assert sess["active_file_id"] == "f2"
+    assert not p.exists()
+
+
+def test_files_summary_local(app, client, tmp_path):
+    a = tmp_path / "a.csv"; a.write_text("x,y\n1,2\n3,4\n")
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": str(a), "source": "local"},
+    ])
+    r = client.get("/files/summary")
+    data = r.get_json()
+    assert data["totals"]["file_count"] == 1
+    row = data["files"][0]
+    assert row["records"] == 2 and row["features"] == 2
+    assert row["source"] == "local"
+    assert row["id"] == "f1"
+    assert "completeness" not in row
+
+
+def test_files_summary_mixed_local_globus(app, client, tmp_path):
+    a = tmp_path / "a.csv"; a.write_text("x\n1\n")
+    _seed(app, client, [
+        {"id": "f1", "name": "a.csv", "type": ".csv", "path": str(a), "source": "local"},
+        {"id": "g1", "name": "r.csv", "type": ".csv", "path": "/remote/r.csv",
+         "source": "globus", "endpoint_id": "ep"},
+    ])
+    data = client.get("/files/summary").get_json()
+    assert data["totals"]["file_count"] == 2
+    assert data["totals"]["by_source"] == {"local": 1, "globus": 1}
+    g = next(f for f in data["files"] if f["id"] == "g1")
+    assert g["source"] == "globus"
+    assert g["records"] is None and g["features"] is None
+    assert g["status"] == "remote"
diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
new file mode 100644
index 00000000..a2a8dda4
--- /dev/null
+++ b/tests/integration/test_globus_multifile.py
@@ -0,0 +1,279 @@
+"""Tests that a Globus file selection (via /globus/submit) feeds the shared file list.
+
+This test patches the Globus SDK availability flag so the blueprint is registered
+even in environments where globus-compute-sdk is not installed, and mocks the
+external Globus calls so no real endpoint is needed.
+"""
+
+import os
+from unittest.mock import MagicMock, patch
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def globus_app():
+    """Flask app with the Globus blueprint force-registered via patching."""
+    import web.globus as _globus_mod
+    # Patch the availability flag at the module level BEFORE create_app() calls
+    # register_blueprints(), which checks is_globus_available() at import time.
+    _orig = _globus_mod._globus_available
+    _globus_mod._globus_available = True
+    try:
+        from web import create_app
+        app = create_app()
+        app.config.update(TESTING=True)
+        app.config["CELERY"]["task_always_eager"] = True
+        app.config["CELERY"]["task_eager_propagates"] = True
+        yield app
+    finally:
+        _globus_mod._globus_available = _orig
+
+
+@pytest.fixture
+def globus_client(globus_app):
+    """Test client for the app with the Globus blueprint registered."""
+    return globus_app.test_client()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _set_globus_auth(client):
+    """Set session state that the /globus/submit route requires."""
+    with client.session_transaction() as sess:
+        sess["globus_authenticated"] = True
+        sess["globus_tokens"] = {"fake_rs": {"access_token": "tok"}}
+
+
+def _get_uploaded_files_via_route(client):
+    """Return the file list from the /files endpoint."""
+    r = client.get("/files")
+    assert r.status_code == 200
+    return r.get_json()
+
+
+# ---------------------------------------------------------------------------
+# The actual test (must FAIL before implementation, PASS after)
+# ---------------------------------------------------------------------------
+
+
+def test_globus_submit_appends_to_file_list(globus_client):
+    """POSTing to /globus/submit should add the file to the shared file list
+    and mark it as the active file.
+    """
+    client = globus_client
+
+    # Arrange: authenticate and mock Globus SDK calls
+    _set_globus_auth(client)
+
+    mock_client = MagicMock()
+    fake_task_id = "task-abc-123"
+
+    with patch("web.routes.globus.get_compute_client", return_value=mock_client), \
+         patch("web.routes.globus.submit_metric", return_value=fake_task_id):
+        # Act: call the submit route with a sample Globus file selection
+        response = client.post(
+            "/globus/submit",
+            json={
+                "endpoint_id": "ep-test-uuid",
+                "file_path": "/remote/data/sample.csv",
+                "file_name": "sample.csv",
+                "file_type": ".csv",
+                "metric_name": "completeness",
+            },
+        )
+
+    # The route should still succeed (task submitted)
+    assert response.status_code == 200, response.get_data(as_text=True)
+    data = response.get_json()
+    assert data.get("task_id") == fake_task_id
+
+    # Assert: the file now appears in GET /files with source="globus"
+    # (GET /files only exposes id, name, type, source — path/endpoint_id are
+    # server-side only; we verify those via get_uploaded_files() below)
+    files_data = _get_uploaded_files_via_route(client)
+    file_list = files_data["files"]
+    globus_files = [f for f in file_list if f.get("source") == "globus"]
+    assert len(globus_files) >= 1, (
+        f"Expected at least one globus file in /files, got: {file_list}"
+    )
+    public_entry = globus_files[0]
+    assert public_entry["name"] == "sample.csv"
+    assert public_entry["type"] == ".csv"
+    assert public_entry["source"] == "globus"
+
+    # Verify full entry (path, endpoint_id) via the server-side helper
+    from web.routes.utils import get_uploaded_files
+    with globus_client.application.test_request_context("/"):
+        # We need the same user_id as the test session to read the right cache key
+        from flask import session as _sess
+        with globus_client.session_transaction() as s:
+            _sess["user_id"] = s.get("user_id")
+        all_entries = get_uploaded_files()
+    globus_entries = [e for e in all_entries if e.get("source") == "globus"]
+    assert len(globus_entries) >= 1
+    full_entry = globus_entries[0]
+    assert full_entry["path"] == "/remote/data/sample.csv"
+    assert full_entry.get("endpoint_id") == "ep-test-uuid"
+
+    # Assert: the file is the active file
+    active_id = files_data.get("active_file_id")
+    assert active_id == public_entry["id"], (
+        f"Expected active_file_id={public_entry['id']!r}, got {active_id!r}"
+    )
+
+
+def test_globus_submit_sets_legacy_session_keys(globus_client):
+    """After /globus/submit, the globus_file_* session keys should still be set
+    (set_active_file repopulates them; existing Globus code that reads those keys
+    keeps working).
+    """
+    client = globus_client
+    _set_globus_auth(client)
+
+    mock_client = MagicMock()
+    with patch("web.routes.globus.get_compute_client", return_value=mock_client), \
+         patch("web.routes.globus.submit_metric", return_value="task-xyz"):
+        client.post(
+            "/globus/submit",
+            json={
+                "endpoint_id": "ep-456",
+                "file_path": "/remote/other.parquet",
+                "file_name": "other.parquet",
+                "file_type": ".parquet",
+                "metric_name": "completeness",
+            },
+        )
+
+    with client.session_transaction() as sess:
+        assert sess.get("globus_file_path") == "/remote/other.parquet"
+        assert sess.get("globus_file_name") == "other.parquet"
+        assert sess.get("globus_file_type") == ".parquet"
+        assert sess.get("globus_endpoint_id") == "ep-456"
+
+
+# ---------------------------------------------------------------------------
+# /globus/add-files — file or directory, server-side type inference
+# ---------------------------------------------------------------------------
+
+
+def _add_files(client, path, files_result, endpoint="ep-dir"):
+    """POST /globus/add-files with the remote listing mocked to files_result."""
+    with patch("web.routes.globus.get_compute_client", return_value=MagicMock()), \
+         patch("web.routes.globus.submit_list_files", return_value="list-task"), \
+         patch("web.routes.globus.check_task",
+               return_value={"status": "completed", "result": {"files": files_result}}):
+        return client.post(
+            "/globus/add-files", json={"endpoint_id": endpoint, "path": path}
+        )
+
+
+def test_globus_add_directory_adds_supported_skips_others(globus_client):
+    client = globus_client
+    _set_globus_auth(client)
+    r = _add_files(client, "/remote/data/", [
+        "/remote/data/a.csv",
+        "/remote/data/b.json",
+        "/remote/data/notes.txt",  # unsupported -> skipped
+    ])
+    assert r.status_code == 200, r.get_data(as_text=True)
+    data = r.get_json()
+    assert set(data["added"]) == {"a.csv", "b.json"}
+    assert data["skipped"] == ["notes.txt"]
+    files = client.get("/files").get_json()
+    names = {f["name"]: f["type"] for f in files["files"]}
+    assert names == {"a.csv": ".csv", "b.json": ".json"}  # types inferred
+    assert files["active_file_id"] == data["active_file_id"]
+
+
+def test_globus_add_single_file(globus_client):
+    client = globus_client
+    _set_globus_auth(client)
+    r = _add_files(client, "/remote/data/x.csv", ["/remote/data/x.csv"])
+    assert r.status_code == 200
+    assert r.get_json()["added"] == ["x.csv"]
+    files = client.get("/files").get_json()["files"]
+    assert [f["name"] for f in files] == ["x.csv"]
+
+
+def test_globus_add_all_unsupported_errors(globus_client):
+    client = globus_client
+    _set_globus_auth(client)
+    r = _add_files(client, "/remote/data/", ["/remote/a.txt", "/remote/b.bin"])
+    assert r.status_code == 400
+    assert "supported" in r.get_json()["error"].lower()
+    assert client.get("/files").get_json()["files"] == []
+
+
+def test_globus_add_requires_auth(globus_client):
+    r = globus_client.post(
+        "/globus/add-files", json={"endpoint_id": "e", "path": "/p"}
+    )
+    assert r.status_code == 401
+
+
+def test_remote_list_files_operation(tmp_path):
+    """The __list_files__ op of remote_metric_runner lists files (stdlib only)."""
+    from web.globus import remote_metric_runner
+    (tmp_path / "a.csv").write_text("x")
+    (tmp_path / "b.json").write_text("x")
+    (tmp_path / "sub").mkdir()  # subdirectory excluded (non-recursive)
+    out = remote_metric_runner("__list_files__", str(tmp_path), "", "")
+    assert sorted(os.path.basename(p) for p in out["files"]) == ["a.csv", "b.json"]
+    one = remote_metric_runner("__list_files__", str(tmp_path / "a.csv"), "", "")
+    assert one["files"] == [str(tmp_path / "a.csv")]
+    assert "error" in remote_metric_runner("__list_files__", "/no/such/path", "", "")
+
+
+def test_run_with_retry_recovers_from_409(monkeypatch):
+    """_run_with_retry re-submits on the transient 'endpoint in use' (409)."""
+    monkeypatch.setattr("time.sleep", lambda *_a, **_k: None)  # no real delay
+    from web.globus import _run_with_retry
+
+    class _Conflict(Exception):
+        http_status = 409
+
+    client = MagicMock()
+    client.run.side_effect = [_Conflict("RESOURCE_CONFLICT: already in use"),
+                              _Conflict("again"), "task-ok"]
+    out = _run_with_retry(client, "a", endpoint_id="e", function_id="f")
+    assert out == "task-ok"
+    assert client.run.call_count == 3
+
+
+def test_run_with_retry_reraises_other_errors(monkeypatch):
+    monkeypatch.setattr("time.sleep", lambda *_a, **_k: None)
+    from web.globus import _run_with_retry
+    client = MagicMock()
+    client.run.side_effect = ValueError("boom")
+    with pytest.raises(ValueError):
+        _run_with_retry(client, "a")
+    assert client.run.call_count == 1
+
+
+def test_remote_summarize_files_matches_local(tmp_path):
+    """remote_metric_runner('__summarize_files__') computes stats inline
+    (read_file + pandas), matching aidrin.summarize_files — no dependency on the
+    endpoint having the new summarize_files."""
+    import pandas as pd
+    import aidrin
+    from web.globus import remote_metric_runner
+    p = tmp_path / "x.csv"
+    pd.DataFrame({"age": [1, 2, 3], "city": ["A", "B", "C"]}).to_csv(p, index=False)
+    infos = [[str(p), "x.csv", ".csv"]]
+    remote = remote_metric_runner("__summarize_files__", "", "", "", file_infos=infos)
+    local = aidrin.summarize_files([(str(p), "x.csv", ".csv")])
+    r, l = remote["files"][0], local["files"][0]
+    for k in ("records", "features", "numerical", "categorical", "status"):
+        assert r[k] == l[k]
+    # unreadable file -> error row, never raises
+    bad = remote_metric_runner("__summarize_files__", "", "", "",
+                               file_infos=[["/no/such.csv", "x.csv", ".csv"]])
+    assert bad["files"][0]["status"] == "error"
diff --git a/tests/integration/test_inspector.py b/tests/integration/test_inspector.py
index 2fb929d7..d589099c 100644
--- a/tests/integration/test_inspector.py
+++ b/tests/integration/test_inspector.py
@@ -63,7 +63,7 @@ def test_inspector_get_no_file(client):
     assert response.status_code == 200
     html = response.data.decode()
     assert "AI Data Readiness Infrastructure" in html
-    assert "Select a File Type" in html
+    assert "Click to upload" in html
     assert "https://aidrin.readthedocs.io/en/latest/" in html
 
 
diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
new file mode 100644
index 00000000..f18323d2
--- /dev/null
+++ b/tests/integration/test_multi_upload.py
@@ -0,0 +1,131 @@
+import io
+
+
+def _upload(client, names):
+    files = [(io.BytesIO(b"a,b\n1,2\n3,4\n"), n) for n in names]
+    return client.post("/inspector", data={"file": files},
+                       content_type="multipart/form-data", follow_redirects=False)
+
+
+def test_multi_upload_builds_list_and_activates_first(client):
+    r = _upload(client, ["two.csv", "one.csv"])
+    assert r.status_code == 302
+    files = client.get("/files").get_json()
+    assert {f["name"] for f in files["files"]} == {"one.csv", "two.csv"}
+    assert files["active_file_id"] is not None
+    # first NEW file by name is "one.csv" -> active
+    active = next(f for f in files["files"] if f["id"] == files["active_file_id"])
+    assert active["name"] == "one.csv"
+
+
+def test_upload_infers_type_from_extension(client):
+    _upload(client, ["data.csv"])
+    f = client.get("/files").get_json()["files"][0]
+    assert f["type"] == ".csv"
+
+
+def test_single_file_upload_still_works(client):
+    r = _upload(client, ["solo.csv"])
+    assert r.status_code == 302
+    files = client.get("/files").get_json()
+    assert len(files["files"]) == 1
+    assert files["active_file_id"] is not None
+
+
+def test_globus_active_file_not_wiped_by_local_existence_check(app, client):
+    from web.routes.utils import save_uploaded_files
+    with app.test_request_context("/"):
+        from flask import session
+        session["user_id"] = "u-g"
+        save_uploaded_files([{
+            "id": "g1", "name": "r.csv", "type": ".csv",
+            "path": "/remote/only/r.csv", "source": "globus", "endpoint_id": "ep",
+        }])
+    with client.session_transaction() as sess:
+        sess["user_id"] = "u-g"
+        sess["active_file_id"] = "g1"
+        sess["uploaded_file_path"] = "/remote/only/r.csv"
+        sess["uploaded_file_name"] = "r.csv"
+        sess["uploaded_file_type"] = ".csv"
+        sess["globus_file_path"] = "/remote/only/r.csv"
+        sess["globus_file_name"] = "r.csv"
+        sess["globus_file_type"] = ".csv"
+        sess["globus_endpoint_id"] = "ep"
+    r = client.get("/inspector")
+    assert r.status_code == 200
+    with client.session_transaction() as sess:
+        assert sess.get("active_file_id") == "g1"
+        assert sess.get("uploaded_file_path") == "/remote/only/r.csv"
+
+
+def test_too_many_files_rejected(client, app):
+    app.config["AIDRIN_MAX_UPLOAD_FILES"] = 2
+    r = _upload(client, ["a.csv", "b.csv", "c.csv"])
+    assert r.status_code == 400
+    data = r.get_json()
+    assert data and data["success"] is False
+    assert "2" in data["message"] or "many" in data["message"].lower()
+
+
+def test_under_file_limit_ok(client, app):
+    app.config["AIDRIN_MAX_UPLOAD_FILES"] = 5
+    r = _upload(client, ["a.csv", "b.csv"])
+    assert r.status_code == 302
+
+
+def test_unsupported_file_rejected_with_clear_message(client):
+    import io as _io
+    r = client.post(
+        "/inspector",
+        data={"file": [(_io.BytesIO(b"hello"), "notes.txt")]},
+        content_type="multipart/form-data",
+        follow_redirects=False,
+    )
+    assert r.status_code == 400
+    data = r.get_json()
+    assert data["success"] is False
+    assert "unsupported" in data["message"].lower()
+    assert "notes.txt" in data["message"]
+    # nothing was saved into the file list
+    assert client.get("/files").get_json()["files"] == []
+
+
+def test_batch_with_one_unsupported_file_rejected(client):
+    import io as _io
+    r = client.post(
+        "/inspector",
+        data={"file": [
+            (_io.BytesIO(b"a,b\n1,2\n"), "good.csv"),
+            (_io.BytesIO(b"x"), "bad.txt"),
+        ]},
+        content_type="multipart/form-data",
+        follow_redirects=False,
+    )
+    assert r.status_code == 400
+    assert client.get("/files").get_json()["files"] == []
+
+
+def test_multi_upload_lands_on_batch_overview(client):
+    """A fresh multi-file upload renders the inspector landing on Batch Overview."""
+    r = _upload(client, ["one.csv", "two.csv"])
+    assert r.status_code == 302
+    # the flag is set in the session by the upload POST
+    with client.session_transaction() as sess:
+        assert sess.get("land_on_batch") is True
+    # ...and the next inspector render consumes it and emits the landing block.
+    # Use the unique comment marker — the sidebar button also calls showPanel.
+    marker = "surface the batch overview as the landing"
+    html = client.get("/inspector").get_data(as_text=True)
+    assert marker in html
+    # flag is one-shot: a second render no longer lands on batch overview
+    html2 = client.get("/inspector").get_data(as_text=True)
+    assert marker not in html2
+
+
+def test_single_upload_does_not_land_on_batch_overview(client):
+    r = _upload(client, ["solo.csv"])
+    assert r.status_code == 302
+    with client.session_transaction() as sess:
+        assert sess.get("land_on_batch") is not True
+    html = client.get("/inspector").get_data(as_text=True)
+    assert "surface the batch overview as the landing" not in html
diff --git a/tests/unit/test_infer_file_type.py b/tests/unit/test_infer_file_type.py
new file mode 100644
index 00000000..ddd25bdd
--- /dev/null
+++ b/tests/unit/test_infer_file_type.py
@@ -0,0 +1,35 @@
+import pytest
+from aidrin.file_handling.file_parser import infer_file_type, READER_MAP, file_extension
+
+
+@pytest.mark.parametrize("filename,expected", [
+    ("data.csv", ".csv"),
+    ("DATA.CSV", ".csv"),
+    ("set.json", ".json"),
+    ("a.npz", ".npz"),
+    ("b.h5", ".h5"),
+    ("c.parquet", ".parquet"),
+    ("sheet.xlsx", ".xls, .xlsb, .xlsx, .xlsm"),
+    ("sheet.xls", ".xls, .xlsb, .xlsx, .xlsm"),
+])
+def test_infer_known_extensions(filename, expected):
+    if expected not in READER_MAP:
+        pytest.skip(f"{expected} reader not registered on this branch")
+    assert infer_file_type(filename) == expected
+
+
+def test_infer_unknown_extension_returns_none():
+    assert infer_file_type("notes.txt") is None
+    assert infer_file_type("noext") is None
+    assert infer_file_type(None) is None
+
+
+def test_infer_real_extension_helper():
+    assert file_extension("Sheet.XLSX") == ".xlsx"
+    assert file_extension("a.csv") == ".csv"
+    assert file_extension("noext") == ""
+
+
+def test_infer_double_extension_uses_last_segment():
+    assert infer_file_type("data.csv.bak") is None
+    assert infer_file_type("data.bak.csv") == ".csv"
diff --git a/tests/unit/test_privacy.py b/tests/unit/test_privacy.py
index 05907ea5..243b48bd 100644
--- a/tests/unit/test_privacy.py
+++ b/tests/unit/test_privacy.py
@@ -468,3 +468,21 @@ def test_visualization_is_base64(self):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+def test_privacy_metrics_reject_empty_quasi_identifiers():
+    """Empty quasi-identifiers return a clear error, not a pandas 'No group
+    keys passed!' crash (this is what reached the UI for Globus k-anonymity)."""
+    import pandas as pd
+    from aidrin.structured_data_metrics.privacy_measure import (
+        compute_k_anonymity,
+        compute_l_diversity,
+        compute_t_closeness,
+        compute_entropy_risk,
+    )
+    df = pd.DataFrame({"a": [1, 2, 3], "s": ["x", "y", "z"]})
+    msg = "Please select at least one quasi-identifier."
+    assert compute_k_anonymity([], df) == {"Error": msg}
+    assert compute_entropy_risk([], df) == {"Error": msg}
+    assert compute_l_diversity([], "s", df) == {"Error": msg}
+    assert compute_t_closeness([], "s", df) == {"Error": msg}
diff --git a/tests/unit/test_public_api.py b/tests/unit/test_public_api.py
index 78f18eb8..57d6833b 100644
--- a/tests/unit/test_public_api.py
+++ b/tests/unit/test_public_api.py
@@ -110,6 +110,9 @@ def test_compute_t_closeness_importable(self):
     def test_compute_entropy_risk_importable(self):
         self._assert_callable("compute_entropy_risk")
 
+    def test_summarize_files_importable(self):
+        self._assert_callable("summarize_files")
+
 
 # ===========================================================================
 # Data Quality
diff --git a/tests/unit/test_summarize_files.py b/tests/unit/test_summarize_files.py
new file mode 100644
index 00000000..c4693330
--- /dev/null
+++ b/tests/unit/test_summarize_files.py
@@ -0,0 +1,112 @@
+import os
+import tempfile
+
+import pandas as pd
+
+from aidrin.batch import summarize_files
+
+
+def _csv(rows="a,b\n1,2\n3,4\n"):
+    f = tempfile.NamedTemporaryFile(suffix=".csv", delete=False, mode="w")
+    f.write(rows)
+    f.close()
+    return f.name
+
+
+def test_ok_file_reports_structure_no_metrics():
+    path = _csv()
+    try:
+        out = summarize_files([(path, "data.csv", ".csv")])
+    finally:
+        os.unlink(path)
+    row = out["files"][0]
+    assert row["status"] == "ok"
+    assert row["records"] == 2
+    assert row["features"] == 2
+    assert row["numerical"] == 2  # both columns are integers
+    assert row["categorical"] == 0
+    assert row["size_bytes"] > 0
+    assert row["error"] is None
+    assert set(row.keys()) == {"name", "type", "records", "features",
+                               "numerical", "categorical",
+                               "size_bytes", "status", "error"}
+
+
+def test_numeric_and_categorical_counts():
+    import pandas as pd
+    f = tempfile.NamedTemporaryFile(suffix=".csv", delete=False, mode="w")
+    pd.DataFrame({"age": [1, 2], "city": ["A", "B"], "score": [1.0, 2.0]}).to_csv(
+        f.name, index=False
+    )
+    f.close()
+    try:
+        row = summarize_files([(f.name, "d.csv", ".csv")])["files"][0]
+    finally:
+        os.unlink(f.name)
+    assert row["numerical"] == 2  # age, score
+    assert row["categorical"] == 1  # city
+
+
+def test_unsupported_type_is_error_not_crash():
+    out = summarize_files([("/nope/x.txt", "x.txt", ".txt")])
+    row = out["files"][0]
+    assert row["status"] == "error"
+    assert row["records"] is None and row["features"] is None
+    assert row["error"]
+
+
+def test_missing_file_is_error():
+    out = summarize_files([("/nope/missing.csv", "missing.csv", ".csv")])
+    assert out["files"][0]["status"] == "error"
+
+
+def test_none_path_reports_clear_error():
+    out = summarize_files([(None, "data.csv", ".csv")])
+    row = out["files"][0]
+    assert row["status"] == "error"
+    assert "path" in row["error"].lower()
+
+
+def test_one_bad_file_does_not_abort_batch():
+    good = _csv()
+    try:
+        out = summarize_files([
+            (good, "good.csv", ".csv"),
+            ("/nope/bad.csv", "bad.csv", ".csv"),
+        ])
+    finally:
+        os.unlink(good)
+    assert [f["status"] for f in out["files"]] == ["ok", "error"]
+
+
+def test_totals():
+    a = _csv("a,b\n1,2\n3,4\n5,6\n")
+    b = _csv("x\n1\n")
+    try:
+        out = summarize_files([
+            (a, "a.csv", ".csv"),
+            (b, "b.csv", ".csv"),
+            ("/nope/c.csv", "c.csv", ".csv"),
+        ])
+    finally:
+        try:
+            os.unlink(a)
+        except OSError:
+            pass
+        try:
+            os.unlink(b)
+        except OSError:
+            pass
+    t = out["totals"]
+    assert t["file_count"] == 3
+    assert t["ok_count"] == 2
+    assert t["error_count"] == 1
+    assert t["total_records"] == 4
+    assert t["total_size_bytes"] > 0
+    assert t["by_type"] == {".csv": 3}
+
+
+def test_empty_input():
+    out = summarize_files([])
+    assert out["files"] == []
+    assert out["totals"]["file_count"] == 0
diff --git a/web/__init__.py b/web/__init__.py
index 43d28cb0..2f61e36c 100644
--- a/web/__init__.py
+++ b/web/__init__.py
@@ -71,6 +71,14 @@ def inject_version():
         max_upload_mb = 1024
     app.config["MAX_CONTENT_LENGTH"] = max_upload_mb * 1024 * 1024
 
+    # Maximum number of files per upload batch.
+    try:
+        app.config["AIDRIN_MAX_UPLOAD_FILES"] = int(
+            os.environ.get("AIDRIN_MAX_UPLOAD_FILES", 50)
+        )
+    except ValueError:
+        app.config["AIDRIN_MAX_UPLOAD_FILES"] = 50
+
     @app.context_processor
     def inject_upload_limit():
         # expose the upload limit to templates for client-side validation
@@ -138,10 +146,11 @@ def file_too_large(error):
     sample_data_folder = os.path.join(project_root, "examples", "sample_data")
     app.config["SAMPLE_DATA_FOLDER"] = sample_data_folder
 
-    # Custom metrics folder stays inside the aidrin package (dynamic import target)
-    import aidrin as _aidrin_pkg
-    aidrin_root = os.path.dirname(_aidrin_pkg.__file__)
-    custom_metrics_folder = os.path.join(aidrin_root, "custom_metrics")
+    # Runtime custom-metric files live OUTSIDE the package, at the project root,
+    # so writing/deleting them does NOT trigger the Flask --debug auto-reloader
+    # (which watches .py files under the package). The base class they import,
+    # `aidrin.custom_metrics.base_dr`, still resolves via the installed package.
+    custom_metrics_folder = os.path.join(project_root, "data", "custom_metrics")
     os.makedirs(custom_metrics_folder, exist_ok=True)
     app.config["CUSTOM_METRICS_FOLDER"] = custom_metrics_folder
     app.config["CUSTOM_ALLOWED_EXTENSIONS"] = {"py"}
diff --git a/web/globus.py b/web/globus.py
index d4689a73..dc219cd6 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -45,7 +45,67 @@ def remote_metric_runner(metric_name, file_path, file_name, file_type, **params)
     This function is serialised and sent to the remote endpoint, where it
     imports ``aidrin`` locally and dispatches to the requested metric.
     The remote environment must have ``pip install aidrin`` completed.
+
+    The special ``metric_name == "__list_files__"`` enumerates the data files at
+    ``file_path`` (a file -> just it; a directory -> its files, non-recursive).
+    It is handled here (rather than as a separate registered function) so it
+    reuses this proven, already-registered function. Needs only stdlib.
     """
+    if metric_name == "__list_files__":
+        import os
+        try:
+            if os.path.isfile(file_path):
+                return {"files": [file_path]}
+            if os.path.isdir(file_path):
+                return {"files": sorted(
+                    os.path.join(file_path, f)
+                    for f in os.listdir(file_path)
+                    if os.path.isfile(os.path.join(file_path, f))
+                )}
+            return {"error": f"Path not found on the remote endpoint: {file_path}"}
+        except Exception as e:  # noqa: BLE001
+            return {"error": f"Could not list '{file_path}': {e}"}
+
+    if metric_name == "__summarize_files__":
+        # Structural batch overview (records, features, numerical, categorical,
+        # size) for a list of remote files. Computed INLINE with read_file +
+        # pandas (both present in any aidrin install) — NOT via
+        # aidrin.summarize_files, which may not exist on the endpoint's released
+        # aidrin. Mirrors aidrin.summarize_files' output so values match local.
+        # params["file_infos"]: list of [path, name, type].
+        import os
+        import pandas as pd
+        from aidrin.file_handling.file_parser import read_file as _read_file
+
+        out = []
+        for fi in (params.get("file_infos") or []):
+            p, n, t = fi[0], fi[1], fi[2]
+            try:
+                size = os.path.getsize(p) if p and os.path.exists(p) else None
+            except OSError:
+                size = None
+            df = _read_file((p, n, t))
+            if isinstance(df, pd.DataFrame):
+                out.append({
+                    "name": n, "type": t,
+                    "records": int(len(df)),
+                    "features": int(len(df.columns)),
+                    "numerical": int(sum(
+                        pd.api.types.is_numeric_dtype(d) for d in df.dtypes)),
+                    "categorical": int(sum(
+                        pd.api.types.is_string_dtype(d) for d in df.dtypes)),
+                    "size_bytes": size, "status": "ok", "error": None,
+                })
+            else:
+                msg = df if isinstance(df, str) else "Could not read the file."
+                out.append({
+                    "name": n, "type": t,
+                    "records": None, "features": None,
+                    "numerical": None, "categorical": None,
+                    "size_bytes": size, "status": "error", "error": msg,
+                })
+        return {"files": out}
+
     # Ensure matplotlib uses non-interactive backend on remote endpoint
     import matplotlib
     matplotlib.use("Agg")
@@ -439,24 +499,93 @@ def get_compute_client(tokens):
 def register_function(client, force=False):
     """Register the remote_metric_runner function with Globus Compute.
 
-    Returns the function UUID. Re-registers on every server restart
-    to ensure the latest code is used.
+    The cache key includes a hash of the function's current source, so any edit
+    to remote_metric_runner (once the running process has reloaded it) forces a
+    fresh registration — the endpoint then runs the new code. Without this, a
+    stale cached registration would keep executing the old function.
     """
-    cache_key = "remote_metric_runner"
+    import hashlib
+    import inspect
+
+    try:
+        src = inspect.getsource(remote_metric_runner)
+        digest = hashlib.sha1(src.encode("utf-8")).hexdigest()[:12]
+    except (OSError, TypeError):
+        src = ""
+        digest = "nosrc"
+    supports_list = "__list_files__" in src
+    cache_key = f"remote_metric_runner:{digest}"
     if not force and cache_key in _function_uuid_cache:
         return _function_uuid_cache[cache_key]
 
     func_uuid = client.register_function(remote_metric_runner)
     _function_uuid_cache[cache_key] = func_uuid
-    logger.info("Registered remote_metric_runner with Globus Compute: %s", func_uuid)
+    # The supports_list flag tells you whether the LOADED code is current: if it
+    # logs False, the server process is running stale code — restart it.
+    logger.info(
+        "Registered remote_metric_runner: func_uuid=%s src_hash=%s supports __list_files__=%s",
+        func_uuid, digest, supports_list,
+    )
     return func_uuid
 
 
+# ---------------------------------------------------------------------------
+# Remote file listing (for adding a file OR a directory to the batch)
+# ---------------------------------------------------------------------------
+
+
+def submit_list_files(client, endpoint_id, path):
+    """Submit a remote file-listing task; return the task UUID string.
+
+    Reuses the proven ``remote_metric_runner`` (via its ``__list_files__``
+    operation) rather than registering a separate function, so it goes through
+    the same registration/serialisation path that already works for metrics.
+    """
+    name = path.rstrip("/").split("/")[-1]
+    return submit_metric(client, endpoint_id, "__list_files__", path, name, "")
+
+
 # ---------------------------------------------------------------------------
 # Task submission and status
 # ---------------------------------------------------------------------------
 
 
+def _run_with_retry(client, *args, max_attempts=8, **kwargs):
+    """client.run with retry on the transient 'endpoint already in use' (409).
+
+    Globus Compute returns 409 RESOURCE_CONFLICT when the endpoint is busy with a
+    concurrent submission and asks the caller to retry. Concurrent submitters that
+    back off on an identical schedule keep colliding, so use exponential backoff
+    with full jitter to de-correlate retries and ride out a busy endpoint.
+    """
+    import random
+    import time
+
+    last_err = None
+    for attempt in range(max_attempts):
+        try:
+            return client.run(*args, **kwargs)
+        except Exception as e:  # noqa: BLE001
+            msg = str(e)
+            transient = (
+                getattr(e, "http_status", None) == 409
+                or "RESOURCE_CONFLICT" in msg
+                or "already in use" in msg.lower()
+                # Endpoint failed to start the task worker (often transient on
+                # busy/HPC endpoints): "Failed to start ... (SystemExit) 73".
+                or "Failed to start" in msg
+                or "SystemExit" in msg
+            )
+            if not (transient and attempt < max_attempts - 1):
+                raise
+            last_err = e
+            # full jitter over an exponentially growing window, capped at 8s:
+            # sleep ~U(0, min(8, 0.5 * 2**attempt))
+            backoff = min(8.0, 0.5 * (2 ** attempt))
+            time.sleep(random.uniform(0.0, backoff))
+    raise last_err  # pragma: no cover
+
+
 def submit_metric(client, endpoint_id, metric_name, file_path, file_name, file_type, **params):
     """Submit a metric computation task to a remote Globus Compute endpoint.
 
@@ -467,7 +596,8 @@ def submit_metric(client, endpoint_id, metric_name, file_path, file_name, file_t
     # Pass all arguments as positional args to avoid kwarg conflicts
     # with endpoint_id/function_id. The remote_metric_runner signature is:
     # remote_metric_runner(metric_name, file_path, file_name, file_type, **params)
-    task_id = client.run(
+    task_id = _run_with_retry(
+        client,
         metric_name, file_path, file_name, file_type,
         endpoint_id=endpoint_id,
         function_id=func_uuid,
diff --git a/web/routes/__init__.py b/web/routes/__init__.py
index 0d724d0e..605f87f1 100644
--- a/web/routes/__init__.py
+++ b/web/routes/__init__.py
@@ -1,6 +1,7 @@
 from web.routes.admin import admin_bp
 from web.routes.core import core_bp
 from web.routes.custom import custom_bp
+from web.routes.files import files_bp
 from web.routes.metrics import metrics_bp
 
 
@@ -8,6 +9,7 @@ def register_blueprints(app):
     app.register_blueprint(admin_bp)
     app.register_blueprint(core_bp)
     app.register_blueprint(custom_bp)
+    app.register_blueprint(files_bp)
     app.register_blueprint(metrics_bp)
 
     # Globus Compute — optional, only if SDK is installed
diff --git a/web/routes/core.py b/web/routes/core.py
index 7fb624b9..36003fef 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -39,39 +39,80 @@ def homepage():
 @core_bp.route("/inspector", methods=["GET", "POST"])
 def inspector():
     if request.method == "POST":
+        from web.routes.utils import (
+            save_uploaded_files, get_uploaded_files, set_active_file,
+        )
+        from aidrin.file_handling.file_parser import infer_file_type
         file_upload_time_log.info("File upload initiated (workspace)")
-        file = request.files["file"]
-
-        if file:
+        uploads = [u for u in request.files.getlist("file") if u and u.filename]
+        if uploads:
+            max_files = current_app.config.get("AIDRIN_MAX_UPLOAD_FILES", 50)
+            if len(get_uploaded_files()) + len(uploads) > max_files:
+                return jsonify({
+                    "success": False,
+                    "message": f"Too many files. The maximum is {max_files} per batch.",
+                }), 400
+            # Reject unsupported file types up front with a clear message, so a
+            # file with no inferable reader never enters the list and silently
+            # gets cleared by the stale-session check.
+            unsupported = [u.filename for u in uploads if infer_file_type(u.filename) is None]
+            if unsupported:
+                supported = ", ".join(label for _ext, label in SUPPORTED_FILE_TYPES)
+                return jsonify({
+                    "success": False,
+                    "message": (
+                        f"Unsupported file type: {', '.join(unsupported)}. "
+                        f"Supported formats: {supported}."
+                    ),
+                }), 400
             cleared_count = clear_all_user_cache()
             file_upload_time_log.info(
                 "Cache cleared for new file upload: %d entries removed", cleared_count
             )
-
-            display_name = file.filename
-            filename = f"{uuid.uuid4().hex}_{secure_filename(file.filename)}"
-            file_path = os.path.join(current_app.config["UPLOAD_FOLDER"], filename)
-            file.save(file_path)
-
-            session["uploaded_file_name"] = display_name
-            session["uploaded_file_path"] = file_path
-            session["uploaded_file_type"] = request.form.get("fileTypeSelector")
-
+            entries = get_uploaded_files()
+            new_entries = []
             # Track files this session created so /clear removes only these,
             # never files belonging to other concurrent sessions.
             owned_files = session.get("owned_files", [])
-            if file_path not in owned_files:
-                owned_files.append(file_path)
+            for up in uploads:
+                display_name = up.filename
+                stored = f"{uuid.uuid4().hex}_{secure_filename(up.filename)}"
+                path = os.path.join(current_app.config["UPLOAD_FOLDER"], stored)
+                up.save(path)
+                entry = {
+                    "id": uuid.uuid4().hex,
+                    "name": display_name,
+                    "type": infer_file_type(display_name) or "",
+                    "path": path,
+                    "source": "local",
+                }
+                entries.append(entry)
+                new_entries.append(entry)
+                if path not in owned_files:
+                    owned_files.append(path)
             session["owned_files"] = owned_files
-
+            save_uploaded_files(entries)
+            first = sorted(new_entries, key=lambda e: e["name"].lower())[0]
+            set_active_file(first["id"])
+            # Land on the batch overview for a multi-file batch (a one-shot flag
+            # consumed on the next render — a URL fragment can't be used because
+            # the AJAX upload follows the redirect via fetch, which strips it).
+            # A single file lands on its data overview.
+            session["land_on_batch"] = len(entries) > 1
             return redirect(url_for("core.inspector"))
 
     uploaded_file_name = session.get("uploaded_file_name", "")
     uploaded_file_path = session.get("uploaded_file_path", "")
     file_type = session.get("uploaded_file_type", "")
 
-    # Validate session: clear stale data if file no longer exists or type is missing
-    if uploaded_file_path and (
+    # Determine if the active file is a remote Globus file — skip local-existence checks for it
+    from web.routes.utils import get_active_file
+    active = get_active_file()
+    is_globus = bool(active and active.get("source") == "globus")
+
+    # Validate session: clear stale data if file no longer exists or type is missing.
+    # Skip local-existence check for Globus remote files (path lives on a remote endpoint).
+    if uploaded_file_path and not is_globus and (
         not os.path.exists(uploaded_file_path) or not file_type
     ):
         file_upload_time_log.warning(
@@ -89,7 +130,7 @@ def inspector():
     file_preview = None
     current_checked_keys = None
 
-    if uploaded_file_path and file_type in [".h5", ".json", ".npz"]:
+    if uploaded_file_path and not is_globus and file_type in [".h5", ".json", ".npz"]:
         try:
             if file_type in READER_MAP:
                 reader = READER_MAP[file_type](uploaded_file_path, file_upload_time_log)
@@ -135,9 +176,15 @@ def inspector():
     effective_file_name = uploaded_file_name or globus_file_name
     effective_file_type = file_type or globus_file_type
 
+    from web.routes.utils import get_uploaded_files as _get_uploaded_files
+    file_count = len(_get_uploaded_files())
+    # One-shot: a fresh multi-file upload lands on the batch overview.
+    land_on_batch = session.pop("land_on_batch", False)
+
     try:
         return render_template(
             "inspector.html",
+            land_on_batch=land_on_batch,
             uploaded_file_path=effective_file_path or "",
             uploaded_file_name=effective_file_name or "",
             file_type=effective_file_type or "",
@@ -152,6 +199,7 @@ def inspector():
             globus_endpoint_id=globus_endpoint_id,
             llm_available=llm_available,
             llm_configured=llm_configured,
+            file_count=file_count,
         )
     except Exception as e:
         file_upload_time_log.error("Error rendering workspace: %s", e, exc_info=True)
@@ -208,7 +256,14 @@ def clear_file():
             except Exception as e:
                 file_upload_time_log.warning("Failed to cancel Globus tasks on clear: %s", e)
 
-    # Capture this session's own files before clearing the session.
+    # Remove the disk-backed file list BEFORE clearing the session — it needs
+    # user_id (in the session) to resolve the per-user file path.
+    from web.routes.utils import clear_uploaded_files
+    clear_uploaded_files()
+
+    # Capture this session's own files before clearing the session, so the
+    # physical files get removed below (clear_uploaded_files drops the list
+    # metadata; this removes the saved files owned by this session).
     owned_files = session.get("owned_files", [])
 
     session.pop("uploaded_file_path", None)
@@ -309,10 +364,11 @@ def cached_result(metric_name):
         or session.get("globus_file_name")
         or ""
     )
-    if not file_name:
+    if not file_name and not session.get("active_file_id"):
         return jsonify({"cached": False})
 
-    cache_key = f"user:{user_id}:file:{file_name}:{metric_name}"
+    file_token = session.get("active_file_id") or file_name
+    cache_key = f"user:{user_id}:file:{file_token}:{metric_name}"
     entry = current_app.TEMP_RESULTS_CACHE.get(cache_key)
     if entry and entry.get("data"):
         resp = {"cached": True, "data": entry["data"]}
diff --git a/web/routes/custom.py b/web/routes/custom.py
index 5d7b3aa3..f5018d00 100644
--- a/web/routes/custom.py
+++ b/web/routes/custom.py
@@ -2,8 +2,8 @@
 import importlib.util
 import logging
 import os
-import runpy
 import sys
+import tempfile
 import time
 import uuid
 
@@ -81,6 +81,11 @@ def custom_metrics():
         folder = None
         try:
             df = read_file(file_info)
+            if df is None or isinstance(df, str):
+                return jsonify({
+                    "error": "The dataset could not be read — it may have been "
+                             "removed. Please re-upload your file."
+                }), 400
             final_dict["Custom Metric Evaluation"] = {}
 
             folder = current_app.config.get("CUSTOM_METRICS_FOLDER", "custom_metrics")
@@ -114,17 +119,6 @@ def custom_metrics():
                     {"error": f"{custom_metric_class.__name__}.metric() must return a dictionary"}
                 ), 400
 
-            module_globals = runpy.run_path(custom_metric_file_path)
-
-            custom_metric_class = module_globals.get("CustomDR")
-            if not custom_metric_class or not issubclass(custom_metric_class, BaseDRAgent):
-                return jsonify({"error": "CustomDR class not found or invalid"}), 400
-
-            instance = custom_metric_class(dataset=df)
-            metric_results = instance.metric()
-            if not isinstance(metric_results, dict):
-                return jsonify({"error": "metric() must return a dictionary"}), 400
-
             final_dict["Custom Metric Evaluation"] = metric_results
 
             if request.form.get("apply_remedy") == "yes":
@@ -136,7 +130,10 @@ def custom_metrics():
                 remedy_folder = current_app.config["REMEDY_FOLDER"]
                 os.makedirs(remedy_folder, exist_ok=True)
 
-                remedy_filename = f"remedied_{session['session_id']}{data_file_type}"
+                # Remedied data is always written as CSV, so name it .csv
+                # regardless of the input format (data_file_type is a reader key,
+                # which for Excel is not even a valid single extension).
+                remedy_filename = f"remedied_{session['session_id']}.csv"
                 remedy_filepath = os.path.join(remedy_folder, remedy_filename)
                 new_data.to_csv(remedy_filepath, index=False)
 
@@ -170,6 +167,26 @@ def download_remedy(filename):
     return send_from_directory(remedy_folder, filename, as_attachment=True)
 
 
+def _atomic_write(path, text):
+    """Write text to path atomically (temp file + rename).
+
+    Avoids leaving a truncated/empty file if the process is interrupted
+    mid-write — which the Flask --debug reloader can do, since these files live
+    inside the watched package and writing one triggers a reload.
+    """
+    fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(text)
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+        raise
+
+
 @custom_bp.route("/load-custom-metric", methods=["GET"])
 def load_custom_metric():
     folder = current_app.config.get("CUSTOM_METRICS_FOLDER", "custom_metrics")
@@ -180,12 +197,15 @@ def load_custom_metric():
     filename = f"customDR_{session['session_id']}.py"
     file_path = os.path.join(folder, filename)
 
-    if not os.path.exists(file_path):
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(_STARTER_TEMPLATE)
+    # (Re)write the starter template if the file is missing OR empty, so the
+    # editor never loads a blank document.
+    if not os.path.exists(file_path) or os.path.getsize(file_path) == 0:
+        _atomic_write(file_path, _STARTER_TEMPLATE)
 
     with open(file_path, encoding="utf-8") as f:
         code = f.read()
+    if not code.strip():
+        code = _STARTER_TEMPLATE
 
     response = make_response(code)
     response.headers["Content-Type"] = "text/plain; charset=utf-8"
@@ -204,7 +224,6 @@ def save_custom_metric_text():
     filename = f"customDR_{session['session_id']}.py"
     file_path = os.path.join(folder, filename)
 
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(code)
+    _atomic_write(file_path, code)
 
     return jsonify({"message": "Custom metric saved successfully"})
diff --git a/web/routes/files.py b/web/routes/files.py
new file mode 100644
index 00000000..5a7dbbd7
--- /dev/null
+++ b/web/routes/files.py
@@ -0,0 +1,73 @@
+"""File-management endpoints for multi-file batches."""
+
+import os
+
+from flask import Blueprint, jsonify, session
+
+from web.routes.utils import (
+    get_uploaded_files, save_uploaded_files, set_active_file, clear_uploaded_files,
+)
+
+files_bp = Blueprint("files", __name__)
+
+
+@files_bp.route("/files", methods=["GET"])
+def list_files():
+    files = get_uploaded_files()
+    public = [{k: f.get(k) for k in ("id", "name", "type", "source")} for f in files]
+    return jsonify({"files": public, "active_file_id": session.get("active_file_id")})
+
+
+@files_bp.route("/files/<file_id>/activate", methods=["POST"])
+def activate(file_id):
+    if set_active_file(file_id):
+        return jsonify({"success": True})
+    return jsonify({"success": False, "message": "Unknown file"}), 404
+
+
+@files_bp.route("/files/summary", methods=["GET"])
+def summary():
+    import aidrin
+    files = get_uploaded_files()
+    local = [f for f in files if f.get("source") == "local"]
+    globus = [f for f in files if f.get("source") == "globus"]
+
+    local_summary = aidrin.summarize_files(
+        [(f["path"], f["name"], f["type"]) for f in local]
+    )
+    rows = []
+    for f, row in zip(local, local_summary["files"]):
+        rows.append({**row, "id": f["id"], "source": "local"})
+    for f in globus:
+        rows.append({
+            "id": f["id"], "name": f["name"], "type": f["type"], "source": "globus",
+            "records": None, "features": None,
+            "numerical": None, "categorical": None, "size_bytes": None,
+            "status": "remote", "error": None,
+        })
+    totals = dict(local_summary["totals"])
+    totals["file_count"] = len(files)
+    totals["by_source"] = {"local": len(local), "globus": len(globus)}
+    return jsonify({"files": rows, "totals": totals})
+
+
+@files_bp.route("/files/<file_id>/remove", methods=["POST"])
+def remove(file_id):
+    files = get_uploaded_files()
+    entry = next((f for f in files if f["id"] == file_id), None)
+    if entry is None:
+        return jsonify({"success": False, "message": "Unknown file"}), 404
+    if entry.get("source") == "local":
+        try:
+            if entry["path"] and os.path.exists(entry["path"]):
+                os.remove(entry["path"])
+        except OSError:
+            pass
+    remaining = [f for f in files if f["id"] != file_id]
+    save_uploaded_files(remaining)
+    if session.get("active_file_id") == file_id:
+        if remaining:
+            set_active_file(remaining[0]["id"])
+        else:
+            clear_uploaded_files()
+    return jsonify({"success": True})
diff --git a/web/routes/globus.py b/web/routes/globus.py
index c1560575..50488e70 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -5,6 +5,7 @@
 """
 
 import logging
+import uuid
 
 from flask import (
     Blueprint,
@@ -21,11 +22,34 @@
     exchange_code_for_tokens,
     get_compute_client,
     submit_metric,
+    submit_list_files,
     check_task,
 )
+from web.routes.utils import get_uploaded_files, save_uploaded_files, set_active_file
 
 logger = logging.getLogger(__name__)
 
+
+def _poll_result(client, task_id, timeout=120):
+    """Block until a short Globus Compute task finishes; return its result.
+
+    Raises on remote failure or timeout. Used for the quick, interactive
+    listing/overview tasks submitted during add-files.
+    """
+    import time
+
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        status = check_task(client, task_id)
+        state = status.get("status")
+        if state == "completed":
+            return status.get("result")
+        if state == "failed":
+            raise RuntimeError(status.get("error", "Remote task failed"))
+        time.sleep(1)
+    raise TimeoutError("Remote task timed out")
+
+
 globus_bp = Blueprint("globus", __name__, url_prefix="/globus")
 
 
@@ -194,11 +218,32 @@ def submit():
         tokens = session.get("globus_tokens", {})
         client = get_compute_client(tokens)
 
-        # Store endpoint info in session for subsequent metric submissions
-        session["globus_endpoint_id"] = endpoint_id
-        session["globus_file_path"] = file_path
-        session["globus_file_name"] = file_name
-        session["globus_file_type"] = file_type
+        # Add the selected Globus file to the shared multi-file list and make it
+        # active.  set_active_file() repopulates the globus_* session keys so
+        # any downstream code that still reads those keys continues to work.
+        entries = get_uploaded_files()
+        # Avoid duplicate entries for the same endpoint + path combination.
+        existing = next(
+            (e for e in entries
+             if e.get("source") == "globus"
+             and e.get("endpoint_id") == endpoint_id
+             and e.get("path") == file_path),
+            None,
+        )
+        if existing is None:
+            entry = {
+                "id": uuid.uuid4().hex,
+                "name": file_name,
+                "type": file_type,
+                "path": file_path,
+                "source": "globus",
+                "endpoint_id": endpoint_id,
+            }
+            entries.append(entry)
+            save_uploaded_files(entries)
+        else:
+            entry = existing
+        set_active_file(entry["id"])  # also repopulates globus_* session keys
 
         task_id = submit_metric(
             client, endpoint_id, metric_name,
@@ -224,6 +269,183 @@ def submit():
         return jsonify({"error": "Failed to submit task"}), 500
 
 
+@globus_bp.route("/add-files", methods=["POST"])
+def add_files():
+    """Add a remote file OR every supported file in a remote directory.
+
+    Body: ``{"endpoint_id": "...", "path": "/remote/file-or-dir"}``.
+
+    Ships a listing function to the endpoint (blocking with a timeout), then
+    infers each file's type server-side (so it doesn't depend on the endpoint's
+    aidrin version), adds the supported ones to the shared batch as
+    ``source:"globus"`` entries, and activates the first new one. Unsupported
+    files are reported as ``skipped``.
+    """
+    import time
+    from aidrin.file_handling.file_parser import infer_file_type
+
+    if not session.get("globus_authenticated"):
+        return jsonify({"error": "Not authenticated with Globus"}), 401
+
+    data = request.get_json() or {}
+    endpoint_id = data.get("endpoint_id")
+    path = data.get("path")
+    if not endpoint_id or not path:
+        return jsonify({"error": "Missing required fields: endpoint_id, path"}), 400
+
+    try:
+        client = get_compute_client(session.get("globus_tokens", {}))
+        task_id = submit_list_files(client, endpoint_id, path)
+
+        # Block for the listing result (it's quick on the endpoint).
+        deadline = time.time() + 60
+        result = None
+        while time.time() < deadline:
+            status = check_task(client, task_id)
+            if status.get("status") == "completed":
+                result = status.get("result")
+                break
+            if status.get("status") == "failed":
+                return jsonify({"error": status.get("error", "Remote listing failed")}), 502
+            time.sleep(1)
+        if result is None:
+            return jsonify({"error": "Timed out listing remote files"}), 504
+        if isinstance(result, dict) and result.get("error"):
+            return jsonify({"error": result["error"]}), 400
+
+        files = result.get("files", []) if isinstance(result, dict) else []
+        if not files:
+            return jsonify({"error": "No files found at that path"}), 400
+
+        max_files = current_app.config.get("AIDRIN_MAX_UPLOAD_FILES", 50)
+        entries = get_uploaded_files()
+        added, skipped = [], []
+        first_id = None
+        for p in files:
+            name = p.rstrip("/").split("/")[-1]
+            ftype = infer_file_type(name)
+            if not ftype:
+                skipped.append(name)
+                continue
+            if len(entries) >= max_files:
+                skipped.append(name)
+                continue
+            existing = next(
+                (e for e in entries
+                 if e.get("source") == "globus"
+                 and e.get("endpoint_id") == endpoint_id
+                 and e.get("path") == p),
+                None,
+            )
+            if existing is not None:
+                if first_id is None:
+                    first_id = existing["id"]
+                continue
+            entry = {
+                "id": uuid.uuid4().hex,
+                "name": name,
+                "type": ftype,
+                "path": p,
+                "source": "globus",
+                "endpoint_id": endpoint_id,
+            }
+            entries.append(entry)
+            added.append(name)
+            if first_id is None:
+                first_id = entry["id"]
+
+        # Pull a structural overview (records/features/numerical/categorical/
+        # size) for the just-added globus files, computed on the endpoint via the
+        # same aidrin.summarize_files used for local batches, and cache it on each
+        # entry so /files/summary doesn't re-fetch it on every page load.
+        # Recompute for entries that have NO usable stats yet — i.e. missing the
+        # records key OR cached as None from an earlier failed attempt (so a
+        # retry isn't permanently blocked).
+        pending = [
+            e for e in entries
+            if e.get("source") == "globus"
+            and e.get("endpoint_id") == endpoint_id
+            and e.get("records") is None
+        ]
+        overview_error = None
+        if pending:
+            # Guard: is THIS server's loaded remote_metric_runner new enough to
+            # do remote stats? If not, the process is running stale code — say so
+            # plainly rather than failing silently into dashes.
+            import inspect as _inspect
+            from web.globus import remote_metric_runner as _runner
+            try:
+                _runner_src = _inspect.getsource(_runner)
+            except (OSError, TypeError):
+                _runner_src = ""
+            if "__summarize_files__" not in _runner_src:
+                overview_error = (
+                    "This AIDRIN server is running an outdated build and cannot "
+                    "compute remote file stats — please fully restart the server."
+                )
+            else:
+                try:
+                    infos = [[e["path"], e["name"], e["type"]] for e in pending]
+                    overview_task = submit_metric(
+                        client, endpoint_id, "__summarize_files__", "", "", "",
+                        file_infos=infos,
+                    )
+                    overview = _poll_result(client, overview_task, timeout=120)
+                    if isinstance(overview, dict) and overview.get("error"):
+                        overview_error = overview["error"]  # e.g. "Unknown metric: ..."
+                    stats_rows = (
+                        overview.get("files", []) if isinstance(overview, dict) else []
+                    )
+                    _ok = sum(1 for r in stats_rows if r.get("status") == "ok")
+                    logger.info(
+                        "Globus overview result: %d/%d files read OK; "
+                        "sample_row=%s top_error=%s",
+                        _ok, len(stats_rows),
+                        (stats_rows[0] if stats_rows else None), overview_error,
+                    )
+                    if not stats_rows and not overview_error:
+                        overview_error = f"Unexpected remote response: {overview!r}"[:200]
+                    for entry, row in zip(pending, stats_rows):
+                        for key in (
+                            "records", "features", "numerical",
+                            "categorical", "size_bytes", "status", "error",
+                        ):
+                            entry[key] = row.get(key)
+                    # If the endpoint read every file but they all errored, surface
+                    # the first reason (e.g. a parse error / missing dependency).
+                    if (stats_rows and not overview_error
+                            and all(r.get("status") == "error" for r in stats_rows)):
+                        overview_error = (
+                            stats_rows[0].get("error")
+                            or "The endpoint could not read the remote files"
+                        )
+                except Exception as ex:  # noqa: BLE001
+                    # Overview is best-effort: a failure here must not block adding.
+                    overview_error = str(ex)
+                    logger.warning("Globus batch overview unavailable: %s", ex)
+
+        save_uploaded_files(entries)
+        if first_id:
+            set_active_file(first_id)  # repopulates globus_* session keys
+
+        if not added and not first_id:
+            return jsonify({
+                "error": "No supported files found. Supported: CSV, Excel, "
+                         "JSON, NumPy (.npz), HDF5."
+            }), 400
+
+        return jsonify({
+            "added": added,
+            "skipped": skipped,
+            "active_file_id": first_id,
+            "overview_error": overview_error,  # why per-file stats are missing
+        })
+
+    except Exception as e:
+        logger.error("Globus add-files error: %s", e, exc_info=True)
+        return jsonify({"error": "Failed to add remote files"}), 500
+
+
 @globus_bp.route("/cache-summary", methods=["POST"])
 def cache_summary():
     """Cache the Globus summary statistics result to avoid re-fetching on page reload."""
diff --git a/web/routes/metrics.py b/web/routes/metrics.py
index 6e3a8def..8e25002f 100644
--- a/web/routes/metrics.py
+++ b/web/routes/metrics.py
@@ -64,6 +64,25 @@
 metric_time_log = logging.getLogger("metric")
 
 
+def _unreadable_response(file):
+    """Return a response when read_file didn't yield a DataFrame, else None.
+
+    read_file returns a DataFrame on success, or None / an error string when the
+    file is missing or unreadable (e.g. it was cleaned up). Without this guard,
+    the metric routes call DataFrame methods on a string and crash with
+    'str'/'NoneType' object has no attribute 'columns'.
+    """
+    if file is not None and not isinstance(file, str):
+        return None  # it's a DataFrame
+    message = (
+        "The dataset could not be read — it may have been removed. "
+        "Please re-upload your file."
+    )
+    if request.method == "POST":
+        return jsonify({"error": message}), 400
+    return redirect(url_for("core.inspector"))
+
+
 # ---------------------------------------------------------------------------
 # Data Quality
 # ---------------------------------------------------------------------------
@@ -149,6 +168,9 @@ def fairness():
     file_type = session.get("uploaded_file_type")
     file_info = (file_path, file_name, file_type)
     file = read_file(file_info)
+    _guard = _unreadable_response(file)
+    if _guard is not None:
+        return _guard
 
     if request.method == "POST":
         start_time = time.time()
@@ -427,6 +449,9 @@ def class_imbalance():
     file_type = session.get("uploaded_file_type")
     file_info = (file_path, file_name, file_type)
     file = read_file(file_info)
+    _guard = _unreadable_response(file)
+    if _guard is not None:
+        return _guard
 
     if request.method == "POST":
         start_time = time.time()
@@ -512,6 +537,9 @@ def privacy_preservation():
     file_type = session.get("uploaded_file_type")
     file_info = (file_path, file_name, file_type)
     file = read_file(file_info)
+    _guard = _unreadable_response(file)
+    if _guard is not None:
+        return _guard
 
     if request.method == "POST":
         start_time = time.time()
@@ -723,6 +751,9 @@ def hipaa_compliance():
         start_time = time.time()
         try:
             df = read_file(file_info)
+            _guard = _unreadable_response(df)
+            if _guard is not None:
+                return _guard
             selected_columns = request.form.getlist("HIPAA identifiers for HIPAA compliance")
             detected_hipaa = detect_hipaa_identifiers(df, selected_columns)
 
diff --git a/web/routes/utils.py b/web/routes/utils.py
index b6f0e0fb..b7447013 100644
--- a/web/routes/utils.py
+++ b/web/routes/utils.py
@@ -2,7 +2,9 @@
 
 import io
 import base64
+import json
 import logging
+import os
 import time
 import uuid
 
@@ -79,10 +81,94 @@ def get_current_user_id():
     return session["user_id"]
 
 
+# ---------------------------------------------------------------------------
+# Multi-file store + active-file shim
+# ---------------------------------------------------------------------------
+
+def _files_store_path():
+    """Path of the current user's persisted file-list JSON.
+
+    Stored on disk (not in the in-memory cache or the session cookie) so the
+    batch survives app restarts — e.g. the Flask dev-server auto-reload that
+    fires when a custom metric writes a .py into the package — and is shared
+    across worker processes. Lives outside UPLOAD_FOLDER so the upload cleanup
+    doesn't remove it.
+    """
+    base = os.path.dirname(current_app.config["UPLOAD_FOLDER"])
+    store_dir = os.path.join(base, "filelists")
+    os.makedirs(store_dir, exist_ok=True)
+    return os.path.join(store_dir, f"{get_current_user_id()}.json")
+
+
+def get_uploaded_files():
+    """Return the persisted list of uploaded files for the current user."""
+    try:
+        with open(_files_store_path()) as fh:
+            return json.load(fh)
+    except (OSError, ValueError):
+        return []
+
+
+def save_uploaded_files(files):
+    """Persist the file list to disk (survives restarts; not in the cookie)."""
+    try:
+        with open(_files_store_path(), "w") as fh:
+            json.dump(files, fh)
+    except OSError:
+        logger.warning("Could not persist uploaded file list", exc_info=True)
+
+
+def get_active_file():
+    """Return the active file entry dict, or None."""
+    active_id = session.get("active_file_id")
+    for f in get_uploaded_files():
+        if f["id"] == active_id:
+            return f
+    return None
+
+
+def set_active_file(file_id):
+    """Make file_id active and mirror its identity into the legacy session keys.
+
+    Returns True if the file exists, else False. For a Globus entry, also
+    repopulates the globus_* keys that the remote path + cache still read.
+    """
+    entry = next((f for f in get_uploaded_files() if f["id"] == file_id), None)
+    if entry is None:
+        return False
+    session["active_file_id"] = file_id
+    session["uploaded_file_path"] = entry["path"]
+    session["uploaded_file_name"] = entry["name"]
+    session["uploaded_file_type"] = entry["type"]
+    if entry.get("source") == "globus":
+        session["globus_file_path"] = entry["path"]
+        session["globus_file_name"] = entry["name"]
+        session["globus_file_type"] = entry["type"]
+        session["globus_endpoint_id"] = entry.get("endpoint_id")
+    else:
+        for k in ("globus_file_path", "globus_file_name",
+                  "globus_file_type", "globus_endpoint_id"):
+            session.pop(k, None)
+    return True
+
+
+def clear_uploaded_files():
+    """Remove the file list and all active/legacy file pointers."""
+    try:
+        os.remove(_files_store_path())
+    except OSError:
+        pass
+    for k in ("active_file_id", "uploaded_file_path", "uploaded_file_name",
+              "uploaded_file_type", "globus_file_path", "globus_file_name",
+              "globus_file_type", "globus_endpoint_id"):
+        session.pop(k, None)
+
+
 def generate_metric_cache_key(file_name, metric_type, **params):
     """Generate a user-specific cache key for metrics."""
     user_id = get_current_user_id()
-    cache_parts = [f"user:{user_id}", f"file:{file_name}"]
+    file_token = session.get("active_file_id") or file_name
+    cache_parts = [f"user:{user_id}", f"file:{file_token}"]
 
     if metric_type == "dp":
         features = params.get("features", [])
@@ -170,8 +256,10 @@ def store_result(metric, final_dict):
     # Also store a persistent user-scoped copy for the cache info page
     user_id = get_current_user_id()
     metric_short = metric.rsplit(".", 1)[-1] if "." in metric else metric
-    file_name = session.get("uploaded_file_name") or session.get("globus_file_name") or "unknown"
-    user_key = f"user:{user_id}:file:{file_name}:{metric_short}"
+    file_token = session.get("active_file_id") or (
+        session.get("uploaded_file_name") or session.get("globus_file_name") or "unknown"
+    )
+    user_key = f"user:{user_id}:file:{file_token}:{metric_short}"
     current_app.TEMP_RESULTS_CACHE[user_key] = {
         "data": formatted_final_dict,
         "timestamp": time.time(),
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index b93a92cc..701ac0d9 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -58,8 +58,18 @@ function showPanel(panelId, pushHistory) {
   }
 
   // Lazy init CodeMirror for custom metrics
-  if (panelId === "custom-metrics" && !codeMirrorEditor) {
-    initCodeMirror();
+  if (panelId === "custom-metrics") {
+    if (!codeMirrorEditor) {
+      initCodeMirror();
+    } else {
+      // The editor may have been created or had setValue() called while the
+      // panel was hidden (e.g. on a reload where the hash restored this panel
+      // and batch-mode then showed the overview). CodeMirror renders blank in
+      // that case until refreshed once the panel is visible again.
+      setTimeout(function () {
+        codeMirrorEditor.refresh();
+      }, 0);
+    }
   }
 
   // Close mobile sidebar after selection
@@ -464,11 +474,43 @@ function workspaceSubmit(targetUrl) {
             gFormData.getAll("quasi identifiers for entropy risk"),
           ),
         };
+      } else if (
+        gFormData.get("differential privacy") === "yes" ||
+        gFormData.get("single attribute risk score") === "yes" ||
+        gFormData.get("multiple attribute risk score") === "yes"
+      ) {
+        // These privacy metrics have no remote handler yet — tell the user
+        // plainly instead of silently falling back to k-anonymity.
+        if (typeof showToast === "function")
+          showToast(
+            "That privacy metric isn't available for remote (Globus) files yet. " +
+              "Remotely supported: k-anonymity, l-diversity, t-closeness, entropy risk. " +
+              "Use a locally uploaded file for the others.",
+            "error",
+          );
+        return;
       }
     } else {
       remoteDisplayName = metricDisplayMap[remoteName] || remoteName;
     }
 
+    // Guard: privacy metrics need at least one quasi-identifier — catch it here
+    // for instant feedback instead of a slow remote round-trip that errors.
+    const qiMetrics = [
+      "k_anonymity",
+      "l_diversity",
+      "t_closeness",
+      "entropy_risk",
+    ];
+    if (
+      qiMetrics.includes(remoteName) &&
+      (!remoteParams.quasi_ids || remoteParams.quasi_ids.length === 0)
+    ) {
+      if (typeof showToast === "function")
+        showToast("Please select at least one quasi-identifier.", "error");
+      return;
+    }
+
     submitGlobusMetric(remoteName, remoteParams, remoteDisplayName);
     return;
   }
@@ -1141,11 +1183,10 @@ function loadGlobusDataset() {
     .getElementById("globus-endpoint-id")
     ?.value?.trim();
   const filePath = document.getElementById("globus-file-path")?.value?.trim();
-  const fileType = document.getElementById("globus-file-type")?.value;
 
   if (!endpointId || !filePath) {
     if (typeof showToast === "function")
-      showToast("Please fill in endpoint UUID and file path", "error");
+      showToast("Please fill in endpoint UUID and file/folder path", "error");
     return;
   }
 
@@ -1166,22 +1207,16 @@ function loadGlobusDataset() {
     el.classList.add("opacity-50");
   });
 
-  const fileName = filePath.split("/").pop();
-
   if (typeof showToast === "function")
-    showToast("Connecting to remote endpoint...", "info");
+    showToast("Listing files on the remote endpoint...", "info");
 
-  fetch("/globus/submit", {
+  // Add the remote file, or every supported file in the remote folder. The
+  // server lists the path on the endpoint and infers each type from its
+  // extension.
+  fetch("/globus/add-files", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      endpoint_id: endpointId,
-      file_path: filePath,
-      file_name: fileName,
-      file_type: fileType,
-      metric_name: "completeness",
-      params: {},
-    }),
+    body: JSON.stringify({ endpoint_id: endpointId, path: filePath }),
   })
     .then((r) => r.json())
     .then((data) => {
@@ -1190,14 +1225,26 @@ function loadGlobusDataset() {
         if (typeof showToast === "function") showToast(data.error, "error");
         return;
       }
-      // Reload the page — session now has globus file info,
-      // inspector will show sidebar + panels
+      if (
+        data.skipped &&
+        data.skipped.length &&
+        typeof showToast === "function"
+      ) {
+        showToast(`Skipped ${data.skipped.length} unsupported file(s)`, "info");
+      }
+      if (data.overview_error && typeof showToast === "function") {
+        // The files were added, but the per-file stats (records/features) could
+        // not be computed remotely — surface why instead of silent dashes.
+        showToast("File stats unavailable: " + data.overview_error, "error");
+      }
+      // Reload — the session now has the active Globus file; the inspector
+      // shows the workspace (or the batch overview for a multi-file folder).
       window.location.href = "/inspector";
     })
     .catch((err) => {
       _reEnableGlobusForm();
       if (typeof showToast === "function")
-        showToast("Failed to connect: " + err.message, "error");
+        showToast("Failed to add remote files: " + err.message, "error");
     });
 }
 
@@ -2151,6 +2198,196 @@ function renderWorkspaceHistograms(histograms) {
   container.innerHTML = html;
 }
 
+// ==================== Batch Overview ====================
+
+function fmtBytes(n) {
+  if (!n && n !== 0) return "—";
+  const u = ["B", "KB", "MB", "GB"];
+  let i = 0,
+    v = n;
+  while (v >= 1024 && i < u.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v < 10 && i > 0 ? 1 : 0)} ${u[i]}`;
+}
+
+function loadBatchOverview() {
+  fetch("/files/summary")
+    .then((r) => r.json())
+    .then((data) => {
+      const totals = document.getElementById("batch-totals");
+      if (totals) {
+        const t = data.totals || {};
+        totals.innerHTML = "";
+        [
+          ["Files", t.file_count ?? 0],
+          ["Loaded OK", t.ok_count ?? 0],
+          ["Failed", t.error_count ?? 0],
+          ["Total records", (t.total_records ?? 0).toLocaleString()],
+        ].forEach(([label, value]) => {
+          const card = document.createElement("div");
+          card.className =
+            "p-4 bg-gray-50 dark:bg-gray-700/50 border border-gray-200 dark:border-gray-600 rounded-lg text-center";
+          const v = document.createElement("div");
+          v.className = "text-3xl font-bold text-gray-900 dark:text-white";
+          v.textContent = value;
+          const k = document.createElement("div");
+          k.className =
+            "text-xs font-medium text-gray-500 dark:text-gray-400 mt-1 uppercase tracking-wide";
+          k.textContent = label;
+          card.appendChild(v);
+          card.appendChild(k);
+          totals.appendChild(card);
+        });
+      }
+
+      const tbody = document.getElementById("batch-rows");
+      if (!tbody) return;
+      const rows = [...(data.files || [])].sort((a, b) =>
+        a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+      );
+      tbody.innerHTML = "";
+      rows.forEach((f) => {
+        const tr = document.createElement("tr");
+        tr.className =
+          "border-b dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-700/50 cursor-pointer";
+        // Records/features/numerical/categorical come from the backend for both
+        // local and globus files (globus stats are computed on the endpoint at
+        // add time); "—" until available.
+        const cells = [
+          f.name,
+          f.type || "?",
+          f.source,
+          f.records ?? "—",
+          f.features ?? "—",
+          f.numerical ?? "—",
+          f.categorical ?? "—",
+          fmtBytes(f.size_bytes),
+        ];
+        cells.forEach((text, idx) => {
+          const td = document.createElement("td");
+          td.className = "px-3 py-2" + (idx >= 3 ? " text-right" : "");
+          td.textContent = text;
+          tr.appendChild(td);
+        });
+        tr.addEventListener("click", () => activateFile(f.id));
+        tbody.appendChild(tr);
+      });
+    })
+    .catch((err) => console.error("Failed to load batch overview:", err));
+}
+
+// ==================== Top-Bar File Selector ====================
+
+let _fileSelectorFiles = [];
+let _fileSelectorActiveId = null;
+
+function loadFileSelector() {
+  fetch("/files")
+    .then((r) => r.json())
+    .then((data) => {
+      _fileSelectorFiles = data.files || [];
+      _fileSelectorActiveId = data.active_file_id;
+      const count = document.getElementById("file-selector-count");
+      if (count) {
+        if (_fileSelectorFiles.length > 1) {
+          count.textContent = `${_fileSelectorFiles.length} ▾`;
+          count.classList.remove("hidden");
+        } else {
+          count.classList.add("hidden");
+        }
+      }
+      renderFileSelectorList();
+    })
+    .catch((err) => console.error("Failed to load file selector:", err));
+}
+
+function renderFileSelectorList() {
+  const ul = document.getElementById("file-selector-list");
+  if (!ul) return;
+  const q = (
+    document.getElementById("file-selector-search")?.value || ""
+  ).toLowerCase();
+  const files = [..._fileSelectorFiles]
+    .filter((f) => f.name.toLowerCase().includes(q))
+    .sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+  ul.innerHTML = "";
+  if (files.length === 0) {
+    const li = document.createElement("li");
+    li.className = "px-3 py-2 text-xs text-gray-400";
+    li.textContent = "No matching files";
+    ul.appendChild(li);
+    return;
+  }
+  files.forEach((f) => {
+    const li = document.createElement("li");
+    const active = f.id === _fileSelectorActiveId;
+    li.className =
+      "flex items-center gap-2 px-3 py-1.5 cursor-pointer text-sm " +
+      (active
+        ? "bg-blue-50 text-blue-700 dark:bg-blue-900/30"
+        : "hover:bg-black/5 dark:hover:bg-white/10");
+    const name = document.createElement("span");
+    name.className = "truncate flex-1";
+    name.textContent = f.name;
+    const type = document.createElement("span");
+    type.className = "text-xs text-gray-400";
+    type.textContent = f.type || "?";
+    li.appendChild(name);
+    li.appendChild(type);
+    li.addEventListener("click", () => activateFile(f.id));
+    ul.appendChild(li);
+  });
+}
+
+function toggleFileSelector(event) {
+  if (event) event.stopPropagation();
+  const dd = document.getElementById("file-selector-dropdown");
+  if (!dd) return;
+  const willOpen = dd.classList.contains("hidden");
+  dd.classList.toggle("hidden");
+  if (willOpen) {
+    const search = document.getElementById("file-selector-search");
+    if (search) {
+      search.value = "";
+      renderFileSelectorList();
+      search.focus();
+    }
+    document.addEventListener("click", _closeFileSelectorOnOutside);
+  } else {
+    document.removeEventListener("click", _closeFileSelectorOnOutside);
+  }
+}
+
+function _closeFileSelectorOnOutside(e) {
+  const wrap = document.getElementById("file-selector-dropdown");
+  const btn = document.getElementById("file-selector-btn");
+  if (wrap && !wrap.contains(e.target) && btn && !btn.contains(e.target)) {
+    wrap.classList.add("hidden");
+    document.removeEventListener("click", _closeFileSelectorOnOutside);
+  }
+}
+
+function activateFile(fileId) {
+  fetch(`/files/${fileId}/activate`, { method: "POST" })
+    .then((r) => r.json())
+    .then((b) => {
+      if (b.success) {
+        // Land on the new file's Data Overview, not the batch list.
+        window.location.hash = "data-overview";
+        window.location.reload();
+      } else if (typeof showToast === "function") {
+        showToast(b.message || "Could not switch file", "error");
+      }
+    })
+    .catch((err) => {
+      console.error("Failed to activate file:", err);
+      if (typeof showToast === "function")
+        showToast("Could not switch file", "error");
+    });
+}
+
 // ==================== Workspace Init ====================
 
 /**
@@ -2158,11 +2395,16 @@ function renderWorkspaceHistograms(histograms) {
  * Fetches summary statistics and populates feature dropdowns.
  */
 function initWorkspace() {
+  // Populate top-bar file selector
+  loadFileSelector();
+
   // Restore panel from URL hash, or default to data-overview
   const hash = location.hash.replace("#", "");
   const initialPanel =
     hash && document.getElementById("panel-" + hash) ? hash : "data-overview";
   showPanel(initialPanel, false); // false = don't push to history on init
+  // Populate the batch overview when it's the landing panel (e.g. fresh upload)
+  if (initialPanel === "batch-overview") loadBatchOverview();
   // Replace current history entry so back button works from the first panel
   history.replaceState({ panel: initialPanel }, "", "#" + initialPanel);
 
diff --git a/web/static/js/main.js b/web/static/js/main.js
index 62916271..cee69cd5 100644
--- a/web/static/js/main.js
+++ b/web/static/js/main.js
@@ -24,39 +24,60 @@ function togglePillarDropdown(id) {
 //for uploads
 function uploadForm() {
   const form = document.getElementById("uploadForm");
-  const fileTypeSelector = document.getElementById("fileTypeSelector");
   const fileInput = document.getElementById("file");
-
-  // Check if file type is selected
-  if (!fileTypeSelector.value) {
-    if (typeof showToast === "function")
-      showToast("Please select a file type first", "error");
-    return;
-  }
-
-  // Check if file is selected
   if (!fileInput.files || fileInput.files.length === 0) {
     if (typeof showToast === "function")
-      showToast("Please select a file to upload", "error");
+      showToast("Please select at least one file", "error");
     return;
   }
-
-  // Check the file does not exceed the server's upload size limit
+  // Check the upload does not exceed the server's size limit. MAX_CONTENT_LENGTH
+  // caps the whole request body, so check the combined size of all files.
   const maxBytes = parseInt(form.dataset.maxUploadBytes, 10);
-  if (maxBytes && fileInput.files[0].size > maxBytes) {
-    const maxMb =
-      form.dataset.maxUploadMb || Math.round(maxBytes / (1024 * 1024));
-    if (typeof showToast === "function")
-      showToast(
-        `File too large. The maximum upload size is ${maxMb} MB.`,
-        "error",
-      );
-    fileInput.value = "";
-    return;
+  if (maxBytes) {
+    let total = 0;
+    for (const f of fileInput.files) total += f.size;
+    if (total > maxBytes) {
+      const maxMb =
+        form.dataset.maxUploadMb || Math.round(maxBytes / (1024 * 1024));
+      if (typeof showToast === "function")
+        showToast(
+          `Upload too large. The maximum total upload size is ${maxMb} MB.`,
+          "error",
+        );
+      fileInput.value = "";
+      return;
+    }
   }
 
-  // Submit the form normally
-  form.submit();
+  const data = new FormData();
+  for (const f of fileInput.files) data.append("file", f);
+  fetch(form.action, {
+    method: "POST",
+    body: data,
+    headers: { Accept: "application/json" },
+  })
+    .then((r) => {
+      if (r.redirected) {
+        window.location.href = r.url;
+        return null;
+      }
+      if (r.ok) {
+        window.location.reload();
+        return null;
+      }
+      return r.json().catch(() => ({
+        success: false,
+        message: `Upload failed (${r.status})`,
+      }));
+    })
+    .then((body) => {
+      if (body && body.success === false && typeof showToast === "function")
+        showToast(body.message || "Upload failed", "error");
+    })
+    .catch((err) => {
+      if (typeof showToast === "function")
+        showToast("Upload failed: " + err.message, "error");
+    });
 }
 
 //to clear
@@ -93,29 +114,6 @@ function clearFile() {
     });
 }
 
-//changes file upload ability
-function updateFileInputBasedOnType(
-  fileTypeElement,
-  fileInput,
-  fileUploadMessage,
-) {
-  const fileType = fileTypeElement.value;
-  //if a filetype is present, set to that filetype only, otherwise disable
-  if (fileType) {
-    fileInput.disabled = false;
-    fileInput.setAttribute("accept", fileType);
-    debugLog("USER SELECTED FILETYPE: " + fileType);
-    fileUploadMessage.style.opacity = "1";
-    fileUploadMessage.textContent = "Click to upload or drag and drop";
-  } else {
-    fileInput.disabled = true;
-    fileInput.removeAttribute("accept");
-    fileUploadMessage.style.opacity = "0.6";
-    fileUploadMessage.textContent = "Select a file type first";
-    debugLog("FILE UPLOAD DISABLED");
-  }
-}
-
 // Add these functions before the submitForm function
 
 // Function to categorize error types for DP Statistics
diff --git a/web/templates/_components/globus_panel.html b/web/templates/_components/globus_panel.html
index 865e41e3..2479bf49 100644
--- a/web/templates/_components/globus_panel.html
+++ b/web/templates/_components/globus_panel.html
@@ -35,22 +35,13 @@ <h3 class="text-base font-semibold text-gray-900 dark:text-white mb-2">Connect t
                style="max-width: none;" />
       </div>
 
-      <!-- Remote file path -->
+      <!-- Remote file or folder path -->
       <div class="mb-4">
-        <label class="block text-sm font-medium mb-1.5 text-gray-900 dark:text-white">File path on remote endpoint</label>
-        <input type="text" id="globus-file-path" placeholder="e.g., /data/datasets/adult.csv"
+        <label class="block text-sm font-medium mb-1.5 text-gray-900 dark:text-white">File or folder path on remote endpoint</label>
+        <input type="text" id="globus-file-path" placeholder="e.g., /data/datasets/adult.csv  or  /data/datasets/"
                class="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg bg-gray-50 dark:bg-gray-700 dark:border-gray-600 dark:text-white focus:ring-blue-500 focus:border-blue-500"
                style="max-width: none;" />
-      </div>
-
-      <!-- File type selector -->
-      <div class="mb-4">
-        <label class="block text-sm font-medium mb-1.5 text-gray-900 dark:text-white">File type</label>
-        <select id="globus-file-type" class="w-full" style="max-width: none;">
-          {% for ext, label in supported_file_types %}
-            <option value="{{ ext }}">{{ label }} ({{ ext }})</option>
-          {% endfor %}
-        </select>
+        <p class="mt-1 text-xs text-gray-500 dark:text-gray-400">A single file, or a folder to add all supported files in it. Type is detected from the extension.</p>
       </div>
 
       <!-- Load dataset button -->
diff --git a/web/templates/_components/sidebar.html b/web/templates/_components/sidebar.html
index f7c6dd3f..821e8b7d 100644
--- a/web/templates/_components/sidebar.html
+++ b/web/templates/_components/sidebar.html
@@ -10,6 +10,16 @@
       <img src="/images/logoNoBackground.png" class="w-1/2" alt="AIDRIN Logo" />
     </a>
 
+    <!-- Batch Overview (only when multiple files are loaded) -->
+    {% if file_count and file_count > 1 %}
+    <button onclick="showPanel('batch-overview'); loadBatchOverview()"
+            class="sidebar-item flex items-center w-full p-2 mb-2 rounded-lg text-sm font-semibold transition-colors hover:bg-black/10 dark:hover:bg-white/10"
+            style="color: var(--textColor);">
+      <svg class="w-5 h-5 mr-2 shrink-0 text-gray-500 dark:text-gray-400" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M6.429 9.75L2.25 12l4.179 2.25m0-4.5l5.571 3 5.571-3m-11.142 0L2.25 7.5 12 2.25l9.75 5.25-4.179 2.25m0 0L21.75 12l-4.179 2.25m0 0l4.179 2.25L12 21.75 2.25 16.5l4.179-2.25m11.142 0l-5.571 3-5.571-3"/></svg>
+      Batch Overview
+    </button>
+    {% endif %}
+
     <!-- Data Overview -->
     <button onclick="showPanel('data-overview')"
             class="sidebar-item flex items-center w-full p-2 mb-2 rounded-lg text-sm font-semibold transition-colors hover:bg-black/10 dark:hover:bg-white/10"
@@ -112,11 +122,7 @@
         <svg class="w-4 h-4 transition-transform text-gray-400" id="pillar-structure-arrow" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M19.5 8.25l-7.5 7.5-7.5-7.5"/></svg>
       </button>
       <ul id="pillar-structure" class="hidden pl-9 space-y-1 pt-1">
-        {% if file_type == '.csv' %}
         <li><button onclick="showPanel('custom-metrics')" class="sidebar-metric-item w-full text-left p-1.5 rounded-md text-sm hover:bg-black/10 dark:hover:bg-white/10 transition-colors" style="color: var(--textColorSecondary);">Custom Metrics</button></li>
-        {% else %}
-        <li><span class="p-1.5 text-sm opacity-50" title="Custom metrics require CSV files">Custom Metrics (CSV only)</span></li>
-        {% endif %}
       </ul>
     </div>
 
diff --git a/web/templates/_components/topbar.html b/web/templates/_components/topbar.html
index 3f6ac948..7bac8a4c 100644
--- a/web/templates/_components/topbar.html
+++ b/web/templates/_components/topbar.html
@@ -21,15 +21,32 @@
       <!-- Center: file info (visible only when a file is loaded) -->
       {% if uploaded_file_path %}
       <div class="hidden sm:flex items-center gap-2 px-3 py-1 rounded-lg text-sm" style="background: var(--backgroundColor);">
+        <div class="relative">
+          <button id="file-selector-btn" type="button" onclick="toggleFileSelector(event)"
+                  class="flex items-center gap-2 max-w-xs">
+            {% if globus_mode %}
+            <!-- Globus remote file icon -->
+            <svg class="w-4 h-4 text-blue-500 shrink-0" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M20.893 13.393l-1.135-1.135a2.252 2.252 0 01-.421-.585l-1.08-2.16a.414.414 0 00-.663-.107.827.827 0 01-.812.21l-1.273-.363a.89.89 0 00-.738 1.595l.587.39c.59.395.674 1.23.172 1.732l-.2.2c-.212.212-.33.498-.33.796v.41c0 .409-.11.809-.32 1.158l-1.315 2.191a2.11 2.11 0 01-1.81 1.025 1.055 1.055 0 01-1.055-1.055v-1.172c0-.92-.56-1.747-1.414-2.089l-.655-.261a2.25 2.25 0 01-1.383-2.46l.007-.042a2.25 2.25 0 01.29-.787l.09-.15a2.25 2.25 0 012.37-1.048l1.178.236a1.125 1.125 0 001.302-.795l.208-.73a1.125 1.125 0 00-.578-1.315l-.665-.332-.091.091a2.25 2.25 0 01-1.591.659h-.18c-.249 0-.487.1-.662.274a.931.931 0 01-1.458-1.137l1.411-2.353a2.25 2.25 0 00.286-.76m11.928 9.869A9 9 0 008.965 3.525m11.928 9.868A9 9 0 118.965 3.525"/></svg>
+            {% else %}
+            <!-- Local file icon -->
+            <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 shrink-0" viewBox="0 -960 960 960" fill="currentColor"><path d="M240-80q-33 0-56.5-23.5T160-160v-640q0-33 23.5-56.5T240-880h320l240 240v480q0 33-23.5 56.5T720-80H240Zm280-520v-200H240v640h480v-440H520ZM240-800v200-200 640-640Z"/></svg>
+            {% endif %}
+            <span id="file-selector-active" class="font-medium truncate">{{ uploaded_file_name }}</span>
+            <span id="file-selector-count" class="text-xs text-gray-400 hidden"></span>
+            <svg class="w-3 h-3 text-gray-400 shrink-0" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7"/></svg>
+          </button>
+          <div id="file-selector-dropdown"
+               class="hidden absolute left-0 mt-2 w-72 max-h-80 overflow-hidden rounded-lg border border-gray-200 dark:border-gray-700 bg-[var(--secondaryColor)] shadow-lg z-50">
+            <div class="p-2 border-b border-gray-200 dark:border-gray-700">
+              <input id="file-selector-search" type="text" placeholder="Filter files…"
+                     oninput="renderFileSelectorList()"
+                     class="w-full px-2 py-1 text-sm rounded border border-gray-300 dark:border-gray-600 bg-transparent" />
+            </div>
+            <ul id="file-selector-list" class="max-h-64 overflow-y-auto py-1"></ul>
+          </div>
+        </div>
         {% if globus_mode %}
-        <!-- Globus remote file indicator -->
-        <svg class="w-4 h-4 text-blue-500" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M20.893 13.393l-1.135-1.135a2.252 2.252 0 01-.421-.585l-1.08-2.16a.414.414 0 00-.663-.107.827.827 0 01-.812.21l-1.273-.363a.89.89 0 00-.738 1.595l.587.39c.59.395.674 1.23.172 1.732l-.2.2c-.212.212-.33.498-.33.796v.41c0 .409-.11.809-.32 1.158l-1.315 2.191a2.11 2.11 0 01-1.81 1.025 1.055 1.055 0 01-1.055-1.055v-1.172c0-.92-.56-1.747-1.414-2.089l-.655-.261a2.25 2.25 0 01-1.383-2.46l.007-.042a2.25 2.25 0 01.29-.787l.09-.15a2.25 2.25 0 012.37-1.048l1.178.236a1.125 1.125 0 001.302-.795l.208-.73a1.125 1.125 0 00-.578-1.315l-.665-.332-.091.091a2.25 2.25 0 01-1.591.659h-.18c-.249 0-.487.1-.662.274a.931.931 0 01-1.458-1.137l1.411-2.353a2.25 2.25 0 00.286-.76m11.928 9.869A9 9 0 008.965 3.525m11.928 9.868A9 9 0 118.965 3.525"/></svg>
-        <span class="font-medium">{{ uploaded_file_name }}</span>
         <span class="text-xs text-gray-400 dark:text-gray-500">via Globus</span>
-        {% else %}
-        <!-- Local file indicator -->
-        <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" viewBox="0 -960 960 960" fill="currentColor"><path d="M240-80q-33 0-56.5-23.5T160-160v-640q0-33 23.5-56.5T240-880h320l240 240v480q0 33-23.5 56.5T720-80H240Zm280-520v-200H240v640h480v-440H520ZM240-800v200-200 640-640Z"/></svg>
-        <span class="font-medium">{{ uploaded_file_name }}</span>
         {% endif %}
         <button onclick="clearFile()" class="ml-1 p-1 rounded hover:bg-red-100 dark:hover:bg-red-900/30 text-red-500 transition-colors" title="Clear file" aria-label="Clear uploaded file">
           <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg>
diff --git a/web/templates/_components/upload_panel.html b/web/templates/_components/upload_panel.html
index c7f2fc0d..1c6bb6a3 100644
--- a/web/templates/_components/upload_panel.html
+++ b/web/templates/_components/upload_panel.html
@@ -1,91 +1,200 @@
 <!-- Upload panel: shown before a file is uploaded -->
-<div id="upload-panel" class="flex flex-col items-center pt-12 px-4 min-h-[60vh]">
+<div
+  id="upload-panel"
+  class="flex flex-col items-center pt-12 px-4 min-h-[60vh]"
+>
   <div class="w-full max-w-lg">
-
     <!-- Logo + title -->
     <div class="flex flex-col items-center mb-6">
-      <img src="/images/logoNoBackground.png" class="h-20 mb-4" alt="AIDRIN Logo" />
-      <h2 class="text-2xl font-semibold text-center text-gray-900 dark:text-white">
+      <img
+        src="/images/logoNoBackground.png"
+        class="h-20 mb-4"
+        alt="AIDRIN Logo"
+      />
+      <h2
+        class="text-2xl font-semibold text-center text-gray-900 dark:text-white"
+      >
         AI Data Readiness Infrastructure
       </h2>
-      <p class="text-xs mt-1 text-gray-400 dark:text-gray-500">v{{ app_version }}</p>
-      <a href="https://aidrin.readthedocs.io/en/latest/" target="_blank"
-         class="text-sm mt-2 text-blue-600 dark:text-blue-400 hover:underline">
+      <p class="text-xs mt-1 text-gray-400 dark:text-gray-500">
+        v{{ app_version }}
+      </p>
+      <a
+        href="https://aidrin.readthedocs.io/en/latest/"
+        target="_blank"
+        class="text-sm mt-2 text-blue-600 dark:text-blue-400 hover:underline"
+      >
         aidrin.readthedocs.io
       </a>
     </div>
 
     <!-- Tab switcher: Upload / Globus (conditional) / ADROIT -->
     <div class="flex border-b border-gray-200 dark:border-gray-700 mb-4">
-      <button type="button" onclick="switchUploadTab('local')" id="tab-local"
-              class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 {{ 'border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400' if globus_available and globus_authenticated else 'border-blue-600 text-blue-600 dark:text-blue-500 dark:border-blue-500' }}">
+      <button
+        type="button"
+        onclick="switchUploadTab('local')"
+        id="tab-local"
+        class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 {{ 'border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400' if globus_available and globus_authenticated else 'border-blue-600 text-blue-600 dark:text-blue-500 dark:border-blue-500' }}"
+      >
         Upload File
       </button>
       {% if globus_available %}
-      <button type="button" onclick="switchUploadTab('globus')" id="tab-globus"
-              class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 {{ 'border-blue-600 text-blue-600 dark:text-blue-500 dark:border-blue-500' if globus_authenticated else 'border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400' }}">
+      <button
+        type="button"
+        onclick="switchUploadTab('globus')"
+        id="tab-globus"
+        class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 {{ 'border-blue-600 text-blue-600 dark:text-blue-500 dark:border-blue-500' if globus_authenticated else 'border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400' }}"
+      >
         Remote (Globus)
       </button>
       {% endif %}
-      <button type="button" onclick="switchUploadTab('cli')" id="tab-cli"
-              class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400">
+      <button
+        type="button"
+        onclick="switchUploadTab('cli')"
+        id="tab-cli"
+        class="upload-tab flex-1 py-2.5 text-sm font-medium text-center border-b-2 border-transparent text-gray-500 hover:text-gray-600 hover:border-gray-300 dark:text-gray-400"
+      >
         CLI
       </button>
     </div>
 
     <!-- Local upload card -->
-    <div id="local-upload" class="{{ 'hidden' if globus_available and globus_authenticated else '' }}">
-      <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5">
-        <form id="uploadForm" method="post" enctype="multipart/form-data" action="{{ url_for('core.inspector') }}" data-max-upload-bytes="{{ max_upload_bytes }}" data-max-upload-mb="{{ max_upload_mb }}">
-
-          <!-- File type selector -->
-          <label for="fileTypeSelector" class="block text-sm font-medium mb-1.5 text-gray-900 dark:text-white">File type</label>
-          <select id="fileTypeSelector" name="fileTypeSelector" class="w-full mb-4" style="max-width: none;">
-            <option disabled value="" {% if not file_type %}selected{% endif %}>Select a File Type</option>
-            {% for ext, label in supported_file_types %}
-              <option value="{{ ext }}" {% if file_type == ext %}selected{% endif %}>{{ label }} ({{ ext }})</option>
-            {% endfor %}
-          </select>
-
+    <div
+      id="local-upload"
+      class="{{ 'hidden' if globus_available and globus_authenticated else '' }}"
+    >
+      <div
+        class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5"
+      >
+        <form
+          id="uploadForm"
+          method="post"
+          enctype="multipart/form-data"
+          action="{{ url_for('core.inspector') }}"
+          data-max-upload-bytes="{{ max_upload_bytes }}"
+          data-max-upload-mb="{{ max_upload_mb }}"
+        >
           <!-- Dropzone -->
-          <label id="fileUploadContainer" for="file"
-                 class="flex flex-col items-center justify-center w-full h-40 border-2 border-gray-300 border-dashed rounded-lg cursor-pointer bg-gray-50 dark:bg-gray-700 hover:bg-gray-100 dark:border-gray-600 dark:hover:border-gray-500 dark:hover:bg-gray-600 transition-colors">
+          <label
+            id="fileUploadContainer"
+            for="file"
+            class="flex flex-col items-center justify-center w-full h-40 border-2 border-gray-300 border-dashed rounded-lg cursor-pointer bg-gray-50 dark:bg-gray-700 hover:bg-gray-100 dark:border-gray-600 dark:hover:border-gray-500 dark:hover:bg-gray-600 transition-colors"
+          >
             <div class="flex flex-col items-center justify-center pt-5 pb-6">
-              <svg class="w-8 h-8 mb-3 text-gray-400" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12"/>
+              <svg
+                class="w-8 h-8 mb-3 text-gray-400"
+                fill="none"
+                stroke="currentColor"
+                stroke-width="1.5"
+                viewBox="0 0 24 24"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12"
+                />
               </svg>
-              <p class="mb-1 text-sm text-gray-500 dark:text-gray-400"><span class="font-semibold">Click to upload</span> or drag and drop</p>
-              <p id="FileUploadMessage" class="text-xs text-gray-500 dark:text-gray-400">Select a file type first</p>
+              <p class="mb-1 text-sm text-gray-500 dark:text-gray-400">
+                <span class="font-semibold">Click to upload</span> or drag and
+                drop
+              </p>
+              <p
+                id="FileUploadMessage"
+                class="text-xs text-gray-500 dark:text-gray-400"
+              >
+                Supported: CSV, Excel, JSON, NumPy (.npz), HDF5
+              </p>
             </div>
-            <input id="file" name="file" type="file" class="hidden" required onchange="uploadForm();" />
+            <input
+              id="file"
+              name="file"
+              type="file"
+              multiple
+              class="hidden"
+              required
+              onchange="uploadForm()"
+            />
           </label>
-
         </form>
       </div>
 
       <!-- Sample data + publications links (inside local tab) -->
       <div class="flex justify-between mt-5 px-1">
-        <button onclick="toggleSampleData()" class="inline-flex items-center gap-1.5 text-sm font-medium text-blue-600 dark:text-blue-400 hover:underline">
-          <svg class="w-4 h-4" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M3 16.5v2.25A2.25 2.25 0 005.25 21h13.5A2.25 2.25 0 0021 18.75V16.5M16.5 12L12 16.5m0 0L7.5 12m4.5 4.5V3"/></svg>
+        <button
+          onclick="toggleSampleData()"
+          class="inline-flex items-center gap-1.5 text-sm font-medium text-blue-600 dark:text-blue-400 hover:underline"
+        >
+          <svg
+            class="w-4 h-4"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.5"
+            viewBox="0 0 24 24"
+          >
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              d="M3 16.5v2.25A2.25 2.25 0 005.25 21h13.5A2.25 2.25 0 0021 18.75V16.5M16.5 12L12 16.5m0 0L7.5 12m4.5 4.5V3"
+            />
+          </svg>
           Sample Data
         </button>
-        <a href="{{ url_for('admin.publications') }}" class="inline-flex items-center gap-1.5 text-sm font-medium text-blue-600 dark:text-blue-400 hover:underline">
+        <a
+          href="{{ url_for('admin.publications') }}"
+          class="inline-flex items-center gap-1.5 text-sm font-medium text-blue-600 dark:text-blue-400 hover:underline"
+        >
           Publications
-          <svg class="w-4 h-4" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 003 8.25v10.5A2.25 2.25 0 005.25 21h10.5A2.25 2.25 0 0018 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"/></svg>
+          <svg
+            class="w-4 h-4"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.5"
+            viewBox="0 0 24 24"
+          >
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              d="M13.5 6H5.25A2.25 2.25 0 003 8.25v10.5A2.25 2.25 0 005.25 21h10.5A2.25 2.25 0 0018 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"
+            />
+          </svg>
         </a>
       </div>
 
       <!-- Sample data container (hidden by default) -->
       <div id="sampleDataContainer" class="sampleDataContainer mt-4">
-        <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5">
-          <h3 class="text-base font-semibold text-gray-900 dark:text-white mb-3">Sample Datasets</h3>
-          <div class="flex items-center gap-2 p-3 text-sm text-blue-800 rounded-lg bg-blue-50 dark:bg-blue-900/20 dark:text-blue-400 mb-3">
-            <svg class="w-4 h-4 shrink-0" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" d="M11.25 11.25l.041-.02a.75.75 0 011.063.852l-.708 2.836a.75.75 0 001.063.853l.041-.021M21 12a9 9 0 11-18 0 9 9 0 0118 0zm-9-3.75h.008v.008H12V8.25z"/></svg>
+        <div
+          class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5"
+        >
+          <h3
+            class="text-base font-semibold text-gray-900 dark:text-white mb-3"
+          >
+            Sample Datasets
+          </h3>
+          <div
+            class="flex items-center gap-2 p-3 text-sm text-blue-800 rounded-lg bg-blue-50 dark:bg-blue-900/20 dark:text-blue-400 mb-3"
+          >
+            <svg
+              class="w-4 h-4 shrink-0"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="1.5"
+              viewBox="0 0 24 24"
+            >
+              <path
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                d="M11.25 11.25l.041-.02a.75.75 0 011.063.852l-.708 2.836a.75.75 0 001.063.853l.041-.021M21 12a9 9 0 11-18 0 9 9 0 0118 0zm-9-3.75h.008v.008H12V8.25z"
+              />
+            </svg>
             <span>Click any file below to download</span>
           </div>
           <div class="mb-3">
-            <label for="fileTypeSelect" class="block text-sm font-medium mb-1 text-gray-900 dark:text-white">Filter by type:</label>
-            <select id="fileTypeSelect" class="w-full" style="max-width: none;">
+            <label
+              for="fileTypeSelect"
+              class="block text-sm font-medium mb-1 text-gray-900 dark:text-white"
+              >Filter by type:</label
+            >
+            <select id="fileTypeSelect" class="w-full" style="max-width: none">
               <option value="">All Files</option>
               <option value="csv">CSV</option>
               <option value="dcat">DCAT</option>
@@ -103,39 +212,78 @@ <h3 class="text-base font-semibold text-gray-900 dark:text-white mb-3">Sample Da
 
     {% if globus_available %}
     <!-- Globus remote panel -->
-    <div id="globus-panel" class="{{ '' if globus_authenticated else 'hidden' }}">
+    <div
+      id="globus-panel"
+      class="{{ '' if globus_authenticated else 'hidden' }}"
+    >
       {% include '_components/globus_panel.html' %}
     </div>
     {% endif %}
 
     <!-- CLI panel -->
     <div id="cli-panel" class="hidden">
-      <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5">
+      <div
+        class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5"
+      >
         <div class="flex items-start gap-3 mb-4">
-          <div class="flex-shrink-0 w-9 h-9 rounded-lg flex items-center justify-center" style="background: var(--primaryColor, #2563eb)20;">
-            <svg class="w-5 h-5 text-blue-600 dark:text-blue-400" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M6.75 7.5l3 2.25-3 2.25m4.5 0h3m-9 8.25h13.5A2.25 2.25 0 0021 18V6a2.25 2.25 0 00-2.25-2.25H5.25A2.25 2.25 0 003 6v12a2.25 2.25 0 002.25 2.25z"/>
+          <div
+            class="flex-shrink-0 w-9 h-9 rounded-lg flex items-center justify-center"
+            style="background: var(--primaryColor, #2563eb) 20"
+          >
+            <svg
+              class="w-5 h-5 text-blue-600 dark:text-blue-400"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="1.5"
+              viewBox="0 0 24 24"
+            >
+              <path
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                d="M6.75 7.5l3 2.25-3 2.25m4.5 0h3m-9 8.25h13.5A2.25 2.25 0 0021 18V6a2.25 2.25 0 00-2.25-2.25H5.25A2.25 2.25 0 003 6v12a2.25 2.25 0 002.25 2.25z"
+              />
             </svg>
           </div>
           <div>
-            <h3 class="text-base font-semibold text-gray-900 dark:text-white">Command Line Interface</h3>
-            <p class="text-xs text-gray-500 dark:text-gray-400">Use AIDRIN directly from your terminal</p>
+            <h3 class="text-base font-semibold text-gray-900 dark:text-white">
+              Command Line Interface
+            </h3>
+            <p class="text-xs text-gray-500 dark:text-gray-400">
+              Use AIDRIN directly from your terminal
+            </p>
           </div>
         </div>
 
         <p class="text-sm text-gray-700 dark:text-gray-300 mb-3">
-          AIDRIN can be used from the command line without the web interface, enabling scripted and automated data readiness workflows. Install the package and run evaluations directly against your datasets.
+          AIDRIN can be used from the command line without the web interface,
+          enabling scripted and automated data readiness workflows. Install the
+          package and run evaluations directly against your datasets.
         </p>
         <p class="text-sm text-gray-600 dark:text-gray-400 mb-5">
-          The CLI is installed separately from the web interface — see the documentation for installation instructions and usage examples.
+          The CLI is installed separately from the web interface — see the
+          documentation for installation instructions and usage examples.
         </p>
 
-        <a href="https://aidrin.readthedocs.io/en/latest/cli.html" target="_blank" rel="noopener noreferrer"
-           class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-white rounded-lg transition-colors"
-           style="background-color: var(--primaryColor, #2563eb);">
+        <a
+          href="https://aidrin.readthedocs.io/en/latest/cli.html"
+          target="_blank"
+          rel="noopener noreferrer"
+          class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-white rounded-lg transition-colors"
+          style="background-color: var(--primaryColor, #2563eb)"
+        >
           View CLI Documentation
-          <svg class="w-4 h-4" fill="none" stroke="currentColor" stroke-width="1.5" viewBox="0 0 24 24">
-            <path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 003 8.25v10.5A2.25 2.25 0 005.25 21h10.5A2.25 2.25 0 0018 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"/>
+          <svg
+            class="w-4 h-4"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="1.5"
+            viewBox="0 0 24 24"
+          >
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              d="M13.5 6H5.25A2.25 2.25 0 003 8.25v10.5A2.25 2.25 0 005.25 21h10.5A2.25 2.25 0 0018 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"
+            />
           </svg>
         </a>
       </div>
diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
new file mode 100644
index 00000000..0a10a104
--- /dev/null
+++ b/web/templates/_panels/_batch_overview.html
@@ -0,0 +1,37 @@
+<!-- Batch Overview panel: totals strip + per-file table (shown after multi-file upload) -->
+<div id="panel-batch-overview" class="metric-panel hidden">
+  <div
+    class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5"
+  >
+    <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+      Batch Overview
+    </h2>
+
+    <!-- Totals strip -->
+    <div
+      id="batch-totals"
+      class="grid grid-cols-2 sm:grid-cols-4 gap-4 mb-6"
+    ></div>
+
+    <!-- Per-file table -->
+    <div class="relative overflow-x-auto rounded-lg shadow-sm">
+      <table class="w-full text-sm text-left text-gray-500 dark:text-gray-400">
+        <thead
+          class="text-xs text-gray-700 uppercase bg-gray-50 dark:bg-gray-700 dark:text-gray-400"
+        >
+          <tr>
+            <th scope="col" class="px-3 py-2.5">File</th>
+            <th scope="col" class="px-3 py-2.5">Type</th>
+            <th scope="col" class="px-3 py-2.5">Source</th>
+            <th scope="col" class="px-3 py-2.5 text-right">Records</th>
+            <th scope="col" class="px-3 py-2.5 text-right">Features</th>
+            <th scope="col" class="px-3 py-2.5 text-right">Numerical</th>
+            <th scope="col" class="px-3 py-2.5 text-right">Categorical</th>
+            <th scope="col" class="px-3 py-2.5 text-right">Size</th>
+          </tr>
+        </thead>
+        <tbody id="batch-rows"></tbody>
+      </table>
+    </div>
+  </div>
+</div>
diff --git a/web/templates/_panels/_custom_metrics.html b/web/templates/_panels/_custom_metrics.html
index a8affc14..b0f46463 100644
--- a/web/templates/_panels/_custom_metrics.html
+++ b/web/templates/_panels/_custom_metrics.html
@@ -1,4 +1,4 @@
-<!-- Custom Metrics panel (CodeMirror editor, CSV only) -->
+<!-- Custom Metrics panel (CodeMirror editor) -->
 <div id="panel-custom-metrics" class="metric-panel hidden">
   <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm p-5">
     <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">Define Custom Metric</h2>
diff --git a/web/templates/inspector.html b/web/templates/inspector.html
index c0a34d92..5b414164 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -55,6 +55,7 @@
 
         <!-- Metric configuration panels (only one visible at a time) -->
         <div id="panels-container">
+          {% include '_panels/_batch_overview.html' %}
           {% include '_panels/_data_overview.html' %}
           {% include '_panels/_data_quality.html' %}
           {% include '_panels/_feature_relevance.html' %}
@@ -85,7 +86,14 @@
       {% endif %}
 
       {% if uploaded_file_path and not globus_mode %}
+        // Initialise the workspace; it restores the panel from the URL hash
+        // (#data-overview when switching files, etc.).
         initWorkspace();
+        {% if land_on_batch %}
+          // Fresh multi-file upload: surface the batch overview as the landing.
+          loadBatchOverview();
+          showPanel('batch-overview');
+        {% endif %}
       {% elif globus_mode %}
         // Globus mode — flag for workspaceSubmit to route through Globus
         window.AIDRIN_GLOBUS_MODE = true;
@@ -93,6 +101,7 @@
         window.AIDRIN_GLOBUS_FILE_PATH = '{{ uploaded_file_path }}';
         window.AIDRIN_GLOBUS_FILE_NAME = '{{ uploaded_file_name }}';
         window.AIDRIN_GLOBUS_FILE_TYPE = '{{ file_type }}';
+        loadFileSelector();
         showPanel('data-overview');
         // Show Globus info banner + loading spinner for summary stats
         var ws = document.getElementById('workspace-summary');
@@ -175,17 +184,6 @@
       const sel = document.getElementById('fileTypeSelect');
       if (sel) sel.addEventListener('change', filterFiles);
 
-      // File type selector enables file input
-      const fileTypeEl = document.getElementById('fileTypeSelector');
-      const fileInput = document.getElementById('file');
-      const fileMsg = document.getElementById('FileUploadMessage');
-      if (fileTypeEl && fileInput && fileMsg) {
-        fileTypeEl.addEventListener('change', function() {
-          updateFileInputBasedOnType(fileTypeEl, fileInput, fileMsg);
-        });
-        updateFileInputBasedOnType(fileTypeEl, fileInput, fileMsg);
-      }
-
       // Drag and drop support for the upload dropzone
       const dropzone = document.getElementById('fileUploadContainer');
       const fileInput2 = document.getElementById('file');