Update collection metadata and safe collectors

LICENSES/source_terms.md

@@ -4,6 +4,8 @@ This file tracks the source terms that govern public mirroring and derived
 NIfTI conversion. It is not legal advice. When a source has ambiguous or
 conflicting terms, raw scans are not mirrored until the terms are resolved.
 
+Last reviewed against the linked source pages: 2026-06-28 UTC.
+
 | Dataset | Source | Current handling |
 |---|---|---|
 | LIDC-IDRI | TCIA public collection: https://www.cancerimagingarchive.net/collection/lidc-idri/ | OK to collect with attribution and TCIA policy notes |
@@ -15,6 +17,11 @@ conflicting terms, raw scans are not mirrored until the terms are resolved.
 | MIDRC | MIDRC Data Use Agreement: https://www.midrc.org/midrc-data-use-agreement | Do not mirror raw or converted scans; DUA requires separate users to access through MIDRC and prohibits distribution without written permission |
 | LTRC | NHLBI BioLINCC: https://biolincc.nhlbi.nih.gov/studies/ltrc/ | Do not mirror raw scans publicly; access requires BioLINCC login/request and is limited to lung disease research |
 
+The machine-readable enforcement policy is in
+`manifests/source_datasets.csv`. Collector scripts refuse scan uploads unless
+that registry explicitly permits mirroring. Metadata-only preparation does not
+override a source agreement.
+
 ## Standard User Obligations
 
 Users must not attempt to identify or contact patients represented in these

README.md

@@ -39,6 +39,20 @@ data/
 Each scan directory contains only `ct.nii.gz`. Provenance, source identifiers,
 checksums, and conversion metadata are stored in `manifests/`.
 
+## Safe Collection
+
+Collection is fail-closed: commands are dry runs unless `--execute` is supplied,
+executed batches default to one case, and all collectors share a lock. Temporary
+data is capped at 20 GiB across `.hf_tmp`, while at least 100 GiB of filesystem
+free space is reserved and checked throughout every download and extraction.
+LUNA16 extracts one scan at a time instead of unpacking a complete subset.
+
+Credentials are read only from supported Hugging Face environment variables.
+Never put API tokens in commands, files, logs, notebooks, or issue text.
+
+See `docs/collection_plan.md` for source gates and safe dry-run commands. Run
+`python scripts/collection_status.py` for an offline readiness check.
+
 ## Planned Public CT Sources
 
 | Dataset | Planned scans from paper | Status policy |

docs/collection_plan.md

@@ -0,0 +1,77 @@
+# Collection Plan
+
+This workspace prepares the eight public cohorts listed in the SUMI paper while
+failing closed on storage and redistribution policy. A paper cohort count is a
+target, not permission to mirror a source.
+
+## Safety Defaults
+
+- Collection commands are dry runs unless `--execute` is supplied.
+- Executed batches default to one CT volume.
+- All bundled collectors share one advisory lock, so they cannot stage large
+  downloads concurrently.
+- Staging is capped at 20 GiB across `.hf_tmp`, with at least 100 GiB of free
+  filesystem space reserved. Both limits are checked before and during writes.
+- Temporary archives, extracted source images, and converted CTs are removed
+  after each bounded batch. LUNA16 extracts only one scan from a subset archive
+  at a time.
+- A CT and its JSONL manifest update are uploaded in one Hugging Face commit.
+
+Do not lower `--min-free-gb` or raise `--max-local-gb` while other disk-heavy
+jobs are active.
+
+## Source Matrix
+
+| Dataset | Preparation | Permitted action |
+|---|---|---|
+| LIDC-IDRI | Ready | Bounded TCIA upload with attribution |
+| LUNA16 | Canary passed | Bounded batches; one scan extracted at a time |
+| NLST | Collector ready, selection unresolved | Catalog only until the exact 422-series allowlist is reviewed |
+| DSB17 | Terms unresolved | Metadata/instructions only |
+| LNDb19 | Record text and metadata conflict; record text says no derivatives | Metadata/instructions only |
+| LTRC | BioLINCC request and agreement required | Metadata/instructions only |
+| MIDRC | Redistribution prohibited without written permission | Metadata/instructions only |
+| RSNA-STR | Redistribution expressly prohibited | Metadata/instructions only |
+
+The machine-readable policy gate is `manifests/source_datasets.csv`. The
+collectors refuse execution when that registry does not explicitly allow the
+requested source.
+
+## Safe Commands
+
+Plan the next LIDC-IDRI case without downloading scan data:
+
+```bash
+python scripts/tcia_collect_upload.py \
+  --collection LIDC-IDRI \
+  --dataset-name LIDC-IDRI
+```
+
+Execute one LIDC-IDRI case only after reviewing the dry run:
+
+```bash
+python scripts/tcia_collect_upload.py \
+  --collection LIDC-IDRI \
+  --dataset-name LIDC-IDRI \
+  --max-cases 1 \
+  --execute
+```
+
+Plan a LUNA16 subset-0 smoke test without downloading its 6.8 GB archive:
+
+```bash
+python scripts/luna16_collect_upload.py --subset 0 --max-cases 1
+```
+
+NLST execution is intentionally impossible until
+`manifests/NLST_selection.csv` contains reviewed TCIA Series Instance UIDs:
+
+```bash
+python scripts/tcia_collect_upload.py \
+  --collection NLST \
+  --dataset-name NLST \
+  --series-allowlist manifests/NLST_selection.csv \
+  --max-cases 1
+```
+
+After the allowlist and its provenance are reviewed, add `--execute`.

manifests/NLST_selection.csv

@@ -0,0 +1 @@
+series_uid,selection_reason,source_reference

manifests/progress.md

@@ -1,14 +1,26 @@
 # Collection Progress
 
-Last updated: 2026-06-26 UTC
+Last updated: 2026-06-28 UTC
 
 | Dataset | Uploaded CT volumes | Notes |
 |---|---:|---|
-| LIDC-IDRI | 5 | First storage-safe TCIA batch uploaded as `data/LIDC-IDRI_00000001` through `data/LIDC-IDRI_00000005` |
-| LUNA16 | 0 | Collector script prepared; next step is a one-subset or smoke-test upload |
-| NLST | 0 | Public TCIA/IDC source confirmed; paper subset selection still needs to be fixed before upload |
+| LIDC-IDRI | 5 | Live inventory verified; collector now uses bounded writes and atomic CT+manifest commits |
+| LUNA16 | 1 | Subset-0 canary passed as `data/LUNA16_00000001`; archive and extracted source were cleaned |
+| NLST | 0 | Collector and allowlist schema prepared; exact 422-series selection still requires review |
 | LNDb19 | 0 | Hold converted NIfTI upload until license conflict is resolved |
 | DSB17 | 0 | Hold converted NIfTI upload until Kaggle/TCIA source terms are resolved |
 | RSNA-STR | 0 | Raw/converted mirroring blocked by no-redistribution term |
 | MIDRC | 0 | Raw/converted mirroring blocked by DUA redistribution restriction |
 | LTRC | 0 | Raw mirroring blocked pending BioLINCC access/permission |
+
+## Preparation State
+
+- All collection commands default to dry-run mode and one-case batches.
+- A shared collection lock prevents bundled collectors from staging in parallel.
+- Staging is capped at 20 GiB with a 100 GiB filesystem free-space reserve.
+- LUNA16 now extracts one scan from a subset archive at a time.
+- The first LUNA16 canary passed checksum, conversion, atomic upload, remote
+  manifest reconciliation, and staging cleanup checks.
+- Restricted sources are policy-gated to metadata/instructions only.
+- Offline storage, conversion, policy, and credential-leak tests are available
+  under `tests/`.

manifests/source_datasets.csv

