Refuse a corpus that has shrunk

The empty-file guard only catches a corpus that lost EVERY name. One
truncated to a handful sails past it: the run compares 298 names
instead of 751, prints those counts, and exits 0 -- green while having
compared a fraction of what its own summary reports.

Floors rather than exact counts, because corpus_issues.jsonl grows
whenever it is regenerated from the tracker and an exact pin would fail
on every legitimate harvest. A corpus with no floor is a hard error
rather than an unguarded default, so adding one forces a decision the
way the Script tables do -- and the test binds both directions, so
neither a floor without a file nor a file without a floor can rot.

Author: derek73

tests/v2/test_differential.py

@@ -325,7 +325,8 @@ def test_ambiguities_is_a_legal_field_name() -> None:
 
 def _run_main(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ledger_body: str,
               baseline_facade: dict, baseline: str = "1.4.0",
-              baseline_v2: dict | None = None) -> tuple[int, str]:
+              baseline_v2: dict | None = None,
+              floor: int | None = 1) -> tuple[int, str]:
     """Drive main() end to end with a faked baseline worker.
 
     No uv, no network. The helper exists because every unit test above
@@ -351,6 +352,11 @@ def _fake(v: str, w: bool, n: list[str]) -> tuple[dict, list[dict]]:
         return ({"__version__": v,
                  "__file__": "/wheel/nameparser/__init__.py"}, [row])
 
+    # The fixture corpus needs a floor like any other. `floor=None`
+    # leaves it unregistered, for the test that pins what happens when
+    # a corpus arrives without one.
+    if floor is not None:
+        monkeypatch.setitem(compare._CORPUS_FLOORS, corpus.name, floor)
     monkeypatch.setattr(compare, "HERE", tmp_path)
     monkeypatch.setattr(compare, "_run_worker", _fake)
     monkeypatch.setattr(sys, "argv", ["compare.py", "--baseline", baseline,
@@ -636,3 +642,55 @@ def test_main_asks_for_the_facade_alone_below_2_0(
     _run_main(tmp_path, monkeypatch,
               '[[change]]\nissue = "x"\nname_regex = "ZZZ"\n', _SAME_FACADE)
     assert _WORKER_CALL["want_v2"] is False
+
+
+def test_every_shipped_corpus_has_a_floor_and_clears_it() -> None:
+    """Two bindings, so neither half can rot alone: every corpus file
+    on disk must have a floor, and must be at or above it.
+
+    The floor exists because the empty-file guard only catches a corpus
+    that lost EVERY name. One truncated to a handful passes that guard,
+    and the run exits 0 having compared a fraction of what its summary
+    line reports -- the harness's own stated nightmare, reached by a
+    file that is merely short rather than absent.
+    """
+    import json
+    corpora = sorted(_TOOLS.glob("corpus*.jsonl"))
+    assert corpora, "no corpora found; this test would pass vacuously"
+    for path in corpora:
+        names = [json.loads(line) for line
+                 in path.read_text(encoding="utf-8").splitlines()
+                 if line.strip()]
+        floor = compare._CORPUS_FLOORS.get(path.name)
+        assert floor is not None, (
+            f"{path.name} has no _CORPUS_FLOORS entry; add one a little "
+            f"under its {len(names)} names")
+        assert len(names) >= floor, (
+            f"{path.name} holds {len(names)}, below its floor {floor}")
+
+
+def test_a_floor_names_a_corpus_that_exists() -> None:
+    """The other direction: a floor for a file nobody ships is a guard
+    that can never fire, and reads as coverage that is not there."""
+    on_disk = {p.name for p in _TOOLS.glob("corpus*.jsonl")}
+    assert set(compare._CORPUS_FLOORS) <= on_disk
+
+
+def test_main_aborts_on_a_truncated_corpus(
+        tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """A corpus below its floor must stop the run, not shrink it."""
+    with pytest.raises(SystemExit, match="below its floor"):
+        _run_main(tmp_path, monkeypatch,
+                  '[[change]]\nissue = "x"\nname_regex = "ZZZ"\n',
+                  _SAME_FACADE, floor=50)
+
+
+def test_main_aborts_on_a_corpus_with_no_floor(
+        tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Adding a corpus without a floor must be a decision, not a
+    silent default -- the same force-a-decision shape the Script
+    tables use."""
+    with pytest.raises(SystemExit, match="no entry in _CORPUS_FLOORS"):
+        _run_main(tmp_path, monkeypatch,
+                  '[[change]]\nissue = "x"\nname_regex = "ZZZ"\n',
+                  _SAME_FACADE, floor=None)

tools/differential/compare.py

@@ -341,6 +341,23 @@ def _is_latin_only(name: str) -> bool:
 #: match every name in every corpus.
 _SENTINELS = ("John Smith", "田中さん", "Хосе Сантос", "x")
 
+#: Per-corpus size floors. The existing empty-file guard only catches a
+#: corpus that lost EVERY name; one truncated to a handful sails past
+#: it, and the run then exits 0 having compared a fraction of what its
+#: own summary line reports -- green, and quietly meaningless.
+#:
+#: Floors, not counts, because corpus_issues.jsonl grows whenever it is
+#: regenerated from the tracker and pinning it exactly would fail on
+#: every legitimate harvest. Set a little under the real size, and
+#: ratchet up only deliberately. A file with no entry here is a hard
+#: error rather than an unguarded default: the point is to force a
+#: decision when a corpus is added, the way the Script tables do.
+_CORPUS_FLOORS = {
+    "corpus.jsonl": 480,        # 486 today, from v1's banks at a pinned ref
+    "corpus_cjk.jsonl": 95,     # 97 today, generated from the case table
+    "corpus_issues.jsonl": 190,  # 200 today, harvested and append-only
+}
+
 
 def validate_rules(rules: list[dict[str, object]], ledger: str) -> None:
     """Reject malformed allowlist rules LOUDLY at startup.
@@ -493,6 +510,20 @@ def main() -> int:
                  for line in path.read_text().splitlines() if line.strip()]
         if not names:
             raise SystemExit(f"{path.name} is empty; comparison aborted")
+        floor = _CORPUS_FLOORS.get(path.name)
+        if floor is None:
+            raise SystemExit(
+                f"{path.name} has no entry in _CORPUS_FLOORS. Add one at "
+                f"a little under its size: without a floor a corpus can "
+                f"shrink to a handful of names and the run still exits "
+                f"0, having compared far less than it reports")
+        if len(names) < floor:
+            raise SystemExit(
+                f"{path.name} holds {len(names)} names, below its floor "
+                f"of {floor} -- it has shrunk or been truncated. The run "
+                f"would still exit 0 while comparing a fraction of what "
+                f"it claims. Restore the file, or lower the floor "
+                f"deliberately if names were removed on purpose")
         per_file[path.name] = len(names)
         corpus.extend(names)
     # dedupe across files, keeping first-seen order stable for output