From fada301fe5a78c38d475556dffaf111a9f541651 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 11:34:04 -0700
Subject: [PATCH 01/49] design: multi-file batch analysis (phase 1)

Spec for analyzing multiple independent files: a session-free core batch
primitive (summarize_files) reused by web/CLI/library, plus a web active-file
switcher (compatibility shim over the existing single-file session keys) and a
combined cross-file summary. Local upload and Globus feed one source-agnostic
file list; per-file type inferred from extension; max 50 files.

Globus is remote compute, so the file list/UI is unified but metric execution
stays dispatched by source (local routes vs remote_metric_runner); the combined
summary shows Globus files with metadata only in phase 1.
---
 ...-06-04-multi-file-batch-analysis-design.md | 235 ++++++++++++++++++
 1 file changed, 235 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md

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..b5dbd66b
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-04-multi-file-batch-analysis-design.md
@@ -0,0 +1,235 @@
+# 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:** the per-file error handling described here mirrors the
+`load_dataframe` helper and friendly-error mapping introduced on the
+`parquet-support` branch. If this feature lands before that work is merged, it
+should include an equivalent helper; otherwise it reuses it.
+
+## 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,
+        "completeness": float|None,   # fraction of non-null cells, 0..1
+        "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`; computes lightweight stats **without Celery**
+  (e.g. completeness = `df.notna().to_numpy().mean()`), so it is cheap and safe
+  to call synchronously.
+- A file that fails to load becomes a `status: "error"` row with a short
+  message — **one bad file never aborts the batch**.
+- 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:
+
+- `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.
+- `session["active_file_id"]`: the currently selected file's id.
+- 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 also restores the Globus execution context
+  (endpoint id + remote path) the frontend's `globus_mode` needs.
+
+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:** `GET /files/summary`. **Local** files are summarized
+   directly via `aidrin.summarize_files`. **Globus** files are listed with
+   metadata only (name, type, size, source; stats shown as `n/a`) in phase 1 —
+   computing remote stats would require a per-file Globus Compute call, deferred
+   to a later phase.
+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 from disk + list). |
+| `GET /files/summary` | Combined per-file overview + totals (Globus = metadata only). |
+| 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.
+
+## Frontend (inspector)
+
+- **Upload dropzone:** add `multiple`; support multi-file drag-drop. **Remove**
+  the "File type" `<select>` (type is inferred).
+- **File switcher:** a list (in the sidebar) of uploaded files, each showing
+  name + type/status badge, the active one highlighted; click to activate;
+  per-file remove button.
+- **Combined summary panel:** a new view rendering the per-file overview table
+  (name, type, #records, #features, completeness, size, status) and the totals;
+  clicking a row activates that file. Errors render inline per row. Globus rows
+  show metadata only with stats as `n/a` (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. Update `generate_metric_cache_key` and the `store_result`
+  user-key accordingly.
+
+## Limits
+
+- `MAX_CONTENT_LENGTH` already caps the **whole** multipart request (the
+  parquet/upload-limit work sets this; default 1 GB) — this naturally bounds the
+  combined batch size. No per-file cap needed.
+- New `AIDRIN_MAX_UPLOAD_FILES` (default **50**) bounds the number of files per
+  batch; exceeding it returns a clear error and rejects the upload.
+
+## 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.
+- **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` — per-file stats, totals, mixed types, a failing
+  file among good ones, empty input. `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; per-file error
+  appears in the summary without 500s; `AIDRIN_MAX_UPLOAD_FILES` enforced.
+- **Globus:** multi-file transfer appends to the shared list (mocked transfer).
+- 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.

From 279d9c52056751ce156edb0abb1209ac51381a7f Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 11:50:48 -0700
Subject: [PATCH 02/49] spec: incorporate sub-agent review findings

Fix completeness to match the existing row-wise metric; correct the
MAX_CONTENT_LENGTH/load_dataframe branch attribution; enumerate the Globus
shim contract (repopulate globus_file_*); add a source==globus bypass for the
local os.path.exists stale-session check; store the file list server-side
(cookie-size risk); specify active-file removal, read_file tri-state handling,
full cache-key migration, type-key-as-suffix caveat, 413/max-files ordering,
and the AJAX upload rewrite.
---
 ...-06-04-multi-file-batch-analysis-design.md | 117 ++++++++++++++----
 1 file changed, 91 insertions(+), 26 deletions(-)

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
index b5dbd66b..fe422bce 100644
--- 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
@@ -57,10 +57,16 @@ The single-file assumption is deep in the web layer:
   already supports multiple files by iteration. The CLI/headless mode (on other
   branches) is likewise config/arg driven and session-free.
 
-**Note on dependencies:** the per-file error handling described here mirrors the
-`load_dataframe` helper and friendly-error mapping introduced on the
-`parquet-support` branch. If this feature lands before that work is merged, it
-should include an equivalent helper; otherwise it reuses it.
+**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
 
@@ -78,7 +84,7 @@ def summarize_files(file_infos):
     per_file = {
         "name": str, "type": str,
         "records": int|None, "features": int|None,
-        "completeness": float|None,   # fraction of non-null cells, 0..1
+        "completeness": float|None,   # row-wise, 0..1 (see note below)
         "size_bytes": int|None,
         "status": "ok"|"error",
         "error": str|None,            # short message when status == "error"
@@ -92,11 +98,21 @@ def summarize_files(file_infos):
     """
 ```
 
-- Reads each file via `read_file`; computes lightweight stats **without Celery**
-  (e.g. completeness = `df.notna().to_numpy().mean()`), so it is cheap and safe
-  to call synchronously.
+- 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.)
+- Computes lightweight stats **without Celery** so it is cheap to call
+  synchronously. **Completeness must use the same row-wise definition as the
+  existing metric** (`completeness.py`): `1 - df.isnull().any(axis=1).mean()`
+  (fraction of rows with no missing value), **not** a cell-wise mean — otherwise
+  the summary column would disagree with the per-file Data Quality result.
 - 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.
@@ -105,16 +121,24 @@ def summarize_files(file_infos):
 
 A presentation-only construct in the Flask session:
 
-- `session["uploaded_files"]`: list of
+- `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.
-- `session["active_file_id"]`: the currently selected file's id.
+  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 also restores the Globus execution context
-  (endpoint id + remote path) the frontend's `globus_mode` needs.
+  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
@@ -152,7 +176,7 @@ file-management endpoints need to be multi-file aware.
 | `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 from disk + list). |
+| `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 (Globus = metadata only). |
 | 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`). |
@@ -166,11 +190,24 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
   `".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).
+  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:** a list (in the sidebar) of uploaded files, each showing
   name + type/status badge, the active one highlighted; click to activate;
   per-file remove button.
@@ -187,16 +224,29 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
 - 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. Update `generate_metric_cache_key` and the `store_result`
-  user-key accordingly.
+  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` already caps the **whole** multipart request (the
-  parquet/upload-limit work sets this; default 1 GB) — this naturally bounds the
-  combined batch size. No per-file cap needed.
+- `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; exceeding it returns a clear error and rejects the upload.
+  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
 
@@ -204,19 +254,34 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
   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` — per-file stats, totals, mixed types, a failing
-  file among good ones, empty input. `infer_file_type` — each supported
-  extension, Excel variants, unknown extension.
+  file among good ones, empty input, and `read_file` returning each of
+  `DataFrame`/`None`/`str`. Assert `completeness` equals the existing row-wise
+  metric on the same data. `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; per-file error
-  appears in the summary without 500s; `AIDRIN_MAX_UPLOAD_FILES` enforced.
-- **Globus:** multi-file transfer appends to the shared list (mocked transfer).
+  `/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`.
+- **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)

From 30fa1cb34a6a192143df6e8d984ca4d1d6b6a126 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 11:56:05 -0700
Subject: [PATCH 03/49] spec: finalize combined-summary design (phase 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Combined summary is the default landing view after a multi-file upload:
totals strip + per-file table (File/Type/Source/Records/Features/Size/Status),
table+totals only, no charts. No metrics in phase 1 — summarize_files does a
single light read for records/features/status (local), Globus rows metadata-only.
Drops completeness from the summary (and the row-wise/cell-wise concern with it).
---
 ...-06-04-multi-file-batch-analysis-design.md | 51 +++++++++++--------
 1 file changed, 30 insertions(+), 21 deletions(-)

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
index fe422bce..c1c03971 100644
--- 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
@@ -83,8 +83,7 @@ def summarize_files(file_infos):
 
     per_file = {
         "name": str, "type": str,
-        "records": int|None, "features": int|None,
-        "completeness": float|None,   # row-wise, 0..1 (see note below)
+        "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"
@@ -103,11 +102,12 @@ def summarize_files(file_infos):
   `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.)
-- Computes lightweight stats **without Celery** so it is cheap to call
-  synchronously. **Completeness must use the same row-wise definition as the
-  existing metric** (`completeness.py`): `1 - df.isnull().any(axis=1).mean()`
-  (fraction of rows with no missing value), **not** a cell-wise mean — otherwise
-  the summary column would disagree with the per-file Data Quality result.
+- **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
@@ -161,11 +161,14 @@ file-management endpoints need to be multi-file aware.
 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:** `GET /files/summary`. **Local** files are summarized
-   directly via `aidrin.summarize_files`. **Globus** files are listed with
-   metadata only (name, type, size, source; stats shown as `n/a`) in phase 1 —
-   computing remote stats would require a per-file Globus Compute call, deferred
-   to a later phase.
+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 are listed with metadata
+   only (name, type, size, source; records/features `n/a`) — no remote read in
+   phase 1. Clicking any row activates that file and drills into its existing
+   per-file panels.
 5. **Metrics:** unchanged — they read the active file through the legacy keys
    (local) or the restored Globus context (remote).
 
@@ -211,10 +214,16 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
 - **File switcher:** a list (in the sidebar) of uploaded files, each showing
   name + type/status badge, the active one highlighted; click to activate;
   per-file remove button.
-- **Combined summary panel:** a new view rendering the per-file overview table
-  (name, type, #records, #features, completeness, size, status) and the totals;
-  clicking a row activates that file. Errors render inline per row. Globus rows
-  show metadata only with stats as `n/a` (phase 1).
+- **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). Failed rows show the friendly
+    error inline (`—` for stats); Globus rows show a "remote" badge with
+    records/features `n/a`. Clicking a row activates that file → its per-file
+    panels.
+  - **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).
@@ -265,11 +274,11 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
 
 ## Testing
 