@@ -1,9 +1,9 @@
-dataset,planned_scans,source_primary,license_status,mirror_policy
-DSB17,1596,Kaggle Data Science Bowl 2017,under_review,manifest_until_terms_verified
-LIDC-IDRI,1018,TCIA LIDC-IDRI,cc_by_3_tcia_policy,mirror_allowed_with_attribution
-LNDb19,324,Zenodo LNDb Dataset,conflicting_cc_by_vs_cc_by_nc_nd,hold_converted_nifti
-LTRC,1496,NHLBI BioLINCC LTRC,access_controlled_biolincc,manifest_only_without_permission
-LUNA16,854,Grand Challenge/Zenodo LUNA16,cc_by_4,mirror_allowed_with_attribution
-MIDRC,10496,MIDRC Data Commons,redistribution_prohibited_without_permission,manifest_only
-NLST,422,TCIA/IDC NLST,public_tcia_policy,mirror_selected_public_ct_with_attribution
-RSNA-STR,1110,Kaggle/AWS RSNA STR Pulmonary Embolism Detection,redistribution_prohibited,manifest_only
+dataset,planned_scans,source_primary,license_status,mirror_policy,preparation_status,collector,required_selection
+DSB17,1596,Kaggle Data Science Bowl 2017,under_review,manifest_until_terms_verified,blocked_terms_review,none,
+LIDC-IDRI,1018,TCIA LIDC-IDRI,cc_by_3_tcia_policy,mirror_allowed_with_attribution,ready_bounded_batches,scripts/tcia_collect_upload.py,
+LNDb19,324,Zenodo LNDb Dataset,conflicting_cc_by_vs_cc_by_nc_nd,hold_converted_nifti,blocked_license_conflict,none,
+LTRC,1496,NHLBI BioLINCC LTRC,access_controlled_biolincc,manifest_only_without_permission,access_request_required,none,
+LUNA16,854,Grand Challenge/Zenodo LUNA16,cc_by_4,mirror_allowed_with_attribution,canary_passed_bounded_batches_ready,scripts/luna16_collect_upload.py,
+MIDRC,10496,MIDRC Data Commons,redistribution_prohibited_without_permission,manifest_only,manifest_only_no_redistribution,none,
+NLST,422,TCIA/IDC NLST,public_tcia_policy,mirror_selected_public_ct_with_attribution,selection_required,scripts/tcia_collect_upload.py,manifests/NLST_selection.csv
+RSNA-STR,1110,Kaggle/AWS RSNA STR Pulmonary Embolism Detection,redistribution_prohibited,manifest_only,manifest_only_no_redistribution,none,

