TranslatorSRI
diff --git a/‎CLAUDE.md‎
Lines changed: 43 additions & 1 deletion b/‎CLAUDE.md‎
Lines changed: 43 additions & 1 deletion
diff --git a/‎tests/conftest.py‎
Lines changed: 71 additions & 18 deletions b/‎tests/conftest.py‎
Lines changed: 71 additions & 18 deletions
diff --git a/‎tests/data/valid_curies.txt‎
Lines changed: 4 additions & 1 deletion b/‎tests/data/valid_curies.txt‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎tests/test_downloader.py‎
Lines changed: 122 additions & 3 deletions b/‎tests/test_downloader.py‎
Lines changed: 122 additions & 3 deletions
@@ -184,8 +184,15 @@ uv run pytest -v -m "integration and not slow"
 
 # Run a single test file
 uv run pytest -v tests/test_nodenorm.py
+
+# Run serially, e.g. to read one test's output
+uv run pytest -v -n0 tests/test_nodenorm.py
 ```
 
+`[tool.pytest.ini_options]` puts `-n auto` in `addopts`, so every run is parallel by default.
+Disable it with `-n0`, **not** `-p no:xdist` — unloading the plugin leaves the already-parsed
+`-n` behind and pytest exits with `unrecognized arguments: -n`.
+
 ### Linting
 
 **Run both of these before committing or pushing.** CI checks them on every PR, and a push
@@ -309,9 +316,44 @@ uv run pytest --collect-only -q                        # full count
 a couple of dozen skips is the expected result without a Translator `BABEL_RELEASES_URL` in `.env`, not a
 broken test environment.
 
+**A release can publish one DuckDB file without the other.** `2026jul22` serves a 4.6 GB
+`Concord.parquet` with no `Identifiers.parquet` beside it, so "does this release have the Parquet
+files?" is not one question. Every DuckDB file goes through `_download_or_skip()`, which skips on
+the `MissingBabelFileError` the downloader already raises for a 404 on a `duckdb/` path.
+`shared_downloader` answers only the genuinely session-wide question — is the server reachable —
+and deliberately probes the release root rather than a specific file, so it cannot be mistaken for
+a publication check. Do not collapse these back into one up-front probe: the non-slow integration
+tests run perfectly well against a release that lacks `Identifiers.parquet`.
+
+**A full run re-downloads everything.** `pytest_sessionfinish` deletes `data/test`, so each
+`uv run pytest` with a Babel release configured pays the multi-gigabyte download again (~9 minutes
+for `2026jul22`). Use `-m "not integration"` while iterating, and budget for the full run.
+
+**Only one pytest session may touch `data/test` at a time.** It is a fixed path shared by every
+run, not a per-run temporary directory, and `pytest_sessionfinish` deletes it at the end of the
+session. The `FileLock` around each download does not help: it guards one file, not a session.
+
+`pytest_sessionfinish` skips the cleanup when the session selected no `integration` tests, so the
+fast `-m "not integration"` loop you run while editing is safe alongside a long integration run.
+**Do not remove that guard.** Without it, every unit run — the most frequent command in this
+repository — silently deletes a multi-gigabyte download in progress in another terminal, and the
+integration run just starts over, looking like a downloader bug rather than an unrelated `pytest`
+invocation two windows away. This was diagnosed twice as a resume defect before the real cause
+turned up.
+
+Two concurrent *integration* runs still clash, and nothing here prevents that:
+
+- **Detect it**: `du -sh data/test` going *down* instead of up, and a run sailing well past the ~9
+  minutes it should take. `ps -eo pid,etime,command | grep "[p]ytest"` showing two sets of workers
+  with different `etime` values confirms it.
+- **Avoid it**: check for a run already in flight before starting one, and never `rm -rf data/test`
+  to "start clean" without checking first — that is the fastest way to corrupt a run in progress.
+- **Recover**: kill every pytest process, `rm -rf data/test`, and start exactly one run. Nothing
+  outside `data/test` is affected, so no repository or cache state needs repairing.
+
 ### Test Infrastructure
 
-- **`tests/conftest.py`** — Session-scoped fixtures that download Parquet files once and share them across all integration tests. The `shared_downloader` fixture HEADs `duckdb/Concord.parquet` first and skips the session on 404. Teardown removes the `data/test/` directory so the next run starts fresh.
+- **`tests/conftest.py`** — Session-scoped fixtures that download Parquet files once and share them across all integration tests. `shared_downloader` HEADs the release root and skips the session if the server is unreachable; `_download_or_skip()` then skips per file if the release does not publish it. `nodenorm` probes `status` the same way, so a NodeNorm outage skips rather than reddening CI. Teardown removes the `data/test/` directory so the next run starts fresh — see the concurrency warning above before running two suites at once.
 - **`tests/constants.py`** — Shared constants (URLs, file paths) and `load_curies()` helper.
 - **`tests/data/valid_curies.txt`** — One CURIE per line (`#` comments allowed). Integration tests are parametrized over this list — adding a new line automatically expands test coverage.
 
 