-- **Core:** `summarize_files` — per-file stats, totals, mixed types, a failing
-  file among good ones, empty input, and `read_file` returning each of
-  `DataFrame`/`None`/`str`. Assert `completeness` equals the existing row-wise
-  metric on the same data. `infer_file_type` — each supported extension, Excel
-  variants, unknown extension.
+- **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

From 705156b261ea7ff026304e32cd8a18205fdb2f76 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 12:00:19 -0700
Subject: [PATCH 04/49] spec: sort batch overview by name; fetch Globus counts
 async

Table sorted by file name (case-insensitive). Globus rows now fetch
records/features asynchronously via the existing remote _summary_statistics
(reusing the globus_summary cache) instead of showing n/a; total records
updates as remote counts stream in.
---
 ...-06-04-multi-file-batch-analysis-design.md | 29 ++++++++++++-------
 1 file changed, 19 insertions(+), 10 deletions(-)

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
index c1c03971..533e4736 100644
--- 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
@@ -165,10 +165,13 @@ file-management endpoints need to be multi-file aware.
    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 are listed with metadata
-   only (name, type, size, source; records/features `n/a`) — no remote read in
-   phase 1. Clicking any row activates that file and drills into its existing
-   per-file panels.
+   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).
 
@@ -180,7 +183,7 @@ file-management endpoints need to be multi-file aware.
 | `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 (Globus = metadata only). |
+| `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`). |
 
@@ -219,10 +222,14 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
   - **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). Failed rows show the friendly
-    error inline (`—` for stats); Globus rows show a "remote" badge with
-    records/features `n/a`. Clicking a row activates that file → its per-file
-    panels.
+    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
@@ -288,7 +295,9 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
   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`.
+  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.

From 5d5dfa99cf9c82a62364b4728d1cad3a1ad532c6 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 13:42:55 -0700
Subject: [PATCH 05/49] plan: multi-file batch analysis implementation

13 TDD tasks across 6 milestones: core batch layer (summarize_files,
infer_file_type), server-side file list + active-file shim, cache re-key,
file-management endpoints, multi-file upload, limits, Globus unification, and
the frontend switcher + batch-overview landing view.
---
 .../2026-06-04-multi-file-batch-analysis.md   | 1327 +++++++++++++++++
 1 file changed, 1327 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-06-04-multi-file-batch-analysis.md

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.

From 76abdfe2438250cb94c34583e22cfc1fc7726fa7 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:22:47 -0700
Subject: [PATCH 06/49] feat(core): infer reader type from file extension

---
 aidrin/file_handling/file_parser.py | 31 +++++++++++++++++++++++++
 tests/unit/test_infer_file_type.py  | 35 +++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+)
 create mode 100644 tests/unit/test_infer_file_type.py

diff --git a/aidrin/file_handling/file_parser.py b/aidrin/file_handling/file_parser.py
index 88009ddf..a93fe5c7 100644
--- a/aidrin/file_handling/file_parser.py
+++ b/aidrin/file_handling/file_parser.py
@@ -35,6 +35,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/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"

From 2fa33954f3b3de7c2b9772c94bf1df33c3a864e7 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:27:36 -0700
Subject: [PATCH 07/49] feat(core): summarize_files batch structural overview

---
 aidrin/__init__.py                 | 12 ++++
 aidrin/batch.py                    | 65 +++++++++++++++++++++
 tests/unit/test_public_api.py      |  3 +
 tests/unit/test_summarize_files.py | 94 ++++++++++++++++++++++++++++++
 4 files changed, 174 insertions(+)
 create mode 100644 aidrin/batch.py
 create mode 100644 tests/unit/test_summarize_files.py

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/batch.py b/aidrin/batch.py
new file mode 100644
index 00000000..a408c55d
--- /dev/null
+++ b/aidrin/batch.py
@@ -0,0 +1,65 @@
+"""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,
+            "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):
+        return {
+            "name": name, "type": file_type,
+            "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": file_type,
+        "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),
+        "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/tests/unit/test_public_api.py b/tests/unit/test_public_api.py
index f23c9b0b..744673bb 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..a70703f5
--- /dev/null
+++ b/tests/unit/test_summarize_files.py
@@ -0,0 +1,94 @@
+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
+    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_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

From 03277b54c62e70fc6ddd6ee45c267051cd53411f Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:36:45 -0700
Subject: [PATCH 08/49] feat(web): server-side file list + active-file shim

---
 tests/integration/test_files_routes.py | 59 +++++++++++++++++++++++++
 web/routes/utils.py                    | 61 ++++++++++++++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 tests/integration/test_files_routes.py

diff --git a/tests/integration/test_files_routes.py b/tests/integration/test_files_routes.py
new file mode 100644
index 00000000..016d3cff
--- /dev/null
+++ b/tests/integration/test_files_routes.py
@@ -0,0 +1,59 @@
+"""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
diff --git a/web/routes/utils.py b/web/routes/utils.py
index d355f401..fdbcf009 100644
--- a/web/routes/utils.py
+++ b/web/routes/utils.py
@@ -25,6 +25,67 @@ def get_current_user_id():
     return session["user_id"]
 
 
+# ---------------------------------------------------------------------------
+# Multi-file store + active-file shim
+# ---------------------------------------------------------------------------
+
+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)
+
+
 def generate_metric_cache_key(file_name, metric_type, **params):
     """Generate a user-specific cache key for metrics."""
     user_id = get_current_user_id()

From b3baf3720cf15fed86d47e871d358d43c9dc3a16 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:40:06 -0700
Subject: [PATCH 09/49] fix(web): key metric cache by active file id

---
 tests/integration/test_files_routes.py | 16 ++++++++++++++++
 web/routes/core.py                     |  5 +++--
 web/routes/utils.py                    |  9 ++++++---
 3 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/tests/integration/test_files_routes.py b/tests/integration/test_files_routes.py
index 016d3cff..b9a9254c 100644
--- a/tests/integration/test_files_routes.py
+++ b/tests/integration/test_files_routes.py
@@ -57,3 +57,19 @@ def test_set_active_unknown_id_returns_false(app):
     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
diff --git a/web/routes/core.py b/web/routes/core.py
index ef28c227..9acc2955 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -288,10 +288,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/utils.py b/web/routes/utils.py
index fdbcf009..a0ea5730 100644
--- a/web/routes/utils.py
+++ b/web/routes/utils.py
@@ -89,7 +89,8 @@ def clear_uploaded_files():
 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", [])
@@ -177,8 +178,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(),

From 2338ae1905206fe0b751007749747150a0b923ee Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:50:36 -0700
Subject: [PATCH 10/49] feat(web): files blueprint (list/activate/remove)

---
 tests/integration/test_files_routes.py | 44 ++++++++++++++++++++++++
 web/routes/__init__.py                 |  2 ++
 web/routes/files.py                    | 47 ++++++++++++++++++++++++++
 3 files changed, 93 insertions(+)
 create mode 100644 web/routes/files.py

diff --git a/tests/integration/test_files_routes.py b/tests/integration/test_files_routes.py
index b9a9254c..a7f48caf 100644
--- a/tests/integration/test_files_routes.py
+++ b/tests/integration/test_files_routes.py
@@ -73,3 +73,47 @@ def test_cache_key_uses_active_file_id_not_display_name(app):
         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()
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/files.py b/web/routes/files.py
new file mode 100644
index 00000000..0759fe31
--- /dev/null
+++ b/web/routes/files.py
@@ -0,0 +1,47 @@
+"""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/<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})

From 7203c4f9e7af0c7cb7b115ab8cdd577c73d3ce2d Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:53:15 -0700
Subject: [PATCH 11/49] feat(web): /files/summary batch overview endpoint

---
 tests/integration/test_files_routes.py | 31 ++++++++++++++++++++++++++
 web/routes/files.py                    | 25 +++++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/tests/integration/test_files_routes.py b/tests/integration/test_files_routes.py
index a7f48caf..c72718b1 100644
--- a/tests/integration/test_files_routes.py
+++ b/tests/integration/test_files_routes.py
@@ -117,3 +117,34 @@ def test_files_remove_active_activates_next(app, client, tmp_path):
     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/web/routes/files.py b/web/routes/files.py
index 0759fe31..5d0e4b53 100644
--- a/web/routes/files.py
+++ b/web/routes/files.py
@@ -25,6 +25,31 @@ def activate(file_id):
     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, "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()

From bc9ffdbe4b684ed6fad45eeefe2b6115bb6f1dae Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:55:58 -0700
Subject: [PATCH 12/49] feat(web): accept multiple files on upload, infer types

---
 tests/integration/test_multi_upload.py | 32 ++++++++++++++++++++++
 web/routes/core.py                     | 38 +++++++++++++++++---------
 2 files changed, 57 insertions(+), 13 deletions(-)
 create mode 100644 tests/integration/test_multi_upload.py

diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
new file mode 100644
index 00000000..34f7ba36
--- /dev/null
+++ b/tests/integration/test_multi_upload.py
@@ -0,0 +1,32 @@
+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
diff --git a/web/routes/core.py b/web/routes/core.py
index 9acc2955..f200274f 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -37,24 +37,36 @@ 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:
             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 = []
+            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)
+            first = sorted(new_entries, key=lambda e: e["name"].lower())[0]
+            set_active_file(first["id"])
             return redirect(url_for("core.inspector"))
 
     uploaded_file_name = session.get("uploaded_file_name", "")

From 2973c4563266dd6669f9d322ac4e57108fde6b78 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 16:59:23 -0700
Subject: [PATCH 13/49] fix(web): don't wipe active Globus file on local
 existence check

---
 tests/integration/test_multi_upload.py | 26 ++++++++++++++++++++++++++
 web/routes/core.py                     | 12 +++++++++---
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
index 34f7ba36..fdefa838 100644
--- a/tests/integration/test_multi_upload.py
+++ b/tests/integration/test_multi_upload.py
@@ -30,3 +30,29 @@ def test_single_file_upload_still_works(client):
     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"
diff --git a/web/routes/core.py b/web/routes/core.py
index f200274f..9b619765 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -73,8 +73,14 @@ def inspector():
     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(
@@ -92,7 +98,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)

From b62621ea94bbff957fee1b21fc400297d84aad1e Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:02:59 -0700
Subject: [PATCH 14/49] feat(web): upload size cap + AIDRIN_MAX_UPLOAD_FILES=50
 + 413

---
 tests/integration/test_multi_upload.py | 15 +++++++++++++++
 web/__init__.py                        | 23 +++++++++++++++++++++++
 web/routes/core.py                     |  6 ++++++
 3 files changed, 44 insertions(+)

diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
index fdefa838..2b30115e 100644
--- a/tests/integration/test_multi_upload.py
+++ b/tests/integration/test_multi_upload.py
@@ -56,3 +56,18 @@ def test_globus_active_file_not_wiped_by_local_existence_check(app, client):
     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
diff --git a/web/__init__.py b/web/__init__.py
index b559fe05..583129f5 100644
--- a/web/__init__.py
+++ b/web/__init__.py
@@ -62,6 +62,29 @@ def inject_version():
     }
     app.config.from_prefixed_env()
 
+    # Maximum upload size (default 1 GB; override via AIDRIN_MAX_UPLOAD_MB).
+    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
+
+    # 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.errorhandler(413)
+    def _request_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
+
     # Initialize in-memory cache
     app.TEMP_RESULTS_CACHE = {}
 
diff --git a/web/routes/core.py b/web/routes/core.py
index 9b619765..37199162 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -44,6 +44,12 @@ def inspector():
         file_upload_time_log.info("File upload initiated (workspace)")
         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
             cleared_count = clear_all_user_cache()
             file_upload_time_log.info(
                 "Cache cleared for new file upload: %d entries removed", cleared_count

From e55979ea3da0424ac3b9554a781925762d9af696 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:07:59 -0700
Subject: [PATCH 15/49] feat(web): Globus selections feed the shared file list

---
 tests/integration/test_globus_multifile.py | 158 +++++++++++++++++++++
 web/routes/globus.py                       |  33 ++++-
 2 files changed, 186 insertions(+), 5 deletions(-)
 create mode 100644 tests/integration/test_globus_multifile.py

diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
new file mode 100644
index 00000000..fdd71180
--- /dev/null
+++ b/tests/integration/test_globus_multifile.py
@@ -0,0 +1,158 @@
+"""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.
+"""
+
+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"
diff --git a/web/routes/globus.py b/web/routes/globus.py
index c1560575..8a2973b0 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -5,6 +5,7 @@
 """
 
 import logging