scripts/collection_status.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Report and validate SUMI OpenCT collection readiness without network I/O."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+
+EXPECTED_DATASETS = {
+    "DSB17",
+    "LIDC-IDRI",
+    "LNDb19",
+    "LTRC",
+    "LUNA16",
+    "MIDRC",
+    "NLST",
+    "RSNA-STR",
+}
+MIRROR_ALLOWED = {
+    "mirror_allowed_with_attribution",
+    "mirror_selected_public_ct_with_attribution",
+}
+
+
+def read_jsonl(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    rows: list[dict] = []
+    with path.open(encoding="utf-8") as f:
+        for line_number, line in enumerate(f, start=1):
+            if not line.strip():
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise RuntimeError(f"Invalid JSON at {path}:{line_number}: {exc}") from exc
+            if not isinstance(value, dict):
+                raise RuntimeError(f"Expected an object at {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def count_csv_rows(path: Path) -> int:
+    if not path.exists():
+        return 0
+    with path.open(newline="", encoding="utf-8") as f:
+        return sum(1 for _ in csv.DictReader(f))
+
+
+def collect_status(root: Path) -> tuple[list[dict], list[str]]:
+    registry_path = root / "manifests/source_datasets.csv"
+    with registry_path.open(newline="", encoding="utf-8") as f:
+        registry = list(csv.DictReader(f))
+
+    errors: list[str] = []
+    names = {row.get("dataset", "") for row in registry}
+    if names != EXPECTED_DATASETS:
+        errors.append(
+            f"registry datasets differ: missing={sorted(EXPECTED_DATASETS - names)}, "
+            f"unexpected={sorted(names - EXPECTED_DATASETS)}"
+        )
+
+    status: list[dict] = []
+    for source in registry:
+        dataset = source["dataset"]
+        planned = int(source["planned_scans"])
+        manifest_path = root / f"manifests/{dataset}.jsonl"
+        manifest = read_jsonl(manifest_path)
+        folders = [str(row.get("folder", "")) for row in manifest]
+        source_uids = [str(row.get("source_series_uid", "")) for row in manifest]
+
+        if len(folders) != len(set(folders)):
+            errors.append(f"{dataset}: duplicate folder in {manifest_path}")
+        if any(not value for value in folders):
+            errors.append(f"{dataset}: manifest row missing folder")
+        if len(source_uids) != len(set(source_uids)):
+            errors.append(f"{dataset}: duplicate source_series_uid in {manifest_path}")
+        if any(not value for value in source_uids):
+            errors.append(f"{dataset}: manifest row missing source_series_uid")
+        if len(manifest) > planned:
+            errors.append(f"{dataset}: {len(manifest)} uploads exceed planned count {planned}")
+
+        collector = source.get("collector", "")
+        if collector and collector != "none" and not (root / collector).is_file():
+            errors.append(f"{dataset}: collector does not exist: {collector}")
+        policy = source.get("mirror_policy", "")
+        if policy not in MIRROR_ALLOWED and manifest:
+            errors.append(f"{dataset}: restricted source has {len(manifest)} uploaded manifest rows")
+
+        selection_path = source.get("required_selection", "")
+        selection_rows = count_csv_rows(root / selection_path) if selection_path else None
+        status.append(
+            {
+                "dataset": dataset,
+                "planned": planned,
+                "uploaded": len(manifest),
+                "preparation_status": source.get("preparation_status", ""),
+                "mirror_policy": policy,
+                "selection_rows": selection_rows,
+            }
+        )
+    return status, errors
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path("."))
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    status, errors = collect_status(root)
+    if args.json:
+        print(json.dumps({"sources": status, "errors": errors}, indent=2, sort_keys=True))
+    else:
+        print(f"{'dataset':<12} {'planned':>8} {'uploaded':>8}  preparation")
+        for row in status:
+            selection = row["selection_rows"]
+            suffix = f" (selection rows: {selection})" if selection is not None else ""
+            print(
+                f"{row['dataset']:<12} {row['planned']:>8} {row['uploaded']:>8}  "
+                f"{row['preparation_status']}{suffix}"
+            )
+        print(
+            f"{'TOTAL':<12} {sum(row['planned'] for row in status):>8} "
+            f"{sum(row['uploaded'] for row in status):>8}"
+        )
+        print("validation: " + ("OK" if not errors else "FAILED"))
+        for error in errors:
+            print(f"- {error}")
+
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/luna16_collect_upload.py

@@ -9,21 +9,38 @@ Use `--max-cases` for small smoke tests before full collection.
 from __future__ import annotations
 
 import argparse
+import csv
 import hashlib
 import json
 import os
 import re
-import shutil
 import tempfile
 import zipfile
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 import nibabel as nib
 import numpy as np
 import requests
-from huggingface_hub import HfApi
+from huggingface_hub import CommitOperationAdd, HfApi
 from tqdm import tqdm
 
+try:
+    from .storage_guard import (
+        StorageBudget,
+        copy_bounded,
+        exclusive_collection_lock,
+        extract_member_bounded,
+        validated_zip_member,
+    )
+except ImportError:  # Support `python scripts/luna16_collect_upload.py`.
+    from storage_guard import (  # type: ignore[no-redef]
+        StorageBudget,
+        copy_bounded,
+        exclusive_collection_lock,
+        extract_member_bounded,
+        validated_zip_member,
+    )
+
 
 TOKEN_KEYS = (
     "HF_TOKEN",
@@ -73,22 +90,6 @@ def default_repo_id(api: HfApi, token: str, repo_name: str) -> str:
     return f"{namespace}/{repo_name}"
 
 
-def bytes_in_tree(path: Path) -> int:
-    if not path.exists():
-        return 0
-    return sum(p.stat().st_size for p in path.rglob("*") if p.is_file())
-
-
-def enforce_staging_limit(path: Path, max_local_gb: float) -> None:
-    used = bytes_in_tree(path)
-    limit = int(max_local_gb * 1024**3)
-    if used > limit:
-        raise RuntimeError(
-            f"Staging directory {path} uses {used / 1024**3:.2f} GiB, "
-            f"above the configured {max_local_gb:.2f} GiB limit."
-        )
-
-
 def md5_file(path: Path) -> str:
     h = hashlib.md5()
     with path.open("rb") as f:
@@ -105,30 +106,48 @@ def sha256_file(path: Path) -> str:
     return h.hexdigest()
 
 
-def download(url: str, out_path: Path) -> None:
+def download(url: str, out_path: Path, budget: StorageBudget) -> None:
     with requests.get(url, stream=True, timeout=300) as resp:
         resp.raise_for_status()
         total = int(resp.headers.get("content-length") or 0)
-        with out_path.open("wb") as f, tqdm(total=total, unit="B", unit_scale=True, desc=out_path.name) as bar:
-            for chunk in resp.iter_content(chunk_size=1024 * 1024):
-                if chunk:
-                    f.write(chunk)
-                    bar.update(len(chunk))
+        with tqdm(
+            total=total,
+            unit="B",
+            unit_scale=True,
+            desc=out_path.name,
+            mininterval=10.0,
+        ) as bar:
+            copy_bounded(
+                resp.raw,
+                out_path,
+                budget,
+                expected_bytes=total or None,
+                context=f"downloading {out_path.name}",
+                on_chunk=bar.update,
+            )
 
 
 def parse_mhd(path: Path) -> dict[str, str]:
-    fields: dict[str, str] = {}
     with path.open("r", encoding="utf-8") as f:
-        for line in f:
-            if "=" not in line:
-                continue
-            key, value = line.split("=", 1)
-            fields[key.strip()] = value.strip()
+        return parse_mhd_text(f.read())
+
+
+def parse_mhd_text(text: str) -> dict[str, str]:
+    fields: dict[str, str] = {}
+    for line in text.splitlines():
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        fields[key.strip()] = value.strip()
     return fields
 
 
-def convert_mhd_to_nifti(mhd_path: Path, raw_path: Path, out_path: Path) -> dict[str, object]:
-    fields = parse_mhd(mhd_path)
+def convert_mhd_fields_to_nifti(
+    fields: dict[str, str],
+    raw_path: Path,
+    out_path: Path,
+    budget: StorageBudget | None = None,
+) -> dict[str, object]:
     dims = [int(v) for v in fields["DimSize"].split()]
     spacing = [float(v) for v in fields.get("ElementSpacing", "1 1 1").split()]
     offset = [float(v) for v in fields.get("Offset", "0 0 0").split()]
@@ -156,6 +175,9 @@ def convert_mhd_to_nifti(mhd_path: Path, raw_path: Path, out_path: Path) -> dict
     image.header.set_xyzt_units("mm")
     image.header["cal_min"] = float(np.nanmin(data_xyz))
     image.header["cal_max"] = float(np.nanmax(data_xyz))
+    if budget is not None:
+        worst_case_bytes = int(data_xyz.nbytes * 1.01) + 1024 * 1024
+        budget.check(worst_case_bytes, context="writing converted LUNA16 NIfTI")
     nib.save(image, str(out_path))
     return {
         "shape": list(map(int, data_xyz.shape)),
@@ -164,138 +186,310 @@ def convert_mhd_to_nifti(mhd_path: Path, raw_path: Path, out_path: Path) -> dict
     }
 
 
+def convert_mhd_to_nifti(
+    mhd_path: Path,
+    raw_path: Path,
+    out_path: Path,
+    budget: StorageBudget | None = None,
+) -> dict[str, object]:
+    return convert_mhd_fields_to_nifti(parse_mhd(mhd_path), raw_path, out_path, budget)
+
+
 def existing_indices(api: HfApi, repo_id: str, dataset_name: str, token: str) -> set[int]:
-    try:
-        files = api.list_repo_files(repo_id=repo_id, repo_type="dataset", token=token)
-    except Exception:
-        return set()
+    files = api.list_repo_files(repo_id=repo_id, repo_type="dataset", token=token)
     pattern = re.compile(rf"^data/{re.escape(dataset_name)}_(\d{{8}})/ct\.nii\.gz$")
     return {int(match.group(1)) for path in files if (match := pattern.match(path))}
 
 
-def append_jsonl(path: Path, row: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(row, sort_keys=True) + "\n")
-
-
-def read_manifest_values(path: Path, key: str) -> set[str]:
+def read_manifest_rows(path: Path) -> list[dict]:
     if not path.exists():
-        return set()
-    values: set[str] = set()
+        return []
+    rows: list[dict] = []
     with path.open("r", encoding="utf-8") as f:
-        for line in f:
+        for line_number, line in enumerate(f, start=1):
             line = line.strip()
             if not line:
                 continue
             try:
                 row = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            value = row.get(key)
-            if value:
-                values.add(str(value))
-    return values
+            except json.JSONDecodeError as exc:
+                raise RuntimeError(f"Invalid JSON in {path}:{line_number}: {exc}") from exc
+            if not isinstance(row, dict):
+                raise RuntimeError(f"Expected an object in {path}:{line_number}")
+            rows.append(row)
+    return rows
+
+
+def sync_remote_manifest(repo_id: str, dataset_name: str, token: str, local_path: Path) -> list[dict]:
+    remote_path = f"manifests/{dataset_name}.jsonl"
+    url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{remote_path}"
+    response = requests.get(url, headers={"Authorization": f"Bearer {token}"}, timeout=120)
+    if response.status_code == 404:
+        return read_manifest_rows(local_path)
+    response.raise_for_status()
+
+    remote_rows: list[dict] = []
+    for line_number, line in enumerate(response.text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(
+                f"Invalid JSON in remote {remote_path}:{line_number}: {exc}"
+            ) from exc
+        if not isinstance(row, dict):
+            raise RuntimeError(f"Expected an object in remote {remote_path}:{line_number}")
+        remote_rows.append(row)
+
+    local_rows = read_manifest_rows(local_path)
+    remote_uids = {str(row.get("source_series_uid")) for row in remote_rows}
+    local_only = {
+        str(row.get("source_series_uid"))
+        for row in local_rows
+        if str(row.get("source_series_uid")) not in remote_uids
+    }
+    if local_only:
+        raise RuntimeError(
+            f"Local manifest has {len(local_only)} source UID(s) absent from the remote manifest; "
+            "refusing to overwrite divergent state."
+        )
+
+    canonical = "".join(json.dumps(row, sort_keys=True) + "\n" for row in remote_rows)
+    current = local_path.read_text(encoding="utf-8") if local_path.exists() else ""
+    if canonical != current:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=local_path.parent,
+            prefix=f".{local_path.name}.",
+            suffix=".sync",
+            delete=False,
+        ) as tmp:
+            tmp.write(canonical)
+            tmp_path = Path(tmp.name)
+        os.replace(tmp_path, local_path)
+    return remote_rows
+
+
+def create_manifest_candidate(path: Path, rows: list[dict], row: dict) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        suffix=".pending",
+        delete=False,
+    ) as tmp:
+        for existing in rows:
+            tmp.write(json.dumps(existing, sort_keys=True) + "\n")
+        tmp.write(json.dumps(row, sort_keys=True) + "\n")
+        return Path(tmp.name)
+
+
+def assert_mirroring_policy(dataset_name: str, policy_path: Path) -> None:
+    with policy_path.open(newline="", encoding="utf-8") as f:
+        rows = {row["dataset"]: row for row in csv.DictReader(f)}
+    if dataset_name not in rows:
+        raise RuntimeError(f"{dataset_name} is not present in {policy_path}")
+    policy = rows[dataset_name].get("mirror_policy", "")
+    if policy != "mirror_allowed_with_attribution":
+        raise RuntimeError(
+            f"Refusing to mirror {dataset_name}: registry policy is {policy!r}, not an allowed policy."
+        )
+
+
+def luna_members(zf: zipfile.ZipFile) -> list[str]:
+    return sorted(info.filename for info in zf.infolist() if info.filename.lower().endswith(".mhd"))
+
+
+def mhd_and_raw_member(zf: zipfile.ZipFile, mhd_member: str) -> tuple[dict[str, str], str]:
+    info = validated_zip_member(zf, mhd_member)
+    fields = parse_mhd_text(zf.read(info).decode("utf-8"))
+    raw_name = fields.get("ElementDataFile")
+    if not raw_name or raw_name.upper() == "LOCAL":
+        raise RuntimeError(f"Unsupported ElementDataFile in {mhd_member}: {raw_name!r}")
+    raw_path = PurePosixPath(mhd_member).parent / PurePosixPath(raw_name)
+    if raw_path.is_absolute() or ".." in raw_path.parts:
+        raise RuntimeError(f"Unsafe raw member path in {mhd_member}: {raw_name}")
+    raw_member = raw_path.as_posix()
+    validated_zip_member(zf, raw_member)
+    return fields, raw_member
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(
+        description="Plan or upload a bounded LUNA16 batch with strict storage guards."
+    )
     parser.add_argument("--dataset-name", default="LUNA16")
     parser.add_argument("--repo-id", default=None)
     parser.add_argument("--repo-name", default="SUMI-OpenCT")
     parser.add_argument("--work-dir", default=".hf_tmp/luna16")
+    parser.add_argument("--staging-root", default=".hf_tmp")
+    parser.add_argument("--lock-file", default=".hf_tmp/collection.lock")
     parser.add_argument("--max-local-gb", type=float, default=20.0)
+    parser.add_argument("--min-free-gb", type=float, default=100.0)
     parser.add_argument("--subset", type=int, choices=range(10), action="append")
-    parser.add_argument("--max-cases", type=int, default=None)
+    parser.add_argument("--max-cases", type=int, default=1)
     parser.add_argument("--start-index", type=int, default=None)
+    parser.add_argument("--policy-file", type=Path, default=Path("manifests/source_datasets.csv"))
+    parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Actually download and upload. Without this flag, print a plan only.",
+    )
     args = parser.parse_args()
 