@@ -13,7 +13,7 @@
 from filelock import FileLock
 
 from babel_explorer.core.babel_xrefs import BabelXRefs
-from babel_explorer.core.downloader import BabelDownloader
+from babel_explorer.core.downloader import BabelDownloader, MissingBabelFileError
 from babel_explorer.core.nodenorm import NodeNorm
 from tests.constants import (
     BABEL_URL,
@@ -38,6 +38,11 @@ def valid_curies() -> list[str]:
     return curies
 
 
+def _selected_any_integration_test(session) -> bool:
+    """Did this session actually select a test that uses ``data/test``?"""
+    return any(item.get_closest_marker("integration") for item in session.items)
+
+
 def pytest_sessionfinish(session, exitstatus):
     """Remove the shared test data directory once every worker has finished.
 
@@ -50,9 +55,19 @@ def pytest_sessionfinish(session, exitstatus):
     down at an unpredictable time and gw0 could delete Concord.parquet while gw5
     is still reading it. Guarding that teardown on the worker id, as this used to,
     meant the directory was simply never removed.
+
+    **A session that selected no integration tests cleans up nothing.** ``data/test``
+    is a fixed path, not a per-run temporary directory, so an unconditional delete here
+    means any ``pytest -m "not integration"`` — the fast loop you run constantly while
+    editing — silently destroys the multi-gigabyte download of an integration run going
+    on in another terminal. The unit suite never creates or reads that directory, so it
+    has no business removing it. Two concurrent *integration* runs still clash; that one
+    is unavoidable while the path is shared, and is documented in CLAUDE.md.
     """
     if hasattr(session.config, "workerinput"):
         return
+    if not _selected_any_integration_test(session):
+        return
     if os.path.exists(TEST_DATA_DIR):
         shutil.rmtree(TEST_DATA_DIR, ignore_errors=True)
 
@@ -68,20 +83,43 @@ def test_data_dir():
     return TEST_DATA_DIR
 
 
+def _download_or_skip(downloader, remote_path, test_data_dir, lock_name) -> str:
+    """Download one Babel file, skipping the tests that need it if the release omits it.
+
+    One rule, one implementation, for every DuckDB file. A release can publish
+    ``Concord.parquet`` without ``Identifiers.parquet`` — ``2026jul22`` does exactly that
+    — so "does this release have the Parquet files?" is a question each file has to answer
+    for itself, not once for the session. ``MissingBabelFileError`` is what the downloader
+    already raises on a 404 for a ``duckdb/`` path, so there is no second HEAD request here
+    to drift out of step with the real one.
+    """
+    lock_path = os.path.join(test_data_dir, lock_name)
+    with FileLock(lock_path):
+        try:
+            return downloader.get_downloaded_file(remote_path)
+        except MissingBabelFileError as e:
+            pytest.skip(str(e))
+
+
 @pytest.fixture(scope="session")
 def shared_downloader(test_data_dir) -> BabelDownloader:
     """A BabelDownloader pointed at the test data directory.
 
-    Skips the whole session when the composed Babel URL points at a release that does
-    not publish the DuckDB Parquet files (as the public releases currently do not).
+    Skips the session when the Babel server cannot be reached at all. Whether a given
+    file is *published* is settled per file by ``_download_or_skip``, not here — see
+    that function for why the two cannot be collapsed into one probe.
+
+    The probe deliberately targets the release root rather than ``Concord.parquet``.
+    Naming a file made this look like a publication check, which is what it used to be;
+    only the response status told the two apart, and that distinction is gone now.
+    Reachability is all this answers, so it asks about the release, not a file in it —
+    and the status is not examined, because a 404 from a reachable server is still a
+    reachable server.
     """
-    probe_url = BABEL_URL + CONCORD_FILE
     try:
-        response = requests.head(probe_url, timeout=30)
+        requests.head(BABEL_URL, timeout=30)
     except requests.RequestException as e:
-        pytest.skip(f"Babel server unreachable at {probe_url}: {e}")
-    if response.status_code == 404:
-        pytest.skip(f"{BABEL_URL} does not publish {CONCORD_FILE}")
+        pytest.skip(f"Babel server unreachable at {BABEL_URL}: {e}")
     return BabelDownloader(url_base=BABEL_URL, local_path=test_data_dir)
 
 
@@ -92,17 +130,17 @@ def downloaded_concord(shared_downloader, test_data_dir) -> str:
     Multi-gigabyte in current releases and growing; do not record a figure here,
     it drifts silently and then misleads.
     """
-    lock_path = os.path.join(test_data_dir, "concord.lock")
-    with FileLock(lock_path):
-        return shared_downloader.get_downloaded_file(CONCORD_FILE)
+    return _download_or_skip(
+        shared_downloader, CONCORD_FILE, test_data_dir, "concord.lock"
+    )
 
 
 @pytest.fixture(scope="session")
 def downloaded_metadata(shared_downloader, test_data_dir) -> str:
     """Download duckdb/Metadata.parquet (small). Returns the local path."""
-    lock_path = os.path.join(test_data_dir, "metadata.lock")
-    with FileLock(lock_path):
-        return shared_downloader.get_downloaded_file(METADATA_FILE)
+    return _download_or_skip(
+        shared_downloader, METADATA_FILE, test_data_dir, "metadata.lock"
+    )
 
 
 @pytest.fixture(scope="session")
@@ -119,15 +157,30 @@ def downloaded_identifiers(shared_downloader, test_data_dir) -> str:
     """Download duckdb/Identifiers.parquet, the largest file Babel publishes.
 
     Every test that reaches this is marked ``slow``.
+
+    Skips when the release does not publish it, which is not the same question as
+    whether it publishes ``Concord.parquet`` — see ``_download_or_skip``.
     """
-    lock_path = os.path.join(test_data_dir, "identifiers.lock")
-    with FileLock(lock_path):
-        return shared_downloader.get_downloaded_file(IDENTIFIERS_FILE)
+    return _download_or_skip(
+        shared_downloader, IDENTIFIERS_FILE, test_data_dir, "identifiers.lock"
+    )
 
 
 @pytest.fixture(scope="session")
 def nodenorm() -> NodeNorm:
-    """A NodeNorm client pointed at the public API."""
+    """A NodeNorm client pointed at the public API.
+
+    Probes ``status`` once and skips the NodeNorm integration tests if it cannot be
+    reached, matching what ``shared_downloader`` does for Babel. Without this a RENCI
+    outage turned every one of these tests red on CI's push and weekly-cron runs — a
+    failure that says nothing about the code under test. The probe cannot cover an
+    outage that begins mid-run; it covers the case that actually recurs.
+    """
+    probe_url = NODENORM_URL.rstrip("/") + "/status"
+    try:
+        requests.get(probe_url, timeout=30).raise_for_status()
+    except requests.RequestException as e:
+        pytest.skip(f"NodeNorm unreachable at {probe_url}: {e}")
     return NodeNorm(nodenorm_url=NODENORM_URL)
 
 
 
@@ -1,5 +1,8 @@
 # Valid CURIEs for integration tests.
 # Add new CURIEs here to expand test coverage — tests are parametrized over this list.
+#
+# NCIT:C55060 was removed in #27: it has no rows in Concord.parquet as of Babel
+# 2026jul22. Tracked in #29, which also covers restoring a third CURIE — with only
+# these two, both MONDO, the suite exercises no other namespace.
 MONDO:0004979
 MONDO:0005044
-NCIT:C55060
 
@@ -13,6 +13,7 @@
 
 import pytest
 import requests
+from _pytest.outcomes import Skipped
 
 from babel_explorer.core.downloader import (
     VERSION_MARKER,
@@ -22,6 +23,7 @@
     compose_babel_url,
     resolve_babel_version,
 )
+from tests import conftest
 from tests.constants import BABEL_URL, CONCORD_FILE
 
 
@@ -1279,7 +1281,124 @@ def test_download_caching_real_files(shared_downloader, downloaded_concord):
 @pytest.mark.integration
 @pytest.mark.slow
 def test_download_identifiers_parquet(downloaded_identifiers):
-    """Verify Identifiers.parquet downloads and is > 2 GB."""
+    """Verify Identifiers.parquet downloads as a complete Parquet file.
+
+    Checks the format rather than a byte count. A hard size figure is exactly the kind
+    of number CLAUDE.md says drifts silently and then misleads — it was ``> 2 GB``,
+    chosen against a release long superseded — and the ``PAR1`` marker at both ends is
+    a better test of the thing that actually goes wrong: a truncated download, or an
+    error page saved under a .parquet name.
+    """
     assert os.path.isfile(downloaded_identifiers)
-    size = os.path.getsize(downloaded_identifiers)
-    assert size > 2 * 1024 * 1024 * 1024, f"Identifiers.parquet too small: {size} bytes"
+    assert os.path.getsize(downloaded_identifiers) > 8, "too short to be a Parquet file"
+    with open(downloaded_identifiers, "rb") as f:
+        assert f.read(4) == b"PAR1", "missing Parquet header"
+        f.seek(-4, os.SEEK_END)
+        assert f.read(4) == b"PAR1", "missing Parquet footer — download was truncated"
+
+
+class TestIdentifiersFixtureSkips:
+    """A release that omits Identifiers.parquet must skip, not error.
+
+    The bug this guards was invisible for the same reason the stale
+    `get_curie_xref.cache_clear()` calls were: it only shows up in a run against a
+    real Babel release, and those skip entirely for anyone without one configured.
+    A unit test is the only place it gets exercised routinely.
+    """
+
+    @staticmethod
+    def _call_fixture(downloader, tmp_path):
+        """Invoke the fixture's underlying function directly, past the decorator."""
+        return conftest.downloaded_identifiers.__wrapped__(downloader, str(tmp_path))
+
+    def test_missing_file_skips(self, tmp_path):
+        downloader = Mock()
+        downloader.get_downloaded_file.side_effect = MissingBabelFileError(
+            "This Babel release (2026jul22) does not publish duckdb/Identifiers.parquet."
+        )
+
+        with pytest.raises(Skipped) as excinfo:
+            self._call_fixture(downloader, tmp_path)
+
+        # The downloader's own message explains how to point at a release that has it.
+        assert "does not publish duckdb/Identifiers.parquet" in str(excinfo.value)
+
+    def test_present_file_is_returned(self, tmp_path):
+        """The skip must not swallow the normal path."""
+        downloader = Mock()
+        downloader.get_downloaded_file.return_value = (
+            "/cache/duckdb/Identifiers.parquet"
+        )
+
+        assert (
+            self._call_fixture(downloader, tmp_path)
+            == "/cache/duckdb/Identifiers.parquet"
+        )
+
+    def test_other_errors_still_propagate(self, tmp_path):
+        """Only a missing file is a skip; a real failure must still fail the run."""
+        downloader = Mock()
+        downloader.get_downloaded_file.side_effect = RuntimeError("connection reset")
+
+        with pytest.raises(RuntimeError, match="connection reset"):
+            self._call_fixture(downloader, tmp_path)
+
+
+class TestSessionFinishCleanup:
+    """A unit run must not delete an integration run's multi-gigabyte download.
+
+    `data/test` is a fixed path, not a per-run temporary directory, so the cleanup hook
+    is the one piece of test infrastructure that can destroy another process's work.
+    """
+
+    @staticmethod
+    def _session(markers):
+        """A stub session whose items carry the given marker names."""
+
+        def item(name):
+            it = Mock()
+            it.get_closest_marker.side_effect = lambda m, n=name: (
+                Mock() if m == n else None
+            )
+            return it
+
+        session = Mock()
+        session.items = [item(m) for m in markers]
+        del session.config.workerinput  # a controller, not an xdist worker
+        return session
+
+    def test_unit_only_session_leaves_the_directory_alone(self, tmp_path, monkeypatch):
+        data_dir = tmp_path / "test"
+        data_dir.mkdir()
+        (data_dir / "Concord.parquet").write_bytes(b"someone else is using this")
+        monkeypatch.setattr(conftest, "TEST_DATA_DIR", str(data_dir))
+
+        conftest.pytest_sessionfinish(self._session([None, None]), 0)
+
+        assert data_dir.exists(), (
+            "a `-m 'not integration'` run must not delete the integration cache"
+        )
+
+    def test_integration_session_cleans_up(self, tmp_path, monkeypatch):
+        data_dir = tmp_path / "test"
+        data_dir.mkdir()
+        (data_dir / "Concord.parquet").write_bytes(b"this run's own download")
+        monkeypatch.setattr(conftest, "TEST_DATA_DIR", str(data_dir))
+
+        conftest.pytest_sessionfinish(self._session([None, "integration"]), 0)
+
+        assert not data_dir.exists(), "the next run must start fresh"
+
+    def test_xdist_worker_never_cleans_up(self, tmp_path, monkeypatch):
+        """Only the controller cleans up; a worker finishing early must not."""
+        data_dir = tmp_path / "test"
+        data_dir.mkdir()
+        monkeypatch.setattr(conftest, "TEST_DATA_DIR", str(data_dir))
+
+        worker = Mock()
+        worker.items = [Mock()]
+        worker.config.workerinput = {"workerid": "gw0"}
+
+        conftest.pytest_sessionfinish(worker, 0)
+
+        assert data_dir.exists()