+import uuid
 
 from flask import (
     Blueprint,
@@ -23,6 +24,7 @@
     submit_metric,
     check_task,
 )
+from web.routes.utils import get_uploaded_files, save_uploaded_files, set_active_file
 
 logger = logging.getLogger(__name__)
 
@@ -194,11 +196,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,

From 3c6b53bd5e3eb95a02d41644f2c169fcb0ea5481 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:11:38 -0700
Subject: [PATCH 16/49] feat(ui): multi-file AJAX upload; drop manual type
 dropdown

---
 tests/integration/test_inspector.py         |   2 +-
 web/static/js/main.js                       |  67 ++++---
 web/templates/_components/upload_panel.html | 188 +++++++++++++++-----
 web/templates/inspector.html                |  11 --
 4 files changed, 177 insertions(+), 91 deletions(-)

diff --git a/tests/integration/test_inspector.py b/tests/integration/test_inspector.py
index 99ec0836..6ef0ce97 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 Inspector" 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/web/static/js/main.js b/web/static/js/main.js
index e3f0c9ee..31e02787 100644
--- a/web/static/js/main.js
+++ b/web/static/js/main.js
@@ -24,25 +24,41 @@ 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;
   }
-
-  // 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
@@ -70,29 +86,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/upload_panel.html b/web/templates/_components/upload_panel.html
index 0ff120df..941ee345 100644
--- a/web/templates/_components/upload_panel.html
+++ b/web/templates/_components/upload_panel.html
@@ -1,15 +1,26 @@
 <!-- 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 Inspector
       </h2>
-      <a href="https://aidrin.readthedocs.io/en/latest/" target="_blank"
-         class="text-sm mt-2 text-blue-600 dark:text-blue-400 hover:underline">
+      <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>
@@ -17,70 +28,160 @@ <h2 class="text-2xl font-semibold text-center text-gray-900 dark:text-white">
     {% if globus_available %}
     <!-- Tab switcher: Upload / Globus -->
     <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_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_authenticated else 'border-blue-600 text-blue-600 dark:text-blue-500 dark:border-blue-500' }}"
+      >
         Upload File
       </button>
-      <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>
     </div>
     {% endif %}
 
     <!-- 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') }}">
-
-          <!-- 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') }}"
+        >
           <!-- 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, JSON, XLSX, NPZ, HDF5, DCAT
+              </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>
@@ -97,7 +198,10 @@ <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 %}
diff --git a/web/templates/inspector.html b/web/templates/inspector.html
index 792ba5fb..a87bfc17 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -174,17 +174,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');

From f4e6537fdfbabf266ab11300cd214c684b1d9560 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:15:47 -0700
Subject: [PATCH 17/49] feat(ui): file switcher sidebar

---
 web/static/js/inspector.js                   | 64 ++++++++++++++++++++
 web/templates/_components/file_switcher.html |  5 ++
 web/templates/_components/sidebar.html       |  2 +
 3 files changed, 71 insertions(+)
 create mode 100644 web/templates/_components/file_switcher.html

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 8dd1d788..8c747db0 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -1943,6 +1943,67 @@ function renderWorkspaceHistograms(histograms) {
   container.innerHTML = html;
 }
 
+// ==================== File Switcher ====================
+
+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 = "";
+      if (files.length === 0) {
+        const li = document.createElement("li");
+        li.className = "text-xs text-gray-400 px-2 py-1";
+        li.textContent = "No files uploaded";
+        ul.appendChild(li);
+        return;
+      }
+      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");
+        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);
+      });
+    })
+    .catch((err) => {
+      console.error("Failed to load file switcher:", err);
+    });
+}
+
+function activateFile(fileId) {
+  fetch(`/files/${fileId}/activate`, { method: "POST" })
+    .then((r) => r.json())
+    .then((b) => {
+      if (b.success) {
+        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 ====================
 
 /**
@@ -1950,6 +2011,9 @@ function renderWorkspaceHistograms(histograms) {
  * Fetches summary statistics and populates feature dropdowns.
  */
 function initWorkspace() {
+  // Populate file switcher in sidebar
+  loadFileSwitcher();
+
   // Restore panel from URL hash, or default to data-overview
   const hash = location.hash.replace("#", "");
   const initialPanel =
diff --git a/web/templates/_components/file_switcher.html b/web/templates/_components/file_switcher.html
new file mode 100644
index 00000000..a4fdba64
--- /dev/null
+++ b/web/templates/_components/file_switcher.html
@@ -0,0 +1,5 @@
+<!-- File switcher: lists uploaded files; click to activate -->
+<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>
diff --git a/web/templates/_components/sidebar.html b/web/templates/_components/sidebar.html
index f7c6dd3f..7cab8b65 100644
--- a/web/templates/_components/sidebar.html
+++ b/web/templates/_components/sidebar.html
@@ -10,6 +10,8 @@
       <img src="/images/logoNoBackground.png" class="w-1/2" alt="AIDRIN Logo" />
     </a>
 
+    {% include '_components/file_switcher.html' %}
+
     <!-- 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"

From 0ea868ae307463f6ff73a13665bb7105379d71fd Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:22:00 -0700
Subject: [PATCH 18/49] feat(ui): batch overview landing view with async Globus
 counts

---
 web/routes/core.py                         |   4 +
 web/static/js/inspector.js                 | 109 +++++++++++++++++++++
 web/templates/_panels/_batch_overview.html |  36 +++++++
 web/templates/inspector.html               |   9 +-
 4 files changed, 157 insertions(+), 1 deletion(-)
 create mode 100644 web/templates/_panels/_batch_overview.html

diff --git a/web/routes/core.py b/web/routes/core.py
index 37199162..dedd51e5 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -150,6 +150,9 @@ 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())
+
     try:
         return render_template(
             "inspector.html",
@@ -167,6 +170,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)
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 8c747db0..8cda242e 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -1943,6 +1943,115 @@ 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-3 bg-gray-50 dark:bg-gray-700/50 rounded text-center";
+          const v = document.createElement("div");
+          v.className = "text-2xl font-bold";
+          v.textContent = value;
+          const k = document.createElement("div");
+          k.className = "text-xs uppercase text-gray-500";
+          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";
+        const isGlobus = f.source === "globus";
+        const cells = [
+          f.name,
+          f.type || "?",
+          f.source,
+          isGlobus ? "…" : (f.records ?? "—"),
+          isGlobus ? "…" : (f.features ?? "—"),
+          fmtBytes(f.size_bytes),
+          f.status === "ok"
+            ? "✅"
+            : f.status === "remote"
+              ? "🌐 remote"
+              : `⚠️ ${f.error || "error"}`,
+        ];
+        cells.forEach((text, idx) => {
+          const td = document.createElement("td");
+          td.className =
+            "px-3 py-2" + (idx >= 3 && idx <= 5 ? " text-right" : "");
+          td.textContent = text;
+          if (isGlobus && (idx === 3 || idx === 4)) {
+            td.dataset.globusId = f.id;
+            td.dataset.field = idx === 3 ? "records" : "features";
+          }
+          tr.appendChild(td);
+        });
+        tr.addEventListener("click", () => activateFile(f.id));
+        tbody.appendChild(tr);
+        if (isGlobus) fetchGlobusCount(f);
+      });
+    })
+    .catch((err) => console.error("Failed to load batch overview:", err));
+}
+
+/**
+ * Fetch records/features counts for a Globus remote file entry.
+ *
+ * NOTE (DONE_WITH_CONCERNS): A clean reuse of fetchGlobusSummary() is not
+ * feasible here without a significant refactor. fetchGlobusSummary() reads
+ * endpoint/path/name/type from the single-file globals
+ * (window.AIDRIN_GLOBUS_ENDPOINT etc.) and is tightly coupled to the
+ * single-file DOM elements (globus-summary-loading, globus-summary-content).
+ * In a batch context each Globus row has its own endpoint/path metadata stored
+ * server-side but not exposed to the frontend as per-file globals. Properly
+ * reusing the Globus Compute submit/poll flow would require:
+ *   1. Exposing per-file endpoint_id + file_path from /files/summary,
+ *   2. Factoring out a generic submitGlobusTask(endpoint, path, ...) helper,
+ *   3. Wiring per-row polling that updates the specific td cells.
+ * Until that refactor lands, Globus rows show "n/a" to keep the UI consistent.
+ */
+function fetchGlobusCount(f) {
+  const cells = document.querySelectorAll(`[data-globus-id="${f.id}"]`);
+  cells.forEach((td) => {
+    td.textContent = "n/a";
+  });
+}
+
 // ==================== File Switcher ====================
 
 function loadFileSwitcher() {
diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
new file mode 100644
index 00000000..40184d8c
--- /dev/null
+++ b/web/templates/_panels/_batch_overview.html
@@ -0,0 +1,36 @@
+<!-- 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">Size</th>
+            <th scope="col" class="px-3 py-2.5">Status</th>
+          </tr>
+        </thead>
+        <tbody id="batch-rows"></tbody>
+      </table>
+    </div>
+  </div>
+</div>
diff --git a/web/templates/inspector.html b/web/templates/inspector.html
index a87bfc17..fd24720c 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,13 @@
       {% endif %}
 
       {% if uploaded_file_path and not globus_mode %}
-        initWorkspace();
+        {% if file_count > 1 %}
+          showPanel('batch-overview');
+          loadBatchOverview();
+          loadFileSwitcher();
+        {% else %}
+          initWorkspace();
+        {% endif %}
       {% elif globus_mode %}
         // Globus mode — flag for workspaceSubmit to route through Globus
         window.AIDRIN_GLOBUS_MODE = true;

From f00b47e1638c56ac164dd22852343132caa2b679 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:34:45 -0700
Subject: [PATCH 19/49] fix(ui): load active-file metrics + switcher in batch
 and globus modes

---
 web/templates/inspector.html | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/web/templates/inspector.html b/web/templates/inspector.html
index fd24720c..096de8d3 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -86,12 +86,17 @@
       {% endif %}
 
       {% if uploaded_file_path and not globus_mode %}
+        // Always initialise the workspace so the active file's summary and
+        // feature dropdowns are populated (initWorkspace also calls
+        // loadFileSwitcher internally).
+        initWorkspace();
         {% if file_count > 1 %}
-          showPanel('batch-overview');
+          // Batch mode: also load the overview list and surface it as the
+          // landing panel.  showPanel is synchronous inside initWorkspace
+          // (called before any fetch), so this call wins and leaves the
+          // batch-overview visible.
           loadBatchOverview();
-          loadFileSwitcher();
-        {% else %}
-          initWorkspace();
+          showPanel('batch-overview');
         {% endif %}
       {% elif globus_mode %}
         // Globus mode — flag for workspaceSubmit to route through Globus
@@ -100,6 +105,7 @@
         window.AIDRIN_GLOBUS_FILE_PATH = '{{ uploaded_file_path }}';
         window.AIDRIN_GLOBUS_FILE_NAME = '{{ uploaded_file_name }}';
         window.AIDRIN_GLOBUS_FILE_TYPE = '{{ file_type }}';
+        loadFileSwitcher();
         showPanel('data-overview');
         // Show Globus info banner + loading spinner for summary stats
         var ws = document.getElementById('workspace-summary');

From 9dc7fc59c963183f525411b927b0a4bf1651ac17 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 17:46:46 -0700
Subject: [PATCH 20/49] fix(web): reject unsupported file types at upload with
 a clear message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously a file whose type couldn't be inferred (e.g. an extension with no
registered reader) was saved with an empty type, then silently wiped by the
inspector stale-session check (not file_type) — the user saw nothing happen.
Now the upload route rejects unsupported files up front with a 400 + message
listing the supported formats, so no empty-type file ever enters the list.
---
 tests/integration/test_multi_upload.py | 32 ++++++++++++++++++++++++++
 web/routes/core.py                     | 13 +++++++++++
 2 files changed, 45 insertions(+)

diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
index 2b30115e..8a663447 100644
--- a/tests/integration/test_multi_upload.py
+++ b/tests/integration/test_multi_upload.py
@@ -71,3 +71,35 @@ 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"] == []
diff --git a/web/routes/core.py b/web/routes/core.py
index dedd51e5..c08414ed 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -50,6 +50,19 @@ def inspector():
                     "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

From 17fdd5b528663596a3b04ee2620fb82f25551352 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 18:28:41 -0700
Subject: [PATCH 21/49] spec: top-bar searchable file selector replaces sidebar
 switcher

Scales to many files (searchable+scrollable, virtualize later); keeps the
sidebar focused on metric nav; reuses GET /files + activate.
---
 ...026-06-04-multi-file-batch-analysis-design.md | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

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
index 533e4736..1ab921c8 100644
--- 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
@@ -214,9 +214,19 @@ New `infer_file_type(filename)` in `aidrin/file_handling/file_parser.py`:
   `<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:** a list (in the sidebar) of uploaded files, each showing
-  name + type/status badge, the active one highlighted; click to activate;
-  per-file remove button.
+- **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`,

From 50655f4499560c07726f4eafe8e2249bf14688f8 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 18:37:15 -0700
Subject: [PATCH 22/49] feat(ui): top-bar searchable file selector; remove
 sidebar switcher

---
 web/static/js/inspector.js                   | 123 +++++++++++++------
 web/templates/_components/file_switcher.html |   5 -
 web/templates/_components/sidebar.html       |   2 -
 web/templates/_components/topbar.html        |  31 +++--
 web/templates/inspector.html                 |   4 +-
 5 files changed, 111 insertions(+), 54 deletions(-)
 delete mode 100644 web/templates/_components/file_switcher.html

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 8cda242e..39821fe3 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -2052,48 +2052,95 @@ function fetchGlobusCount(f) {
   });
 }
 
-// ==================== File Switcher ====================
+// ==================== Top-Bar File Selector ====================
 
-function loadFileSwitcher() {
+let _fileSelectorFiles = [];
+let _fileSelectorActiveId = null;
+
+function loadFileSelector() {
   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 = "";
-      if (files.length === 0) {
-        const li = document.createElement("li");
-        li.className = "text-xs text-gray-400 px-2 py-1";
-        li.textContent = "No files uploaded";
-        ul.appendChild(li);
-        return;
+      _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");
+        }
       }
-      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");
-        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);
-      });
+      renderFileSelectorList();
     })