-    token = get_token()
-    api = HfApi(token=token)
-    repo_id = args.repo_id or default_repo_id(api, token, args.repo_name)
+    if args.max_cases <= 0:
+        parser.error("--max-cases must be positive")
+
+    budget = StorageBudget.from_gib(
+        Path(args.staging_root),
+        max_local_gib=args.max_local_gb,
+        min_free_gib=args.min_free_gb,
+    )
     work_dir = Path(args.work_dir).resolve()
     work_dir.mkdir(parents=True, exist_ok=True)
     subsets = args.subset if args.subset is not None else list(range(10))
-    existing = existing_indices(api, repo_id, args.dataset_name, token)
-    index = args.start_index or ((max(existing) + 1) if existing else 1)
-    processed = 0
-    manifest_path = Path("manifests") / f"{args.dataset_name}.jsonl"
-    processed_source_uids = read_manifest_values(manifest_path, "source_series_uid")
-
-    for subset_id in subsets:
-        if args.max_cases is not None and processed >= args.max_cases:
-            break
-        url, expected_md5 = LUNA16_FILES[subset_id]
-        with tempfile.TemporaryDirectory(dir=work_dir) as tmp:
-            tmp_dir = Path(tmp)
-            zip_path = tmp_dir / f"subset{subset_id}.zip"
-            extract_dir = tmp_dir / "extract"
-            download(url, zip_path)
-            enforce_staging_limit(work_dir, args.max_local_gb)
-            actual_md5 = md5_file(zip_path)
-            if actual_md5 != expected_md5:
-                raise RuntimeError(f"MD5 mismatch for subset{subset_id}: {actual_md5} != {expected_md5}")
-
-            with zipfile.ZipFile(zip_path) as zf:
-                zf.extractall(extract_dir)
-            enforce_staging_limit(work_dir, args.max_local_gb)
-
-            mhd_files = sorted(extract_dir.rglob("*.mhd"))
-            for mhd_path in mhd_files:
-                if args.max_cases is not None and processed >= args.max_cases:
-                    break
-                fields = parse_mhd(mhd_path)
-                raw_name = fields["ElementDataFile"]
-                raw_path = mhd_path.parent / raw_name
-                if not raw_path.exists():
-                    raise RuntimeError(f"Missing raw file {raw_path}")
-                if mhd_path.stem in processed_source_uids:
-                    continue
-
-                folder_name = f"{args.dataset_name}_{index:08d}"
-                case_dir = tmp_dir / folder_name
-                case_dir.mkdir(parents=True, exist_ok=True)
-                ct_path = case_dir / "ct.nii.gz"
-                conversion = convert_mhd_to_nifti(mhd_path, raw_path, ct_path)
-                digest = sha256_file(ct_path)
-                size_bytes = ct_path.stat().st_size
-
-                api.upload_folder(
-                    repo_id=repo_id,
-                    repo_type="dataset",
-                    folder_path=str(case_dir),
-                    path_in_repo=f"data/{folder_name}",
-                    token=token,
-                    commit_message=f"Add {folder_name}",
-                )
-                row = {
-                    "dataset": args.dataset_name,
-                    "folder": folder_name,
-                    "path": f"data/{folder_name}/ct.nii.gz",
-                    "source": "LUNA16",
-                    "source_subset": subset_id,
-                    "source_series_uid": mhd_path.stem,
-                    "source_mhd": str(mhd_path.relative_to(extract_dir)),
-                    "sha256": digest,
-                    "size_bytes": size_bytes,
-                    **conversion,
-                }
-                append_jsonl(manifest_path, row)
-                processed_source_uids.add(mhd_path.stem)
-                api.upload_file(
-                    repo_id=repo_id,
-                    repo_type="dataset",
-                    path_or_fileobj=str(manifest_path),
-                    path_in_repo=f"manifests/{args.dataset_name}.jsonl",
-                    token=token,
-                    commit_message=f"Update {args.dataset_name} manifest",
-                )
-                shutil.rmtree(case_dir, ignore_errors=True)
-                processed += 1
-                index += 1
-
-    enforce_staging_limit(work_dir, args.max_local_gb)
-    print(f"Uploaded {processed} {args.dataset_name} cases to {repo_id}")
+
+    if not args.execute:
+        print(
+            f"DRY RUN: subsets={subsets}; would process at most {args.max_cases} case(s); "
+            f"staging cap={args.max_local_gb:.1f} GiB; free-space reserve={args.min_free_gb:.1f} GiB."
+        )
+        print("Re-run with --execute to download and upload. No archive was downloaded.")
+        return
+
+    assert_mirroring_policy(args.dataset_name, args.policy_file)
+    token = get_token()
+    api = HfApi(token=token)
+    repo_id = args.repo_id or default_repo_id(api, token, args.repo_name)
+
+    with exclusive_collection_lock(Path(args.lock_file)):
+        budget.check(context="starting LUNA16 collection")
+        manifest_path = Path("manifests") / f"{args.dataset_name}.jsonl"
+        manifest_rows = sync_remote_manifest(repo_id, args.dataset_name, token, manifest_path)
+        processed_source_uids = {
+            str(row["source_series_uid"])
+            for row in manifest_rows
+            if row.get("source_series_uid")
+        }
+        if len(processed_source_uids) != len(manifest_rows):
+            raise RuntimeError("Manifest contains missing or duplicate source_series_uid values")
+
+        existing = existing_indices(api, repo_id, args.dataset_name, token)
+        manifested_indices = {
+            int(match.group(1))
+            for row in manifest_rows
+            if (match := re.fullmatch(rf"{re.escape(args.dataset_name)}_(\d{{8}})", str(row.get("folder", ""))))
+        }
+        orphan_data = existing - manifested_indices
+        missing_data = manifested_indices - existing
+        if orphan_data or missing_data:
+            raise RuntimeError(
+                "Remote data/manifest mismatch; refusing automatic resume. "
+                f"orphan data indices={sorted(orphan_data)}, missing data indices={sorted(missing_data)}"
+            )
+
+        index = args.start_index or ((max(existing) + 1) if existing else 1)
+        if index in existing:
+            raise RuntimeError(f"Requested start index {index} already exists")
+        processed = 0
+
+        for subset_id in subsets:
+            if processed >= args.max_cases:
+                break
+            budget.check(context=f"starting LUNA16 subset{subset_id}")
+            url, expected_md5 = LUNA16_FILES[subset_id]
+            with tempfile.TemporaryDirectory(dir=work_dir) as tmp:
+                tmp_dir = Path(tmp)
+                zip_path = tmp_dir / f"subset{subset_id}.zip"
+                download(url, zip_path, budget)
+                actual_md5 = md5_file(zip_path)
+                if actual_md5 != expected_md5:
+                    raise RuntimeError(
+                        f"MD5 mismatch for subset{subset_id}: {actual_md5} != {expected_md5}"
+                    )
+
+                with zipfile.ZipFile(zip_path) as zf:
+                    members = luna_members(zf)
+                    if not members:
+                        raise RuntimeError(f"No MHD files found in subset{subset_id}")
+                    for mhd_member in members:
+                        if processed >= args.max_cases:
+                            break
+                        source_uid = PurePosixPath(mhd_member).stem
+                        if source_uid in processed_source_uids:
+                            continue
+
+                        fields, raw_member = mhd_and_raw_member(zf, mhd_member)
+                        folder_name = f"{args.dataset_name}_{index:08d}"
+                        with tempfile.TemporaryDirectory(dir=tmp_dir, prefix="case-") as case_tmp:
+                            case_tmp_dir = Path(case_tmp)
+                            raw_path = case_tmp_dir / PurePosixPath(raw_member).name
+                            case_dir = case_tmp_dir / folder_name
+                            case_dir.mkdir(parents=True, exist_ok=True)
+                            ct_path = case_dir / "ct.nii.gz"
+
+                            extract_member_bounded(zf, raw_member, raw_path, budget)
+                            conversion = convert_mhd_fields_to_nifti(
+                                fields, raw_path, ct_path, budget
+                            )
+                            digest = sha256_file(ct_path)
+                            size_bytes = ct_path.stat().st_size
+                            row = {
+                                "dataset": args.dataset_name,
+                                "folder": folder_name,
+                                "path": f"data/{folder_name}/ct.nii.gz",
+                                "source": "LUNA16",
+                                "source_subset": subset_id,
+                                "source_series_uid": source_uid,
+                                "source_mhd": mhd_member,
+                                "sha256": digest,
+                                "size_bytes": size_bytes,
+                                **conversion,
+                            }
+
+                            original_digest = sha256_file(manifest_path) if manifest_path.exists() else None
+                            candidate = create_manifest_candidate(manifest_path, manifest_rows, row)
+                            try:
+                                api.create_commit(
+                                    repo_id=repo_id,
+                                    repo_type="dataset",
+                                    token=token,
+                                    commit_message=f"Add {folder_name} with manifest",
+                                    operations=[
+                                        CommitOperationAdd(
+                                            path_in_repo=f"data/{folder_name}/ct.nii.gz",
+                                            path_or_fileobj=str(ct_path),
+                                        ),
+                                        CommitOperationAdd(
+                                            path_in_repo=f"manifests/{args.dataset_name}.jsonl",
+                                            path_or_fileobj=str(candidate),
+                                        ),
+                                    ],
+                                )
+                                current_digest = (
+                                    sha256_file(manifest_path) if manifest_path.exists() else None
+                                )
+                                if current_digest != original_digest:
+                                    raise RuntimeError(
+                                        "Remote commit succeeded, but the local manifest changed "
+                                        "concurrently; leaving it untouched for reconciliation."
+                                    )
+                                os.replace(candidate, manifest_path)
+                            finally:
+                                candidate.unlink(missing_ok=True)
+
+                        manifest_rows.append(row)
+                        processed_source_uids.add(source_uid)
+                        processed += 1
+                        index += 1
+                        budget.check(context="finishing LUNA16 case")
+
+        print(f"Uploaded {processed} {args.dataset_name} case(s) to {repo_id}")
 
 
 if __name__ == "__main__":