-    .catch((err) => {
-      console.error("Failed to load file switcher:", err);
-    });
+    .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) {
@@ -2120,8 +2167,8 @@ function activateFile(fileId) {
  * Fetches summary statistics and populates feature dropdowns.
  */
 function initWorkspace() {
-  // Populate file switcher in sidebar
-  loadFileSwitcher();
+  // Populate top-bar file selector
+  loadFileSelector();
 
   // Restore panel from URL hash, or default to data-overview
   const hash = location.hash.replace("#", "");
diff --git a/web/templates/_components/file_switcher.html b/web/templates/_components/file_switcher.html
deleted file mode 100644
index a4fdba64..00000000
--- a/web/templates/_components/file_switcher.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<!-- File switcher: lists uploaded files; click to activate -->
-<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>
diff --git a/web/templates/_components/sidebar.html b/web/templates/_components/sidebar.html
index 7cab8b65..f7c6dd3f 100644
--- a/web/templates/_components/sidebar.html
+++ b/web/templates/_components/sidebar.html
@@ -10,8 +10,6 @@
       <img src="/images/logoNoBackground.png" class="w-1/2" alt="AIDRIN Logo" />
     </a>
 
-    {% include '_components/file_switcher.html' %}
-
     <!-- 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"
diff --git a/web/templates/_components/topbar.html b/web/templates/_components/topbar.html
index a4febe28..23686846 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/inspector.html b/web/templates/inspector.html
index 096de8d3..a80d7b45 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -88,7 +88,7 @@
       {% if uploaded_file_path and not globus_mode %}
         // Always initialise the workspace so the active file's summary and
         // feature dropdowns are populated (initWorkspace also calls
-        // loadFileSwitcher internally).
+        // loadFileSelector internally).
         initWorkspace();
         {% if file_count > 1 %}
           // Batch mode: also load the overview list and surface it as the
@@ -105,7 +105,7 @@
         window.AIDRIN_GLOBUS_FILE_PATH = '{{ uploaded_file_path }}';
         window.AIDRIN_GLOBUS_FILE_NAME = '{{ uploaded_file_name }}';
         window.AIDRIN_GLOBUS_FILE_TYPE = '{{ file_type }}';
-        loadFileSwitcher();
+        loadFileSelector();
         showPanel('data-overview');
         // Show Globus info banner + loading spinner for summary stats
         var ws = document.getElementById('workspace-summary');

From af50190a58370881c9cc161e6156f7d53955bad2 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 18:51:59 -0700
Subject: [PATCH 23/49] feat(ui): Batch Overview menu entry, uppercase title,
 overview-style totals cards

- Add a 'Batch Overview' item to the sidebar nav (shown when >1 file) so the
  page is reachable after navigating into a metric panel.
- Uppercase the Batch Overview page title.
- Restyle the totals cards to match the Data Overview stat-card style
  (p-4, border, rounded-lg, text-3xl) for visual consistency.
---
 web/static/js/inspector.js                 |  7 ++++---
 web/templates/_components/sidebar.html     | 10 ++++++++++
 web/templates/_panels/_batch_overview.html |  4 +++-
 3 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 39821fe3..00b4191d 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -1973,12 +1973,13 @@ function loadBatchOverview() {
         ].forEach(([label, value]) => {
           const card = document.createElement("div");
           card.className =
-            "p-3 bg-gray-50 dark:bg-gray-700/50 rounded text-center";
+            "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-2xl font-bold";
+          v.className = "text-3xl font-bold text-gray-900 dark:text-white";
           v.textContent = value;
           const k = document.createElement("div");
-          k.className = "text-xs uppercase text-gray-500";
+          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);
diff --git a/web/templates/_components/sidebar.html b/web/templates/_components/sidebar.html
index f7c6dd3f..8b02def5 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"
diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
index 40184d8c..fa9a74d1 100644
--- a/web/templates/_panels/_batch_overview.html
+++ b/web/templates/_panels/_batch_overview.html
@@ -3,7 +3,9 @@
   <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">
+    <h2
+      class="text-lg font-semibold uppercase tracking-wide text-gray-900 dark:text-white mb-4"
+    >
       Batch Overview
     </h2>
 

From 0b4e11a2690ee29d22cde96850e8e402cb34cf4d Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 18:54:10 -0700
Subject: [PATCH 24/49] feat(ui): drop Status column from batch overview table

---
 web/static/js/inspector.js                 | 5 -----
 web/templates/_panels/_batch_overview.html | 1 -
 2 files changed, 6 deletions(-)

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 00b4191d..0d3d8196 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -2005,11 +2005,6 @@ function loadBatchOverview() {
           isGlobus ? "…" : (f.records ?? "—"),
           isGlobus ? "…" : (f.features ?? "—"),
           fmtBytes(f.size_bytes),
-          f.status === "ok"
-            ? "✅"
-            : f.status === "remote"
-              ? "🌐 remote"
-              : `⚠️ ${f.error || "error"}`,
         ];
         cells.forEach((text, idx) => {
           const td = document.createElement("td");
diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
index fa9a74d1..0d31b218 100644
--- a/web/templates/_panels/_batch_overview.html
+++ b/web/templates/_panels/_batch_overview.html
@@ -28,7 +28,6 @@
             <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">Size</th>
-            <th scope="col" class="px-3 py-2.5">Status</th>
           </tr>
         </thead>
         <tbody id="batch-rows"></tbody>

From f43e0bb2db685f30063d5f0487f943fb5a92c2cb Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 18:59:16 -0700
Subject: [PATCH 25/49] feat: add numerical/categorical feature counts to batch
 overview

---
 aidrin/batch.py                            |  6 ++++++
 tests/unit/test_summarize_files.py         | 18 ++++++++++++++++++
 web/routes/files.py                        |  3 ++-
 web/static/js/inspector.js                 |  5 +++--
 web/templates/_panels/_batch_overview.html |  2 ++
 5 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/aidrin/batch.py b/aidrin/batch.py
index a408c55d..a4a3105e 100644
--- a/aidrin/batch.py
+++ b/aidrin/batch.py
@@ -13,6 +13,7 @@ def _summarize_one(file_info):
         return {
             "name": name, "type": file_type,
             "records": None, "features": None,
+            "numerical": None, "categorical": None,
             "size_bytes": None, "status": "error",
             "error": "No file path provided.",
         }
@@ -25,10 +26,14 @@ def _summarize_one(file_info):
 
     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,
         }
 
@@ -39,6 +44,7 @@ def _summarize_one(file_info):
     return {
         "name": name, "type": file_type,
         "records": None, "features": None,
+        "numerical": None, "categorical": None,
         "size_bytes": size, "status": "error", "error": message,
     }
 
diff --git a/tests/unit/test_summarize_files.py b/tests/unit/test_summarize_files.py
index a70703f5..c4693330 100644
--- a/tests/unit/test_summarize_files.py
+++ b/tests/unit/test_summarize_files.py
@@ -23,12 +23,30 @@ def test_ok_file_reports_structure_no_metrics():
     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]
diff --git a/web/routes/files.py b/web/routes/files.py
index 5d0e4b53..5a7dbbd7 100644
--- a/web/routes/files.py
+++ b/web/routes/files.py
@@ -41,7 +41,8 @@ def summary():
     for f in globus:
         rows.append({
             "id": f["id"], "name": f["name"], "type": f["type"], "source": "globus",
-            "records": None, "features": None, "size_bytes": None,
+            "records": None, "features": None,
+            "numerical": None, "categorical": None, "size_bytes": None,
             "status": "remote", "error": None,
         })
     totals = dict(local_summary["totals"])
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 0d3d8196..3f2313fb 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -2004,12 +2004,13 @@ function loadBatchOverview() {
           f.source,
           isGlobus ? "…" : (f.records ?? "—"),
           isGlobus ? "…" : (f.features ?? "—"),
+          isGlobus ? "n/a" : (f.numerical ?? "—"),
+          isGlobus ? "n/a" : (f.categorical ?? "—"),
           fmtBytes(f.size_bytes),
         ];
         cells.forEach((text, idx) => {
           const td = document.createElement("td");
-          td.className =
-            "px-3 py-2" + (idx >= 3 && idx <= 5 ? " text-right" : "");
+          td.className = "px-3 py-2" + (idx >= 3 ? " text-right" : "");
           td.textContent = text;
           if (isGlobus && (idx === 3 || idx === 4)) {
             td.dataset.globusId = f.id;
diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
index 0d31b218..9f5de525 100644
--- a/web/templates/_panels/_batch_overview.html
+++ b/web/templates/_panels/_batch_overview.html
@@ -27,6 +27,8 @@
             <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>

From d72401d9efbb4fb257f5f29ed82feaac2e033db5 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 19:04:23 -0700
Subject: [PATCH 26/49] fix(web): persist the uploaded-file list to disk
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The file list lived in in-memory TEMP_RESULTS_CACHE, which is wiped on any app
restart. Running a custom metric writes a customDR_*.py into the aidrin package,
which triggers the Flask --debug auto-reloader → restart → the list was lost,
so switching files afterward returned 'Unknown file'. Persist the list to a
per-user JSON on disk (keyed by the cookie-stable user_id, stored outside
UPLOAD_FOLDER) so it survives restarts and is shared across worker processes.
---
 web/routes/utils.py | 38 +++++++++++++++++++++++++++++++-------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/web/routes/utils.py b/web/routes/utils.py
index a0ea5730..d1df01ac 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
 
@@ -29,18 +31,37 @@ def get_current_user_id():
 # Multi-file store + active-file shim
 # ---------------------------------------------------------------------------
 
-def _files_cache_key():
-    return f"uploaded_files:{get_current_user_id()}"
+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 server-side list of uploaded files for the current user."""
-    return current_app.TEMP_RESULTS_CACHE.get(_files_cache_key(), [])
+    """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 server-side (kept out of the session cookie)."""
-    current_app.TEMP_RESULTS_CACHE[_files_cache_key()] = 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():
@@ -79,7 +100,10 @@ def set_active_file(file_id):
 
 def clear_uploaded_files():
     """Remove the file list and all active/legacy file pointers."""
-    current_app.TEMP_RESULTS_CACHE.pop(_files_cache_key(), None)
+    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"):

From a57d41ae487f12d77727a2241396d13300c42259 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 19:06:10 -0700
Subject: [PATCH 27/49] chore: gitignore runtime data dir and generated custom
 metrics

---
 .gitignore | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.gitignore b/.gitignore
index d5fb9145..a7940b94 100644
--- a/.gitignore
+++ b/.gitignore
@@ -172,3 +172,10 @@ noisy/
 
 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/

From 01d0d66dc966f6b4be2c59f9fa0a27dc291685ce Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 19:14:09 -0700
Subject: [PATCH 28/49] fix(web): custom-metric editor never loads empty;
 atomic writes

The custom-metric .py is written inside the watched aidrin package with
open(path, 'w'), which truncates to 0 bytes; the --debug reloader can restart
mid-write (or interrupt the load request), leaving an empty file and a blank
editor. Write atomically (temp file + os.replace) and fall back to the starter
template when the file is missing or empty, so the editor always shows content.
---
 web/routes/custom.py | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/web/routes/custom.py b/web/routes/custom.py
index 05ee8e93..a32697e7 100644
--- a/web/routes/custom.py
+++ b/web/routes/custom.py
@@ -4,6 +4,7 @@
 import os
 import runpy
 import sys
+import tempfile
 import time
 import uuid
 
@@ -168,6 +169,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")
@@ -178,12 +199,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"
@@ -202,7 +226,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"})

From 9098db5b1e1e76aed3460d8b2e50566f8f8552e0 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 19:19:28 -0700
Subject: [PATCH 29/49] fix(web): write runtime custom-metric files outside the
 package
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Generated customDR_*.py and remedy_data were written into aidrin/custom_metrics
(inside the package the --debug reloader watches), so every save/run/cleanup
restarted the dev server — the 'reloads after a while' flicker, and the cause
of the earlier lost-file-list and empty-editor bugs. Move CUSTOM_METRICS_FOLDER
to data/custom_metrics (project root). base_dr.py/__init__.py stay in the
package, so generated metrics still import aidrin.custom_metrics.base_dr; the
reloader no longer fires on custom-metric activity.
---
 web/__init__.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/web/__init__.py b/web/__init__.py
index 583129f5..876aec8e 100644
--- a/web/__init__.py
+++ b/web/__init__.py
@@ -121,10 +121,11 @@ def _request_too_large(error):
         except Exception as e:
             startup_log.warning("Failed to delete %s: %s", file_path, e)
 
-    # 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"}

From 09e711cb0fc4a497b919d98fb631df46258038a0 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 19:31:02 -0700
Subject: [PATCH 30/49] fix(ui): refresh CodeMirror when re-showing
 custom-metrics panel

Changing the file while on the custom-metrics panel reloads with hash
#custom-metrics; initWorkspace restores that panel (creating the editor) and
batch-mode then shows the overview, hiding it. The /load-custom-metric fetch's
setValue() then runs on a hidden CodeMirror, which renders blank. Re-showing
the panel skipped init (editor already existed) and never refreshed. Now
showPanel refreshes the existing editor so the code renders.
---
 web/static/js/inspector.js | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 3f2313fb..27ebbc49 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

From f4bf9b783bf8f257ac82d83d0cbbdd431a50a779 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Thu, 4 Jun 2026 23:26:55 -0700
Subject: [PATCH 31/49] style(ui): Batch Overview title in normal case to match
 other panels

---
 web/templates/_panels/_batch_overview.html | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/web/templates/_panels/_batch_overview.html b/web/templates/_panels/_batch_overview.html
index 9f5de525..0a10a104 100644
--- a/web/templates/_panels/_batch_overview.html
+++ b/web/templates/_panels/_batch_overview.html
@@ -3,9 +3,7 @@
   <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 uppercase tracking-wide text-gray-900 dark:text-white mb-4"
-    >
+    <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">
       Batch Overview
     </h2>
 

From b8b5298ffd64728bd55390a34a920199e8b41936 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Fri, 5 Jun 2026 09:11:13 -0700
Subject: [PATCH 32/49] fix(web): metric routes return clean error when the
 active file is unreadable

read_file returns None/an error string when the active file is missing (e.g.
cleaned up); the metric routes called DataFrame methods on it and crashed
(HIPAA: 'str' object has no attribute 'columns'). Guard all read_file sites in
metrics.py: on POST return a 400 with a re-upload message, on GET redirect to
the inspector (which clears the stale session).
---
 web/routes/metrics.py | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

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)
 

From 191983c445c33a219b558989805740ee6550bc06 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Fri, 5 Jun 2026 09:19:36 -0700
Subject: [PATCH 33/49] feat(ui): switching a file lands on Data Overview;
 batch overview only on fresh upload

Activating a file (top-bar selector or a Batch Overview row) now sets the hash
to #data-overview before reloading, so you land on that file's Data Overview.
A fresh multi-file upload redirects to #batch-overview. initWorkspace loads the
batch overview only when it is the restored landing panel.
---
 web/routes/core.py           |  7 ++++++-
 web/static/js/inspector.js   |  4 ++++
 web/templates/inspector.html | 14 +++-----------
 3 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/web/routes/core.py b/web/routes/core.py
index c08414ed..26d4bf99 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -86,7 +86,12 @@ def inspector():
             save_uploaded_files(entries)
             first = sorted(new_entries, key=lambda e: e["name"].lower())[0]
             set_active_file(first["id"])
-            return redirect(url_for("core.inspector"))
+            # Land on the batch overview for a multi-file batch, else the
+            # single file's data overview.
+            target = url_for("core.inspector")
+            if len(entries) > 1:
+                target += "#batch-overview"
+            return redirect(target)
 
     uploaded_file_name = session.get("uploaded_file_name", "")
     uploaded_file_path = session.get("uploaded_file_path", "")
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 27ebbc49..0e9fe300 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -2155,6 +2155,8 @@ function activateFile(fileId) {
     .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");
@@ -2182,6 +2184,8 @@ function initWorkspace() {
   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/templates/inspector.html b/web/templates/inspector.html
index a80d7b45..d0c52e6b 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -86,18 +86,10 @@
       {% endif %}
 
       {% if uploaded_file_path and not globus_mode %}
-        // Always initialise the workspace so the active file's summary and
-        // feature dropdowns are populated (initWorkspace also calls
-        // loadFileSelector internally).
+        // Initialise the workspace; it restores the panel from the URL hash
+        // (#batch-overview right after a multi-file upload, #data-overview when
+        // switching files) and loads the batch overview when it's the landing.
         initWorkspace();
-        {% if file_count > 1 %}
-          // Batch mode: also load the overview list and surface it as the
-          // landing panel.  showPanel is synchronous inside initWorkspace
-          // (called before any fetch), so this call wins and leaves the
-          // batch-overview visible.
-          loadBatchOverview();
-          showPanel('batch-overview');
-        {% endif %}
       {% elif globus_mode %}
         // Globus mode — flag for workspaceSubmit to route through Globus
         window.AIDRIN_GLOBUS_MODE = true;

From f7d1d9b5c4c6bc7ebea54b7a59f6205cf53bfb76 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Fri, 5 Jun 2026 09:27:46 -0700
Subject: [PATCH 34/49] =?UTF-8?q?fix:=20review=20findings=20=E2=80=94=20cl?=
 =?UTF-8?q?ear=5Ffile=20leak,=20test=20isolation,=20dead=20stub,=20dropzon?=
 =?UTF-8?q?e=20text?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- clear_file now removes the disk-backed file list before session.clear()
  (which drops user_id), so it no longer orphans data/filelists/<id>.json.
- conftest 'app' fixture isolates UPLOAD_FOLDER/CUSTOM_METRICS_FOLDER (and the
  derived filelists dir) to tmp_path so tests don't pollute real data/.
- Remove the no-op fetchGlobusCount stub; Globus rows render 'n/a' directly.
- Dropzone no longer advertises DCAT (no DCAT reader; uploads are rejected).
---
 tests/integration/conftest.py               | 14 ++++++++-
 web/routes/core.py                          |  5 +++
 web/static/js/inspector.js                  | 35 +++------------------
 web/templates/_components/upload_panel.html |  2 +-
 4 files changed, 24 insertions(+), 32 deletions(-)

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/web/routes/core.py b/web/routes/core.py
index 26d4bf99..c6f79f48 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -234,6 +234,11 @@ def clear_file():
             except Exception as e:
                 file_upload_time_log.warning("Failed to cancel Globus tasks on clear: %s", e)
 
+    # 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()
+
     session.pop("uploaded_file_path", None)
     session.pop("uploaded_file_name", None)
     session.pop("uploaded_file_type", None)
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 0e9fe300..23978f6a 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -2008,12 +2008,15 @@ function loadBatchOverview() {
         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";
+        // Globus (remote) files show "n/a" for data-derived stats — phase 1
+        // does not pull remote data for the overview. (Per-row remote counts
+        // are a documented follow-up.)
         const cells = [
           f.name,
           f.type || "?",
           f.source,
-          isGlobus ? "…" : (f.records ?? "—"),
-          isGlobus ? "…" : (f.features ?? "—"),
+          isGlobus ? "n/a" : (f.records ?? "—"),
+          isGlobus ? "n/a" : (f.features ?? "—"),
           isGlobus ? "n/a" : (f.numerical ?? "—"),
           isGlobus ? "n/a" : (f.categorical ?? "—"),
           fmtBytes(f.size_bytes),
@@ -2022,43 +2025,15 @@ function loadBatchOverview() {
           const td = document.createElement("td");
           td.className = "px-3 py-2" + (idx >= 3 ? " text-right" : "");
           td.textContent = text;
-          if (isGlobus && (idx === 3 || idx === 4)) {
-            td.dataset.globusId = f.id;
-            td.dataset.field = idx === 3 ? "records" : "features";
-          }
           tr.appendChild(td);
         });
         tr.addEventListener("click", () => activateFile(f.id));
         tbody.appendChild(tr);
-        if (isGlobus) fetchGlobusCount(f);
       });
     })
     .catch((err) => console.error("Failed to load batch overview:", err));
 }
 
-/**
- * Fetch records/features counts for a Globus remote file entry.
- *
- * NOTE (DONE_WITH_CONCERNS): A clean reuse of fetchGlobusSummary() is not
- * feasible here without a significant refactor. fetchGlobusSummary() reads
- * endpoint/path/name/type from the single-file globals
- * (window.AIDRIN_GLOBUS_ENDPOINT etc.) and is tightly coupled to the
- * single-file DOM elements (globus-summary-loading, globus-summary-content).
- * In a batch context each Globus row has its own endpoint/path metadata stored
- * server-side but not exposed to the frontend as per-file globals. Properly
- * reusing the Globus Compute submit/poll flow would require:
- *   1. Exposing per-file endpoint_id + file_path from /files/summary,
- *   2. Factoring out a generic submitGlobusTask(endpoint, path, ...) helper,
- *   3. Wiring per-row polling that updates the specific td cells.
- * Until that refactor lands, Globus rows show "n/a" to keep the UI consistent.
- */
-function fetchGlobusCount(f) {
-  const cells = document.querySelectorAll(`[data-globus-id="${f.id}"]`);
-  cells.forEach((td) => {
-    td.textContent = "n/a";
-  });
-}
-
 // ==================== Top-Bar File Selector ====================
 
 let _fileSelectorFiles = [];
diff --git a/web/templates/_components/upload_panel.html b/web/templates/_components/upload_panel.html
index 941ee345..7901b103 100644
--- a/web/templates/_components/upload_panel.html
+++ b/web/templates/_components/upload_panel.html
@@ -89,7 +89,7 @@
                 id="FileUploadMessage"
                 class="text-xs text-gray-500 dark:text-gray-400"
               >
-                Supported: CSV, JSON, XLSX, NPZ, HDF5, DCAT
+                Supported: CSV, Excel, JSON, NumPy (.npz), HDF5
               </p>
             </div>
             <input

From 796676b24958cd9695036ca505019b4b1a53de80 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Fri, 5 Jun 2026 10:13:44 -0700
Subject: [PATCH 35/49] feat(web): enable custom metrics for all supported file
 types

The execution path already reads via the generic read_file (CSV/JSON/NPZ/HDF5/
Excel -> DataFrame); only the sidebar gated it to CSV. Remove the gate. Fix the
remedy output to always be a real .csv (it's written with to_csv; the old name
used the reader key as an extension, which is invalid for Excel). Guard the
read so a missing file returns a clean error instead of crashing.
---
 web/routes/custom.py                       | 10 +++++++++-
 web/templates/_components/sidebar.html     |  4 ----
 web/templates/_panels/_custom_metrics.html |  2 +-
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/web/routes/custom.py b/web/routes/custom.py
index a32697e7..296889bf 100644
--- a/web/routes/custom.py
+++ b/web/routes/custom.py
@@ -80,6 +80,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")
@@ -135,7 +140,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)
 
diff --git a/web/templates/_components/sidebar.html b/web/templates/_components/sidebar.html
index 8b02def5..821e8b7d 100644
--- a/web/templates/_components/sidebar.html
+++ b/web/templates/_components/sidebar.html
@@ -122,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/_panels/_custom_metrics.html b/web/templates/_panels/_custom_metrics.html
index 2cac21b3..5ba0eb76 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>

From 8af5177be4cdac312c4a76f9f2df46db63245b5f Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 07:01:43 -0700
Subject: [PATCH 36/49] fix: batch-overview landing regression + duplicate
 custom-metric execution

Re-review findings:
- A URL fragment can't carry the 'land on batch overview' intent: the AJAX
  upload follows the redirect via fetch, and Response.url strips the fragment,
  so fresh multi-uploads were landing on Data Overview. Use a one-shot session
  flag (land_on_batch) consumed on the next inspector render. Add integration
  tests for multi- vs single-upload landing.
- custom.py executed the user metric twice (importlib then runpy); drop the
  redundant runpy run (and its now-unused import).
---
 tests/integration/test_multi_upload.py | 26 ++++++++++++++++++++++++++
 web/routes/core.py                     | 15 +++++++++------
 web/routes/custom.py                   | 12 ------------
 web/templates/inspector.html           |  8 ++++++--
 4 files changed, 41 insertions(+), 20 deletions(-)

diff --git a/tests/integration/test_multi_upload.py b/tests/integration/test_multi_upload.py
index 8a663447..f18323d2 100644
--- a/tests/integration/test_multi_upload.py
+++ b/tests/integration/test_multi_upload.py
@@ -103,3 +103,29 @@ def test_batch_with_one_unsupported_file_rejected(client):
     )
     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/web/routes/core.py b/web/routes/core.py
index c6f79f48..db67282a 100644
--- a/web/routes/core.py
+++ b/web/routes/core.py
@@ -86,12 +86,12 @@ def inspector():
             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, else the
-            # single file's data overview.
-            target = url_for("core.inspector")
-            if len(entries) > 1:
-                target += "#batch-overview"
-            return redirect(target)
+            # 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", "")
@@ -170,10 +170,13 @@ def inspector():
 
     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 "",
diff --git a/web/routes/custom.py b/web/routes/custom.py
index 296889bf..e2230d19 100644
--- a/web/routes/custom.py
+++ b/web/routes/custom.py
@@ -2,7 +2,6 @@
 import importlib.util
 import logging
 import os
-import runpy
 import sys
 import tempfile
 import time
@@ -118,17 +117,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":
diff --git a/web/templates/inspector.html b/web/templates/inspector.html
index d0c52e6b..fd379415 100644
--- a/web/templates/inspector.html
+++ b/web/templates/inspector.html
@@ -87,9 +87,13 @@
 
       {% if uploaded_file_path and not globus_mode %}
         // Initialise the workspace; it restores the panel from the URL hash
-        // (#batch-overview right after a multi-file upload, #data-overview when
-        // switching files) and loads the batch overview when it's the landing.
+        // (#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;

From 422c7b5a4f138ce5bd1599ba446e92891ffe8025 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 09:03:01 -0700
Subject: [PATCH 37/49] feat(globus): add a remote file OR a whole directory;
 infer type from extension

The Globus panel previously took a single remote file path + a manual file-type
dropdown. Now it accepts a file OR a folder path: a tiny stdlib listing function
runs on the endpoint (remote_list_data_files), the server infers each file's
type from its extension (decoupled from the endpoint's aidrin version) and adds
the supported files to the batch as source:globus entries (unsupported skipped,
respecting AIDRIN_MAX_UPLOAD_FILES). Drops the file-type dropdown. The remote
metric-execution path (/globus/submit) is unchanged. Mock-tested; needs a real
endpoint for live verification.
---
 tests/integration/test_globus_multifile.py  |  60 +++++++++++
 web/globus.py                               |  49 +++++++++
 web/routes/globus.py                        | 107 ++++++++++++++++++++
 web/static/js/inspector.js                  |  34 +++----
 web/templates/_components/globus_panel.html |  17 +---
 5 files changed, 237 insertions(+), 30 deletions(-)

diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
index fdd71180..221d926e 100644
--- a/tests/integration/test_globus_multifile.py
+++ b/tests/integration/test_globus_multifile.py
@@ -156,3 +156,63 @@ def test_globus_submit_sets_legacy_session_keys(globus_client):
         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
diff --git a/web/globus.py b/web/globus.py
index 31d6d2ed..3550f91a 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -424,6 +424,55 @@ def register_function(client, force=False):
     return func_uuid
 
 
+# ---------------------------------------------------------------------------
+# Remote file listing (for adding a file OR a directory to the batch)
+# ---------------------------------------------------------------------------
+
+
+def remote_list_data_files(path):
+    """Run on the remote endpoint: enumerate data files at ``path``.
+
+    If ``path`` is a file, return just that file. If it's a directory, return
+    the files directly inside it (non-recursive). Returns
+    ``{"files": [abs_path, ...]}`` or ``{"error": str}``. Pure stdlib so it does
+    not depend on the endpoint's installed ``aidrin`` version.
+    """
+    import os
+
+    try:
+        if os.path.isfile(path):
+            return {"files": [path]}
+        if os.path.isdir(path):
+            files = sorted(
+                os.path.join(path, f)
+                for f in os.listdir(path)
+                if os.path.isfile(os.path.join(path, f))
+            )
+            return {"files": files}
+        return {"error": f"Path not found on the remote endpoint: {path}"}
+    except Exception as e:  # noqa: BLE001
+        return {"error": f"Could not list '{path}': {e}"}
+
+
+def register_list_function(client, force=False):
+    """Register remote_list_data_files with Globus Compute; return its UUID."""
+    cache_key = "remote_list_data_files"
+    if not force and cache_key in _function_uuid_cache:
+        return _function_uuid_cache[cache_key]
+
+    func_uuid = client.register_function(remote_list_data_files)
+    _function_uuid_cache[cache_key] = func_uuid
+    logger.info("Registered remote_list_data_files with Globus Compute: %s", func_uuid)
+    return func_uuid
+
+
+def submit_list_files(client, endpoint_id, path):
+    """Submit a remote file-listing task; return the task UUID string."""
+    func_uuid = register_list_function(client)
+    task_id = client.run(path, endpoint_id=endpoint_id, function_id=func_uuid)
+    return str(task_id)
+
+
 # ---------------------------------------------------------------------------
 # Task submission and status
 # ---------------------------------------------------------------------------
diff --git a/web/routes/globus.py b/web/routes/globus.py
index 8a2973b0..c6763837 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -22,6 +22,7 @@
     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
@@ -247,6 +248,112 @@ 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"]
+
+        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,
+        })
+
+    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/static/js/inspector.js b/web/static/js/inspector.js
index 23978f6a..817b5dd0 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -1066,11 +1066,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;
   }
 
@@ -1091,22 +1090,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) => {
@@ -1115,14 +1108,21 @@ 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");
+      }
+      // 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");
     });
 }
 
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 -->

From 2236ae7048312891ca55b1f107b916b4b53b5f4f Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 09:38:19 -0700
Subject: [PATCH 38/49] fix(globus): list remote files via remote_metric_runner
 instead of a new function

A live endpoint rejected the separate listing function with a 422
SEMANTICALLY_INVALID / (SystemExit) 73 at submit time. Fold the directory/file
listing into the already-registered, proven remote_metric_runner as a
'__list_files__' operation so it goes through the same serialization/registration
path metrics use. Removes remote_list_data_files/register_list_function; adds a
direct test of the list operation.
---
 tests/integration/test_globus_multifile.py | 13 +++++
 web/globus.py                              | 67 +++++++++-------------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
index 221d926e..bd365115 100644
--- a/tests/integration/test_globus_multifile.py
+++ b/tests/integration/test_globus_multifile.py
@@ -216,3 +216,16 @@ def test_globus_add_requires_auth(globus_client):
         "/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(p.split("/")[-1] 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", "", "")
diff --git a/web/globus.py b/web/globus.py
index 3550f91a..86bafa18 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -45,7 +45,27 @@ 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}"}
+
     # Ensure matplotlib uses non-interactive backend on remote endpoint
     import matplotlib
     matplotlib.use("Agg")
@@ -429,48 +449,15 @@ def register_function(client, force=False):
 # ---------------------------------------------------------------------------
 
 
-def remote_list_data_files(path):
-    """Run on the remote endpoint: enumerate data files at ``path``.
+def submit_list_files(client, endpoint_id, path):
+    """Submit a remote file-listing task; return the task UUID string.
 
-    If ``path`` is a file, return just that file. If it's a directory, return
-    the files directly inside it (non-recursive). Returns
-    ``{"files": [abs_path, ...]}`` or ``{"error": str}``. Pure stdlib so it does
-    not depend on the endpoint's installed ``aidrin`` version.
+    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.
     """
-    import os
-
-    try:
-        if os.path.isfile(path):
-            return {"files": [path]}
-        if os.path.isdir(path):
-            files = sorted(
-                os.path.join(path, f)
-                for f in os.listdir(path)
-                if os.path.isfile(os.path.join(path, f))
-            )
-            return {"files": files}
-        return {"error": f"Path not found on the remote endpoint: {path}"}
-    except Exception as e:  # noqa: BLE001
-        return {"error": f"Could not list '{path}': {e}"}
-
-
-def register_list_function(client, force=False):
-    """Register remote_list_data_files with Globus Compute; return its UUID."""
-    cache_key = "remote_list_data_files"
-    if not force and cache_key in _function_uuid_cache:
-        return _function_uuid_cache[cache_key]
-
-    func_uuid = client.register_function(remote_list_data_files)
-    _function_uuid_cache[cache_key] = func_uuid
-    logger.info("Registered remote_list_data_files with Globus Compute: %s", func_uuid)
-    return func_uuid
-
-
-def submit_list_files(client, endpoint_id, path):
-    """Submit a remote file-listing task; return the task UUID string."""
-    func_uuid = register_list_function(client)
-    task_id = client.run(path, endpoint_id=endpoint_id, function_id=func_uuid)
-    return str(task_id)
+    name = path.rstrip("/").split("/")[-1]
+    return submit_metric(client, endpoint_id, "__list_files__", path, name, "")
 
 
 # ---------------------------------------------------------------------------

From 378cb05b93001b1452b0c602894804e07ab63280 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 09:47:42 -0700
Subject: [PATCH 39/49] fix(globus): hash function source in the registration
 cache key

The function-UUID cache reused a stale registration after remote_metric_runner
was edited (e.g. adding __list_files__), so the endpoint ran the old code and
reported 'Unknown metric: __list_files__'. Key the cache on a hash of the
function source so any change forces a fresh registration once the process has
reloaded the new code.
---
 web/globus.py | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/web/globus.py b/web/globus.py
index 86bafa18..586f74fe 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -431,10 +431,20 @@ 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):
+        digest = "nosrc"
+    cache_key = f"remote_metric_runner:{digest}"
     if not force and cache_key in _function_uuid_cache:
         return _function_uuid_cache[cache_key]
 

From 34e3d33be6b36a9bcabc9382abc76a7b77df3d70 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 10:01:05 -0700
Subject: [PATCH 40/49] fix(globus): retry submissions on transient 409
 'endpoint in use'

Globus Compute returns 409 RESOURCE_CONFLICT when the endpoint is momentarily
busy and asks the caller to retry. Wrap client.run in _run_with_retry with
backoff (1s,2s,3s,4s) on 409/RESOURCE_CONFLICT so metric and listing
submissions ride out a busy endpoint instead of erroring out.
---
 tests/integration/test_globus_multifile.py | 26 +++++++++++++++++++
 web/globus.py                              | 30 +++++++++++++++++++++-
 2 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
index bd365115..b284c8e3 100644
--- a/tests/integration/test_globus_multifile.py
+++ b/tests/integration/test_globus_multifile.py
@@ -229,3 +229,29 @@ def test_remote_list_files_operation(tmp_path):
     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
diff --git a/web/globus.py b/web/globus.py
index 586f74fe..e938ee39 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -475,6 +475,33 @@ def submit_list_files(client, endpoint_id, path):
 # ---------------------------------------------------------------------------
 
 
+def _run_with_retry(client, *args, max_attempts=5, **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; back off and re-submit.
+    """
+    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()
+            )
+            if transient and attempt < max_attempts - 1:
+                last_err = e
+                time.sleep(1.0 * (attempt + 1))  # 1s, 2s, 3s, 4s
+                continue
+            raise
+    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.
 
@@ -485,7 +512,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,

From df163109ae22ccf7876a41bbe84449c4c724ab28 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 10:26:07 -0700
Subject: [PATCH 41/49] chore(globus): log whether the loaded
 remote_metric_runner supports __list_files__

Adds a registration log line (func_uuid, src hash, supports __list_files__) so a
stale-process situation is diagnosable: if it logs supports=False, the server is
running old code and must be fully restarted.
---
 web/globus.py | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/web/globus.py b/web/globus.py
index e938ee39..907b525e 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -443,14 +443,21 @@ def register_function(client, force=False):
         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
 
 
@@ -475,12 +482,15 @@ def submit_list_files(client, endpoint_id, path):
 # ---------------------------------------------------------------------------
 
 
-def _run_with_retry(client, *args, max_attempts=5, **kwargs):
+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; back off and re-submit.
+    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
@@ -494,11 +504,13 @@ def _run_with_retry(client, *args, max_attempts=5, **kwargs):
                 or "RESOURCE_CONFLICT" in msg
                 or "already in use" in msg.lower()
             )
-            if transient and attempt < max_attempts - 1:
-                last_err = e
-                time.sleep(1.0 * (attempt + 1))  # 1s, 2s, 3s, 4s
-                continue
-            raise
+            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
 
 

From fd7f19d2e800446a23f9f466f032cfadf89c5d50 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 10:57:56 -0700
Subject: [PATCH 42/49] fix(globus): compute remote batch overview inline, not
 via aidrin.summarize_files

Globus batch-overview stats showed as dashes because __summarize_files__ called
aidrin.summarize_files on the endpoint, which doesn't exist in the endpoint's
released aidrin. Inline the computation with read_file + pandas (present in any
aidrin install) so it's version-independent, mirroring summarize_files' output.
Verified the remote output matches the local helper exactly.
---
 tests/integration/test_globus_multifile.py | 21 ++++++++++++
 web/globus.py                              | 40 ++++++++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/tests/integration/test_globus_multifile.py b/tests/integration/test_globus_multifile.py
index b284c8e3..97bb22f1 100644
--- a/tests/integration/test_globus_multifile.py
+++ b/tests/integration/test_globus_multifile.py
@@ -255,3 +255,24 @@ def test_run_with_retry_reraises_other_errors(monkeypatch):
     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/web/globus.py b/web/globus.py
index 907b525e..7d8dd076 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -66,6 +66,46 @@ def remote_metric_runner(metric_name, file_path, file_name, file_type, **params)
         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")

From 6c35b065d4ad8b99e04d3d8f6710d950ed2730f4 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 12:34:50 -0700
Subject: [PATCH 43/49] fix(globus): surface why batch stats fail + allow retry
 of failed entries

Globus per-file stats showed as dashes with no explanation. (1) The 'pending'
guard used 'records not in e', so once an entry was cached as records=None from
a failed fetch it was never retried; use 'records is None' instead. (2) Capture
the failure reason (remote {error} like 'Unknown metric', or an exception) and
return it as overview_error; the UI now shows it as a toast instead of silent
dashes.
---
 web/routes/globus.py       | 61 ++++++++++++++++++++++++++++++++++++++
 web/static/js/inspector.js | 20 ++++++++-----
 2 files changed, 73 insertions(+), 8 deletions(-)

diff --git a/web/routes/globus.py b/web/routes/globus.py
index c6763837..8aad6d1c 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -29,6 +29,26 @@
 
 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")
 
 
@@ -333,6 +353,46 @@ def add_files():
             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:
+            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 []
+                )
+                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)
+            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
@@ -347,6 +407,7 @@ def add_files():
             "added": added,
             "skipped": skipped,
             "active_file_id": first_id,
+            "overview_error": overview_error,  # why per-file stats are missing
         })
 
     except Exception as e:
diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 817b5dd0..407eedb1 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -1115,6 +1115,11 @@ function loadGlobusDataset() {
       ) {
         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";
@@ -2007,18 +2012,17 @@ function loadBatchOverview() {
         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";
-        // Globus (remote) files show "n/a" for data-derived stats — phase 1
-        // does not pull remote data for the overview. (Per-row remote counts
-        // are a documented follow-up.)
+        // 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,
-          isGlobus ? "n/a" : (f.records ?? "—"),
-          isGlobus ? "n/a" : (f.features ?? "—"),
-          isGlobus ? "n/a" : (f.numerical ?? "—"),
-          isGlobus ? "n/a" : (f.categorical ?? "—"),
+          f.records ?? "—",
+          f.features ?? "—",
+          f.numerical ?? "—",
+          f.categorical ?? "—",
           fmtBytes(f.size_bytes),
         ];
         cells.forEach((text, idx) => {

From 7f529f3c6f65c851f663856ece616e1fd68a18ed Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 12:54:11 -0700
Subject: [PATCH 44/49] fix(globus): clearer stats-failure reasons (stale
 build, per-file read errors)

---
 web/routes/globus.py | 67 +++++++++++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 22 deletions(-)

diff --git a/web/routes/globus.py b/web/routes/globus.py
index 8aad6d1c..bf9c0986 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -368,30 +368,53 @@ def add_files():
         ]
         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:
-                infos = [[e["path"], e["name"], e["type"]] for e in pending]
-                overview_task = submit_metric(
-                    client, endpoint_id, "__summarize_files__", "", "", "",
-                    file_infos=infos,
+                _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."
                 )
-                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 []
-                )
-                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)
-            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)
+            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 []
+                    )
+                    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:

From ce1aab206c69755cb8ab4a92e18d1d75591180d8 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 13:02:20 -0700
Subject: [PATCH 45/49] chore(globus): log the __summarize_files__ result (ok
 count + sample row + error)

---
 web/routes/globus.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/web/routes/globus.py b/web/routes/globus.py
index bf9c0986..319c9f18 100644
--- a/web/routes/globus.py
+++ b/web/routes/globus.py
@@ -395,6 +395,13 @@ def add_files():
                     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):

From b03d9f94645597abfdea47da72e5ceabe1ee0c0b Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 13:10:16 -0700
Subject: [PATCH 46/49] fix(globus): also retry on transient 'Failed to start /
 SystemExit 73' worker errors
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The same registered function that listed files succeeded once then failed with
422 'Failed to start ... (SystemExit) 73' minutes later — an intermittent
endpoint worker-startup failure, not an invalid request. Treat it as transient
and retry with the existing jittered backoff.
---
 web/globus.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/web/globus.py b/web/globus.py
index 7d8dd076..db246ff7 100644
--- a/web/globus.py
+++ b/web/globus.py
@@ -543,6 +543,10 @@ def _run_with_retry(client, *args, max_attempts=8, **kwargs):
                 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

From 9bb3e1d3d3e474da0f82f85701f1ee604a187140 Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 14:14:24 -0700
Subject: [PATCH 47/49] fix(privacy): clear error for empty quasi-identifiers
 (k-anon 'No group keys passed!')

Running k-anonymity (or l-diversity/t-closeness/entropy) on a Globus file with
no quasi-identifiers selected reached pandas' groupby([]) and surfaced the raw
'No group keys passed!'. The local route guards this but the Globus path didn't.
Guard all four privacy functions to return a clear 'Please select at least one
quasi-identifier.' message, and add a frontend guard so the Globus submit gives
instant feedback instead of a slow remote round-trip.
---
 .../structured_data_metrics/privacy_measure.py |  8 ++++++++
 tests/unit/test_privacy.py                     | 18 ++++++++++++++++++
 web/static/js/inspector.js                     | 17 +++++++++++++++++
 3 files changed, 43 insertions(+)

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/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/web/static/js/inspector.js b/web/static/js/inspector.js
index 407eedb1..9c6576ef 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -436,6 +436,23 @@ function workspaceSubmit(targetUrl) {
       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;
   }

From a73ff515bc2761aec31a6364c387a3a21d3948fa Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Mon, 8 Jun 2026 14:31:01 -0700
Subject: [PATCH 48/49] fix(globus): clear message for privacy metrics with no
 remote handler
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Differential privacy and the single/multiple attribute risk scores have no
remote_metric_runner branch, so selecting them on a Globus file silently fell
back to k-anonymity (then 'no quasi-identifiers'). Detect those selections in
the Globus submit path and show a clear 'not available for remote files yet —
use a local file' message instead of misfiring.
---
 web/static/js/inspector.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/web/static/js/inspector.js b/web/static/js/inspector.js
index 9c6576ef..6185927b 100644
--- a/web/static/js/inspector.js
+++ b/web/static/js/inspector.js
@@ -431,6 +431,21 @@ 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;

From 3706d430ae3465e00b9afd7219c4c95a82dd51cf Mon Sep 17 00:00:00 2001
From: Jean Luca Bez <jeanlucabez@gmail.com>
Date: Wed, 1 Jul 2026 10:06:18 -0700
Subject: [PATCH 49/49] chore: gitignore local session artifacts (AIDRIN-gtag,
 claude.session)

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index e5a48d43..8b4424cc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -192,3 +192,7 @@ 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