scripts/storage_guard.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Shared, fail-closed storage guards for collection scripts.
+
+The guards enforce both a workspace staging cap and a filesystem free-space
+reserve.  Checks happen before and during writes so a misleading or missing
+Content-Length cannot fill the disk.  A workspace-wide advisory lock prevents
+the bundled collectors from staging large archives concurrently.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import os
+import shutil
+import zipfile
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import BinaryIO, Callable, Iterator
+
+
+GIB = 1024**3
+COPY_CHUNK_BYTES = 1024 * 1024
+
+
+class StorageLimitError(RuntimeError):
+    """Raised before a write would violate a configured storage limit."""
+
+
+def bytes_in_tree(path: Path) -> int:
+    """Return allocated file sizes below *path* without following symlinks."""
+
+    if not path.exists():
+        return 0
+    total = 0
+    for item in path.rglob("*"):
+        if item.is_file() and not item.is_symlink():
+            total += item.stat().st_size
+    return total
+
+
+@dataclass(frozen=True)
+class StorageBudget:
+    """A staging-directory cap plus a whole-filesystem free-space reserve."""
+
+    staging_root: Path
+    max_local_bytes: int
+    min_free_bytes: int
+
+    @classmethod
+    def from_gib(
+        cls,
+        staging_root: Path,
+        max_local_gib: float,
+        min_free_gib: float,
+    ) -> "StorageBudget":
+        if max_local_gib <= 0:
+            raise ValueError("max_local_gib must be positive")
+        if min_free_gib < 0:
+            raise ValueError("min_free_gib cannot be negative")
+        root = staging_root.resolve()
+        root.mkdir(parents=True, exist_ok=True)
+        return cls(
+            staging_root=root,
+            max_local_bytes=int(max_local_gib * GIB),
+            min_free_bytes=int(min_free_gib * GIB),
+        )
+
+    def check(self, additional_bytes: int = 0, context: str = "operation") -> None:
+        """Fail if writing *additional_bytes* would exceed either limit."""
+
+        if additional_bytes < 0:
+            raise ValueError("additional_bytes cannot be negative")
+        staged = bytes_in_tree(self.staging_root)
+        if staged + additional_bytes > self.max_local_bytes:
+            raise StorageLimitError(
+                f"Refusing {context}: staging would use "
+                f"{(staged + additional_bytes) / GIB:.2f} GiB, above the "
+                f"{self.max_local_bytes / GIB:.2f} GiB cap at {self.staging_root}."
+            )
+
+        free = shutil.disk_usage(self.staging_root).free
+        if free - additional_bytes < self.min_free_bytes:
+            raise StorageLimitError(
+                f"Refusing {context}: projected filesystem free space is "
+                f"{max(0, free - additional_bytes) / GIB:.2f} GiB, below the "
+                f"{self.min_free_bytes / GIB:.2f} GiB reserve."
+            )
+
+
+def copy_bounded(
+    source: BinaryIO,
+    destination: Path,
+    budget: StorageBudget,
+    *,
+    expected_bytes: int | None = None,
+    context: str = "write",
+    on_chunk: Callable[[int], None] | None = None,
+) -> int:
+    """Copy a binary stream while checking the budget before every chunk."""
+
+    if expected_bytes is not None:
+        budget.check(expected_bytes, context=context)
+    else:
+        budget.check(context=context)
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    written = 0
+    try:
+        with destination.open("wb") as output:
+            while True:
+                chunk = source.read(COPY_CHUNK_BYTES)
+                if not chunk:
+                    break
+                budget.check(len(chunk), context=context)
+                output.write(chunk)
+                written += len(chunk)
+                if on_chunk is not None:
+                    on_chunk(len(chunk))
+    except BaseException:
+        destination.unlink(missing_ok=True)
+        raise
+
+    if expected_bytes is not None and written != expected_bytes:
+        destination.unlink(missing_ok=True)
+        raise RuntimeError(
+            f"Incomplete {context}: wrote {written} bytes, expected {expected_bytes}."
+        )
+    return written
+
+
+def validated_zip_member(zf: zipfile.ZipFile, member_name: str) -> zipfile.ZipInfo:
+    """Resolve a regular ZIP member and reject traversal or link-like entries."""
+
+    path = PurePosixPath(member_name)
+    if path.is_absolute() or ".." in path.parts:
+        raise RuntimeError(f"Unsafe ZIP member path: {member_name}")
+    info = zf.getinfo(member_name)
+    if info.is_dir():
+        raise RuntimeError(f"Expected a file, found ZIP directory: {member_name}")
+    unix_mode = info.external_attr >> 16
+    if unix_mode and (unix_mode & 0o170000) not in (0, 0o100000):
+        raise RuntimeError(f"Refusing non-regular ZIP member: {member_name}")
+    return info
+
+
+def extract_member_bounded(
+    zf: zipfile.ZipFile,
+    member_name: str,
+    destination: Path,
+    budget: StorageBudget,
+) -> int:
+    """Extract one regular ZIP member with traversal and storage checks."""
+
+    info = validated_zip_member(zf, member_name)
+    with zf.open(info, "r") as source:
+        return copy_bounded(
+            source,
+            destination,
+            budget,
+            expected_bytes=info.file_size,
+            context=f"extracting {member_name}",
+        )
+
+
+@contextmanager
+def exclusive_collection_lock(lock_path: Path) -> Iterator[None]:
+    """Prevent bundled collectors from running large staging jobs together."""
+
+    path = lock_path.resolve()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a+", encoding="utf-8") as lock_file:
+        try:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError as exc:
+            lock_file.seek(0)
+            owner = lock_file.read().strip() or "another process"
+            raise RuntimeError(f"Collection lock {path} is held by {owner}.") from exc
+
+        lock_file.seek(0)
+        lock_file.truncate()
+        lock_file.write(f"pid={os.getpid()}")
+        lock_file.flush()
+        try:
+            yield
+        finally:
+            lock_file.seek(0)
+            lock_file.truncate()
+            lock_file.flush()
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)

scripts/tcia_collect_upload.py

@@ -18,19 +18,33 @@ import hashlib
 import json
 import os
 import re
-import shutil
 import tempfile
 import zipfile
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Iterable
 
 import nibabel as nib
 import numpy as np
 import requests
-from huggingface_hub import HfApi
+from huggingface_hub import CommitOperationAdd, HfApi
 from tqdm import tqdm
 
+try:
+    from .storage_guard import (
+        StorageBudget,
+        copy_bounded,
+        exclusive_collection_lock,
+        extract_member_bounded,
+    )
+except ImportError:  # Support `python scripts/tcia_collect_upload.py`.
+    from storage_guard import (  # type: ignore[no-redef]
+        StorageBudget,
+        copy_bounded,
+        exclusive_collection_lock,
+        extract_member_bounded,
+    )
+
 try:
     import pydicom
 except ImportError as exc:  # pragma: no cover - dependency guard
@@ -73,26 +87,6 @@ def default_repo_id(api: HfApi, token: str, repo_name: str) -> str:
     return f"{namespace}/{repo_name}"
 
 
-def bytes_in_tree(path: Path) -> int:
-    if not path.exists():
-        return 0
-    total = 0
-    for item in path.rglob("*"):
-        if item.is_file():
-            total += item.stat().st_size
-    return total
-
-
-def enforce_staging_limit(path: Path, max_local_gb: float) -> None:
-    used = bytes_in_tree(path)
-    limit = int(max_local_gb * 1024**3)
-    if used > limit:
-        raise RuntimeError(
-            f"Staging directory {path} uses {used / 1024**3:.2f} GiB, "
-            f"above the configured {max_local_gb:.2f} GiB limit."
-        )
-
-
 def request_json(endpoint: str, params: dict[str, str | int]) -> list[dict]:
     resp = requests.get(f"{TCIA_BASE}/{endpoint}", params=params, timeout=120)
     resp.raise_for_status()
@@ -119,10 +113,7 @@ def load_series(collection: str, modality: str = "CT") -> list[SeriesInfo]:
 
 
 def existing_indices(api: HfApi, repo_id: str, repo_type: str, dataset_name: str, token: str) -> set[int]:
-    try:
-        files = api.list_repo_files(repo_id=repo_id, repo_type=repo_type, token=token)
-    except Exception:
-        return set()
+    files = api.list_repo_files(repo_id=repo_id, repo_type=repo_type, token=token)
     pattern = re.compile(rf"^data/{re.escape(dataset_name)}_(\d{{8}})/ct\.nii\.gz$")
     indices: set[int] = set()
     for path in files:
@@ -138,27 +129,39 @@ def next_index(existing: set[int], requested_start: int | None = None) -> int:
     return (max(existing) + 1) if existing else 1
 
 
-def download_series_zip(series_uid: str, out_path: Path) -> None:
+def download_series_zip(series_uid: str, out_path: Path, budget: StorageBudget) -> None:
     params = {"SeriesInstanceUID": series_uid}
     with requests.get(f"{TCIA_BASE}/getImage", params=params, stream=True, timeout=300) as resp:
         resp.raise_for_status()
         total = int(resp.headers.get("content-length") or 0)
-        with out_path.open("wb") as f, tqdm(
+        with tqdm(
             total=total,
             unit="B",
             unit_scale=True,
             desc=f"download {series_uid[-12:]}",
+            mininterval=10.0,
         ) as bar:
-            for chunk in resp.iter_content(chunk_size=1024 * 1024):
-                if chunk:
-                    f.write(chunk)
-                    bar.update(len(chunk))
+            copy_bounded(
+                resp.raw,
+                out_path,
+                budget,
+                expected_bytes=total or None,
+                context=f"downloading TCIA series {series_uid}",
+                on_chunk=bar.update,
+            )
 
 
-def extract_zip(zip_path: Path, out_dir: Path) -> list[Path]:
+def extract_zip(zip_path: Path, out_dir: Path, budget: StorageBudget) -> list[Path]:
+    files: list[Path] = []
     with zipfile.ZipFile(zip_path) as zf:
-        zf.extractall(out_dir)
-    return [p for p in out_dir.rglob("*") if p.is_file()]
+        for info in zf.infolist():
+            if info.is_dir():
+                continue
+            rel = PurePosixPath(info.filename)
+            target = out_dir.joinpath(*rel.parts)
+            extract_member_bounded(zf, info.filename, target, budget)
+            files.append(target)
+    return files
 
 
 def read_dicom_slices(paths: Iterable[Path]) -> list:
@@ -185,7 +188,11 @@ def slice_position(ds, normal: np.ndarray) -> float:
     return float(getattr(ds, "InstanceNumber", 0))
 
 
-def dicom_to_nifti(dicom_paths: Iterable[Path], out_path: Path) -> dict[str, object]:
+def dicom_to_nifti(
+    dicom_paths: Iterable[Path],
+    out_path: Path,
+    budget: StorageBudget | None = None,
+) -> dict[str, object]:
     slices = read_dicom_slices(dicom_paths)
     first = slices[0]
     orientation = np.asarray([float(v) for v in first.ImageOrientationPatient], dtype=float)
@@ -198,6 +205,7 @@ def dicom_to_nifti(dicom_paths: Iterable[Path], out_path: Path) -> dict[str, obj
     normal = normal / norm
 
     slices.sort(key=lambda ds: slice_position(ds, normal))
+    first = slices[0]
     positions = [slice_position(ds, normal) for ds in slices]
     diffs = np.diff(positions)
     if len(diffs):
@@ -235,6 +243,9 @@ def dicom_to_nifti(dicom_paths: Iterable[Path], out_path: Path) -> dict[str, obj
     image.header.set_xyzt_units("mm")
     image.header["cal_min"] = float(np.nanmin(data))
     image.header["cal_max"] = float(np.nanmax(data))
+    if budget is not None:
+        worst_case_bytes = int(data.nbytes * 1.01) + 1024 * 1024
+        budget.check(worst_case_bytes, context="writing converted TCIA NIfTI")
     nib.save(image, str(out_path))
 
     return {
@@ -253,31 +264,131 @@ def sha256_file(path: Path) -> str:
     return h.hexdigest()
 
 
-def append_jsonl(path: Path, row: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(row, sort_keys=True) + "\n")
-
-
-def read_manifest_values(path: Path, key: str) -> set[str]:
+def read_manifest_rows(path: Path) -> list[dict]:
     if not path.exists():
-        return set()
-    values: set[str] = set()
+        return []
+    rows: list[dict] = []
     with path.open("r", encoding="utf-8") as f:
-        for line in f:
+        for line_number, line in enumerate(f, start=1):
             line = line.strip()
             if not line:
                 continue
             try:
                 row = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            value = row.get(key)
-            if value:
-                values.add(str(value))
+            except json.JSONDecodeError as exc:
+                raise RuntimeError(f"Invalid JSON in {path}:{line_number}: {exc}") from exc
+            if not isinstance(row, dict):
+                raise RuntimeError(f"Expected an object in {path}:{line_number}")
+            rows.append(row)
+    return rows
+
+
+def sync_remote_manifest(
+    repo_id: str,
+    dataset_name: str,
+    token: str,
+    local_path: Path,
+) -> list[dict]:
+    """Use the remote manifest as authority and refuse divergent local state."""
+
+    remote_path = f"manifests/{dataset_name}.jsonl"
+    url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{remote_path}"
+    response = requests.get(url, headers={"Authorization": f"Bearer {token}"}, timeout=120)
+    if response.status_code == 404:
+        return read_manifest_rows(local_path)
+    response.raise_for_status()
+
+    remote_rows: list[dict] = []
+    for line_number, line in enumerate(response.text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(
+                f"Invalid JSON in remote {remote_path}:{line_number}: {exc}"
+            ) from exc
+        if not isinstance(row, dict):
+            raise RuntimeError(f"Expected an object in remote {remote_path}:{line_number}")
+        remote_rows.append(row)
+
+    local_rows = read_manifest_rows(local_path)
+    remote_uids = {str(row.get("source_series_uid")) for row in remote_rows}
+    local_only = {
+        str(row.get("source_series_uid"))
+        for row in local_rows
+        if str(row.get("source_series_uid")) not in remote_uids
+    }
+    if local_only:
+        raise RuntimeError(
+            f"Local manifest has {len(local_only)} source UID(s) absent from the remote manifest; "
+            "refusing to overwrite divergent state."
+        )
+
+    canonical = "".join(json.dumps(row, sort_keys=True) + "\n" for row in remote_rows)
+    current = local_path.read_text(encoding="utf-8") if local_path.exists() else ""
+    if canonical != current:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=local_path.parent,
+            prefix=f".{local_path.name}.",
+            suffix=".sync",
+            delete=False,
+        ) as tmp:
+            tmp.write(canonical)
+            tmp_path = Path(tmp.name)
+        os.replace(tmp_path, local_path)
+    return remote_rows
+
+
+def create_manifest_candidate(path: Path, rows: list[dict], row: dict) -> Path:
+    """Create the next manifest beside the canonical file for an atomic swap."""
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        suffix=".pending",
+        delete=False,
+    ) as tmp:
+        for existing in rows:
+            tmp.write(json.dumps(existing, sort_keys=True) + "\n")
+        tmp.write(json.dumps(row, sort_keys=True) + "\n")
+        return Path(tmp.name)
+
+
+def read_series_allowlist(path: Path) -> set[str]:
+    """Read a CSV with a required `series_uid` column."""
+
+    with path.open(newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        if not reader.fieldnames or "series_uid" not in reader.fieldnames:
+            raise RuntimeError(f"{path} must contain a series_uid column")
+        values = {str(row["series_uid"]).strip() for row in reader if row.get("series_uid")}
+    if not values:
+        raise RuntimeError(f"{path} contains no series UIDs")
     return values
 
 
+def assert_mirroring_policy(dataset_name: str, policy_path: Path) -> None:
+    """Fail closed unless the source registry explicitly permits mirroring."""
+
+    with policy_path.open(newline="", encoding="utf-8") as f:
+        rows = {row["dataset"]: row for row in csv.DictReader(f)}
+    if dataset_name not in rows:
+        raise RuntimeError(f"{dataset_name} is not present in {policy_path}")
+    policy = rows[dataset_name].get("mirror_policy", "")
+    allowed = {"mirror_allowed_with_attribution", "mirror_selected_public_ct_with_attribution"}
+    if policy not in allowed:
+        raise RuntimeError(
+            f"Refusing to mirror {dataset_name}: registry policy is {policy!r}, not an allowed policy."
+        )
+
+
 def write_series_catalog(path: Path, series: list[SeriesInfo]) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     with path.open("w", newline="", encoding="utf-8") as f:
@@ -299,113 +410,196 @@ def write_series_catalog(path: Path, series: list[SeriesInfo]) -> None:
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(
+        description="Catalog TCIA series or upload a bounded, policy-approved batch."
+    )
     parser.add_argument("--collection", required=True, help="TCIA collection name, e.g. LIDC-IDRI.")
     parser.add_argument("--dataset-name", required=True, help="Folder prefix, e.g. LIDC-IDRI.")
     parser.add_argument("--repo-id", default=None)
     parser.add_argument("--repo-name", default="SUMI-OpenCT")
     parser.add_argument("--work-dir", default=".hf_tmp/tcia")
-    parser.add_argument("--max-local-gb", type=float, default=25.0)
-    parser.add_argument("--max-cases", type=int, default=None)
+    parser.add_argument("--staging-root", default=".hf_tmp")
+    parser.add_argument("--lock-file", default=".hf_tmp/collection.lock")
+    parser.add_argument("--max-local-gb", type=float, default=20.0)
+    parser.add_argument("--min-free-gb", type=float, default=100.0)
+    parser.add_argument(
+        "--max-cases",
+        type=int,
+        default=1,
+        help="Bounded batch size; defaults to one case.",
+    )
     parser.add_argument("--start-index", type=int, default=None)
-    parser.add_argument("--skip-existing", action="store_true")
+    parser.add_argument("--series-allowlist", type=Path, default=None)
+    parser.add_argument("--policy-file", type=Path, default=Path("manifests/source_datasets.csv"))
     parser.add_argument("--metadata-only", action="store_true")
+    parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Actually upload. Without this flag, the command only prepares local metadata and a plan.",
+    )
     args = parser.parse_args()
 
-    token = get_token()
-    api = HfApi(token=token)
-    repo_id = args.repo_id or default_repo_id(api, token, args.repo_name)
-    work_dir = Path(args.work_dir).resolve() / args.dataset_name
-    work_dir.mkdir(parents=True, exist_ok=True)
+    if args.max_cases <= 0:
+        parser.error("--max-cases must be positive")
+    if args.dataset_name.upper() == "NLST" and not args.metadata_only and args.series_allowlist is None:
+        parser.error("NLST data collection requires --series-allowlist; full-collection download is forbidden")
 
-    series = load_series(args.collection)
-    catalog_path = Path("manifests") / f"{args.dataset_name}_tcia_series.csv"
-    write_series_catalog(catalog_path, series)
-    api.upload_file(
-        repo_id=repo_id,
-        repo_type="dataset",
-        path_or_fileobj=str(catalog_path),
-        path_in_repo=f"manifests/{catalog_path.name}",
-        token=token,
-        commit_message=f"Add {args.dataset_name} TCIA series catalog",
+    budget = StorageBudget.from_gib(
+        Path(args.staging_root),
+        max_local_gib=args.max_local_gb,
+        min_free_gib=args.min_free_gb,
     )
-    if args.metadata_only:
-        print(f"Wrote metadata for {len(series)} series")
-        return
-
-    existing = existing_indices(api, repo_id, "dataset", args.dataset_name, token)
-    index = next_index(existing, args.start_index)
-    processed = 0
-    manifest_path = Path("manifests") / f"{args.dataset_name}.jsonl"
-    processed_source_uids = read_manifest_values(manifest_path, "source_series_uid")
-
-    for item in series:
-        if args.max_cases is not None and processed >= args.max_cases:
-            break
-        if item.series_uid in processed_source_uids:
-            continue
-        if args.skip_existing and index in existing:
-            index += 1
-            continue
+    work_dir = Path(args.work_dir).resolve() / args.dataset_name
+    work_dir.mkdir(parents=True, exist_ok=True)
 
-        folder_name = f"{args.dataset_name}_{index:08d}"
-        with tempfile.TemporaryDirectory(dir=work_dir) as tmp:
-            tmp_dir = Path(tmp)
-            zip_path = tmp_dir / "series.zip"
-            extract_dir = tmp_dir / "dicom"
-            case_dir = tmp_dir / folder_name
-            case_dir.mkdir(parents=True, exist_ok=True)
-            ct_path = case_dir / "ct.nii.gz"
-
-            download_series_zip(item.series_uid, zip_path)
-            enforce_staging_limit(work_dir, args.max_local_gb)
-            dicom_files = extract_zip(zip_path, extract_dir)
-            enforce_staging_limit(work_dir, args.max_local_gb)
-            conversion = dicom_to_nifti(dicom_files, ct_path)
-            digest = sha256_file(ct_path)
-            size_bytes = ct_path.stat().st_size
-
-            api.upload_folder(
-                repo_id=repo_id,
-                repo_type="dataset",
-                folder_path=str(case_dir),
-                path_in_repo=f"data/{folder_name}",
-                token=token,
-                commit_message=f"Add {folder_name}",
+    with exclusive_collection_lock(Path(args.lock_file)):
+        budget.check(context="starting TCIA collection")
+        all_series = load_series(args.collection)
+        catalog_path = Path("manifests") / f"{args.dataset_name}_tcia_series.csv"
+        write_series_catalog(catalog_path, all_series)
+
+        selected_series = all_series
+        if args.series_allowlist is not None:
+            allowed_uids = read_series_allowlist(args.series_allowlist)
+            by_uid = {item.series_uid: item for item in all_series}
+            missing = allowed_uids - by_uid.keys()
+            if missing:
+                raise RuntimeError(
+                    f"Allowlist contains {len(missing)} UID(s) absent from TCIA collection {args.collection}."
+                )
+            selected_series = [item for item in all_series if item.series_uid in allowed_uids]
+
+        if not args.execute:
+            local_rows = read_manifest_rows(Path("manifests") / f"{args.dataset_name}.jsonl")
+            completed = {str(row.get("source_series_uid")) for row in local_rows}
+            pending = [item for item in selected_series if item.series_uid not in completed]
+            print(
+                f"DRY RUN: cataloged {len(all_series)} series; selected {len(selected_series)}; "
+                f"pending {len(pending)}; would process at most {min(args.max_cases, len(pending))}."
             )
-
-            row = {
-                "dataset": args.dataset_name,
-                "folder": folder_name,
-                "path": f"data/{folder_name}/ct.nii.gz",
-                "source_collection": item.collection,
-                "source_patient_id": item.patient_id,
-                "source_study_uid": item.study_uid,
-                "source_series_uid": item.series_uid,
-                "source_image_count": item.image_count,
-                "source_manufacturer": item.manufacturer,
-                "source_model": item.model,
-                "sha256": digest,
-                "size_bytes": size_bytes,
-                **conversion,
-            }
-            append_jsonl(manifest_path, row)
-            processed_source_uids.add(item.series_uid)
-            api.upload_file(
-                repo_id=repo_id,
-                repo_type="dataset",
-                path_or_fileobj=str(manifest_path),
-                path_in_repo=f"manifests/{args.dataset_name}.jsonl",
-                token=token,
-                commit_message=f"Update {args.dataset_name} manifest",
+            print("Re-run with --execute to upload. No scan data was downloaded.")
+            return
+
+        if not args.metadata_only:
+            assert_mirroring_policy(args.dataset_name, args.policy_file)
+        token = get_token()
+        api = HfApi(token=token)
+        repo_id = args.repo_id or default_repo_id(api, token, args.repo_name)
+        api.upload_file(
+            repo_id=repo_id,
+            repo_type="dataset",
+            path_or_fileobj=str(catalog_path),
+            path_in_repo=f"manifests/{catalog_path.name}",
+            token=token,
+            commit_message=f"Update {args.dataset_name} TCIA series catalog",
+        )
+        if args.metadata_only:
+            print(f"Uploaded metadata for {len(all_series)} series to {repo_id}")
+            return
+
+        manifest_path = Path("manifests") / f"{args.dataset_name}.jsonl"
+        manifest_rows = sync_remote_manifest(repo_id, args.dataset_name, token, manifest_path)
+        processed_source_uids = {
+            str(row["source_series_uid"])
+            for row in manifest_rows
+            if row.get("source_series_uid")
+        }
+        if len(processed_source_uids) != len(manifest_rows):
+            raise RuntimeError("Manifest contains missing or duplicate source_series_uid values")
+
+        existing = existing_indices(api, repo_id, "dataset", args.dataset_name, token)
+        manifested_indices = {
+            int(match.group(1))
+            for row in manifest_rows
+            if (match := re.fullmatch(rf"{re.escape(args.dataset_name)}_(\d{{8}})", str(row.get("folder", ""))))
+        }
+        orphan_data = existing - manifested_indices
+        missing_data = manifested_indices - existing
+        if orphan_data or missing_data:
+            raise RuntimeError(
+                "Remote data/manifest mismatch; refusing automatic resume. "
+                f"orphan data indices={sorted(orphan_data)}, missing data indices={sorted(missing_data)}"
             )
 
-        shutil.rmtree(work_dir / "__pycache__", ignore_errors=True)
-        processed += 1
-        index += 1
-        enforce_staging_limit(work_dir, args.max_local_gb)
+        index = next_index(existing, args.start_index)
+        if index in existing:
+            raise RuntimeError(f"Requested start index {index} already exists")
+
+        processed = 0
+        for item in selected_series:
+            if processed >= args.max_cases:
+                break
+            if item.series_uid in processed_source_uids:
+                continue
+
+            budget.check(context=f"starting {item.series_uid}")
+            folder_name = f"{args.dataset_name}_{index:08d}"
+            with tempfile.TemporaryDirectory(dir=work_dir) as tmp:
+                tmp_dir = Path(tmp)
+                zip_path = tmp_dir / "series.zip"
+                extract_dir = tmp_dir / "dicom"
+                case_dir = tmp_dir / folder_name
+                case_dir.mkdir(parents=True, exist_ok=True)
+                ct_path = case_dir / "ct.nii.gz"
+
+                download_series_zip(item.series_uid, zip_path, budget)
+                dicom_files = extract_zip(zip_path, extract_dir, budget)
+                conversion = dicom_to_nifti(dicom_files, ct_path, budget)
+                digest = sha256_file(ct_path)
+                size_bytes = ct_path.stat().st_size
+
+                row = {
+                    "dataset": args.dataset_name,
+                    "folder": folder_name,
+                    "path": f"data/{folder_name}/ct.nii.gz",
+                    "source_collection": item.collection,
+                    "source_patient_id": item.patient_id,
+                    "source_study_uid": item.study_uid,
+                    "source_series_uid": item.series_uid,
+                    "source_image_count": item.image_count,
+                    "source_manufacturer": item.manufacturer,
+                    "source_model": item.model,
+                    "sha256": digest,
+                    "size_bytes": size_bytes,
+                    **conversion,
+                }
+                original_digest = sha256_file(manifest_path) if manifest_path.exists() else None
+                candidate = create_manifest_candidate(manifest_path, manifest_rows, row)
+                try:
+                    api.create_commit(
+                        repo_id=repo_id,
+                        repo_type="dataset",
+                        token=token,
+                        commit_message=f"Add {folder_name} with manifest",
+                        operations=[
+                            CommitOperationAdd(
+                                path_in_repo=f"data/{folder_name}/ct.nii.gz",
+                                path_or_fileobj=str(ct_path),
+                            ),
+                            CommitOperationAdd(
+                                path_in_repo=f"manifests/{args.dataset_name}.jsonl",
+                                path_or_fileobj=str(candidate),
+                            ),
+                        ],
+                    )
+                    current_digest = sha256_file(manifest_path) if manifest_path.exists() else None
+                    if current_digest != original_digest:
+                        raise RuntimeError(
+                            "Remote commit succeeded, but the local manifest changed concurrently; "
+                            "leaving it untouched for reconciliation on the next run."
+                        )
+                    os.replace(candidate, manifest_path)
+                finally:
+                    candidate.unlink(missing_ok=True)
+
+                manifest_rows.append(row)
+                processed_source_uids.add(item.series_uid)
+
+            processed += 1
+            index += 1
+            budget.check(context="finishing TCIA case")
 
-    print(f"Uploaded {processed} {args.dataset_name} cases to {repo_id}")
+        print(f"Uploaded {processed} {args.dataset_name} case(s) to {repo_id}")
 
 
 if __name__ == "__main__":