eurlex: drop the 92 IASB-notice documents (243,060 -> 242,968 docs, v0.2.6)

artifacts/source_findings.md

@@ -1928,16 +1928,19 @@ clause does not change a label here. Evidence in `data/wikinews/wikinews.license
 documents; copyright pastes in news text (the audit's 100-document press-copying sample was
 not run); the markup residue above.
 
-## eurlex — relabelled to the EU reuse policy, third-party material reported (2026-10-06)
+## eurlex — relabelled to the EU reuse policy, 92 IASB documents dropped (2026-10-06)
 
 **Investigated** — 2026-10-06 (October 2026 rights audit, polish-dynaword-v2 #57; lawyer
 question #56 B5; `rights_audit_2026-10/reports/citations.md`).
 
-**Verdict** — kept and relabelled, nothing dropped: 243,060 documents, 5,976,949,249
-characters, 2,378,055,718 tokens before and after. `CC-BY-4.0` becomes
+**Verdict** — kept and relabelled, the 92 IASB-notice documents dropped (maintainer
+decision 2026-10-06): 243,060 -> 242,968 documents, 5,976,949,249 -> 5,902,889,135
+characters, 2,378,055,718 -> 2,350,709,056 tokens. `CC-BY-4.0` becomes
 `LicenseRef-EU-Reuse-Policy` in the per-row `license` column, the registry and the card,
-by `src/clean_eurlex.py` (tested in `src/test_eurlex_contract.py`; all other columns are
-identical). The Polish Copyright Act Art. 4 basis is removed from the card.
+by `src/clean_eurlex.py` (tested in `src/test_eurlex_contract.py`; every kept row is
+otherwise identical to v0.2.5). The drop is pinned to the 92 hand-checked ids and fails
+closed if the IASB rule and the list disagree. The Polish Copyright Act Art. 4 basis is
+removed from the card.
 
 **License evidence** — verified, read 2026-10-06: the EUR-Lex legal notice
 (<https://eur-lex.europa.eu/content/legal-notice/legal-notice.html>, sha256 `7994b96f…`)
@@ -1952,13 +1955,14 @@ the Decision covers Commission documents, so acts of other institutions (Council
 Parliament, ECB, EESC, CJEU) rest on the notice's general sentence. Evidence in
 `data/eurlex/eurlex.license-evidence.json`.
 
-**Third-party check** — report only (`python3 src/clean_eurlex.py --scan`):
+**Third-party check** — `python3 src/clean_eurlex.py --scan` on the v0.2.5 input:
 - 92 documents (74.1M characters, 1.24%) contain the IASB notice: reproduction allowed in
   the EEA, all rights reserved outside it. They are 64 OJ acts adopting or amending
   IAS/IFRS and 28 consolidated versions (20 of Regulation 1126/2008). The notice is the
   "special conditions of use" the legal notice names for the International Accounting
   Standards. All 92 matched lines and all 64 titles hand-checked. Two more documents have
   a standard title line without the notice (67,283 characters) and were not counted.
+  Dropped. None of the 92 is in the (c)-sign or header counts below, so those are unchanged.
 - 97 documents contain a (c) sign; 33 are third-party credits or short data citations
   (photographs, maps, OECD, IHS Markit, McKinsey, Springer), 25 EU credits, 7 binary
   garbage, 32 glyph noise or list markers. Labelled by reading the first occurrence in
@@ -1971,9 +1975,9 @@ Parliament, ECB, EESC, CJEU) rest on the notice's general sentence. Evidence in
 - No large-scale reproduction of non-EU copyrighted works was found. Recall for third-party
   text the patterns do not target is unknown.
 
-**Blockers** — none to merge. Open decision for the maintainer: keep the 92 IASB-notice
-documents (the notice reserves rights outside the EEA, and the Hub is not EEA-limited) or
-drop them. Ids are in `data/eurlex/eurlex.third-party-scan.json`.
+**Blockers** — none to merge. The notice reserves rights outside the EEA and the Hub is not
+EEA-limited, so the 92 documents were dropped; the (c)-sign and header documents are kept.
+Ids are in `data/eurlex/eurlex.third-party-scan.json`.
 
 **Not established** — SpeakLeash's terms for `eurlex_corpus`; whether the ECB, EESC,
 Council, Parliament and the Court of Justice publish reuse terms of their own; the

data/eurlex/eurlex.license-evidence.json

@@ -51,11 +51,14 @@
   "parquet": {
     "v0_2_5_sha256": "5f151d57c20103f5488fd7f1b6c108311b648e4c7ed1ff02ef7a376be5c92f04",
     "v0_2_5_bytes": 1691883292,
-    "after_relabel_sha256": "44cc0dfb0c73c1462635cebc23ed7c1f46e6c509e57e118477a8cfc7cc74c84c",
-    "rows": 243060,
-    "chars": 5976949249,
-    "tokens": 2378055718,
-    "change": "per-row license column CC-BY-4.0 -> LicenseRef-EU-Reuse-Policy (src/clean_eurlex.py); all other columns identical, no row dropped"
+    "v0_2_5_rows": 243060,
+    "v0_2_5_chars": 5976949249,
+    "v0_2_5_tokens": 2378055718,
+    "after_sha256": "17e4112c40d2f961f01e6c4c0b31157c77d5ba89b4c86935d19a82fe0496a2ef",
+    "rows": 242968,
+    "chars": 5902889135,
+    "tokens": 2350709056,
+    "change": "per-row license column CC-BY-4.0 -> LicenseRef-EU-Reuse-Policy and the 92 IASB-notice documents dropped (src/clean_eurlex.py); every kept row is otherwise identical to v0.2.5"
   },
   "document_kinds_heuristic": {
     "method": "first 200 characters of each document",
@@ -73,13 +76,14 @@
     "note": "17,229 consolidated texts (29.0% of characters) are within the notice's CC BY 4.0 grant as well; the single corpus label does not claim CC BY 4.0 for the rest"
   },
   "third_party_check": {
-    "report_only": true,
-    "dropped": 0,
-    "scan": "data/eurlex/eurlex.third-party-scan.json (src/clean_eurlex.py --scan)",
+    "report_only": false,
+    "dropped": 92,
+    "scan": "data/eurlex/eurlex.third-party-scan.json (src/clean_eurlex.py --scan, on the v0.2.5 input; its iasb_notice_ids is the pinned drop list)",
     "iasb_notice": {
       "documents": 92,
       "characters": 74060114,
       "share_of_characters": 0.01239,
+      "tokens": 27346662,
       "what": "Documents carrying the IASB notice (reproduction allowed within the EEA, all rights reserved outside it): 64 OJ acts adopting or amending IAS/IFRS and 28 consolidated versions (20 of Regulation 1126/2008, 6 of 1725/2003, 1 of 475/2012, 1 of 1361/2014). The notice sits in the reproduced standards; the rest of each document is EU text.",
       "hand_check": "All 92 matched lines read: each is the IASB notice (11 distinct line forms, including whitespace and quote-mark variants). All 64 non-consolidated titles concern IAS/IFRS or accounting.",
       "cross_check": "2 further documents have a standard-title line without the notice (eurlex_1848316, eurlex_2024404; 67,283 characters): not counted.",
@@ -143,7 +147,8 @@
       "un_ece_regulation": 253,
       "note": "Not third-party under the notice by themselves: they are texts of EU bodies or Commission notices. They matter only if those bodies' reuse terms differ (not checked). The audit's rough shares (ECB ~4%, state aid ~2.5%) do not reproduce with these patterns."
     },
-    "not_found": "No large-scale reproduction of non-EU copyrighted works was found by these patterns. Recall for third-party text they do not target is unknown (Inferred)."
+    "not_found": "No large-scale reproduction of non-EU copyrighted works was found by these patterns. Recall for third-party text they do not target is unknown (Inferred).",
+    "decision": "2026-10-06, maintainer: drop the 92 IASB-notice documents (Hub PR 71). The (c)-sign and author-header documents are reported only and kept."
   },
   "not_checked": [
     "SpeakLeash's terms for eurlex_corpus",

data/eurlex/eurlex.md

@@ -19,18 +19,18 @@ Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `eurlex
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 243,060 | 5,976,949,249 | 2,378,055,718 |
+| 242,968 | 5,902,889,135 | 2,350,709,056 |
 
 
 ## Per-document license metadata
 | license | documents |
 |---|---:|
-| `LicenseRef-EU-Reuse-Policy` | 243,060 |
+| `LicenseRef-EU-Reuse-Policy` | 242,968 |
 
 Author metadata present for **0** documents. Empty values mean the upstream record did not expose a machine-readable author field.
 
 ## Legal scope note
-Third-party material is not covered. The notice and Decision 2011/833/EU Art. 2(2)(a)-(b) exclude documents covered by industrial property rights or third-party intellectual property rights, and the notice says the International Accounting Standards may carry special conditions of use. 92 documents (74.1M characters, 1.24%) contain the IASB notice allowing reproduction within the EEA and reserving all rights outside it: 64 Official Journal acts adopting or amending IAS/IFRS and 28 consolidated versions (Regulations 1126/2008, 1725/2003, 475/2012, 1361/2014). 97 documents contain a (c) sign; 33 of them are third-party credits or short data citations (photographs, maps, OECD, IHS Markit, McKinsey, Springer), the rest EU credits or extraction noise. Nothing was removed. Ids and counts are in `eurlex.third-party-scan.json` and `eurlex.license-evidence.json`; recall for third-party text the patterns do not target is unknown. Decision 2011/833/EU itself covers documents held by the Commission or the Publications Office; acts of other institutions (Council, Parliament, ECB, EESC, CJEU) rest on the notice's general sentence alone, and whether those bodies publish their own reuse terms was not checked.
+Third-party material is not covered. The notice and Decision 2011/833/EU Art. 2(2)(a)-(b) exclude documents covered by industrial property rights or third-party intellectual property rights, and the notice says the International Accounting Standards may carry special conditions of use. 92 documents (74.1M characters, 1.24% of v0.2.5) carried the IASB notice allowing reproduction within the EEA and reserving all rights outside it: 64 Official Journal acts adopting or amending IAS/IFRS and 28 consolidated versions (Regulations 1126/2008, 1725/2003, 475/2012, 1361/2014). They were removed in v0.2.6 (243,060 -> 242,968 documents). 97 documents contain a (c) sign; 33 of them are third-party credits or short data citations (photographs, maps, OECD, IHS Markit, McKinsey, Springer), the rest EU credits or extraction noise; they were kept. Ids and counts are in `eurlex.third-party-scan.json` and `eurlex.license-evidence.json`; recall for third-party text the patterns do not target is unknown. Decision 2011/833/EU itself covers documents held by the Commission or the Publications Office; acts of other institutions (Council, Parliament, ECB, EESC, CJEU) rest on the notice's general sentence alone, and whether those bodies publish their own reuse terms was not checked.
 
 Statistics were recomputed directly from the released parquet file.
 
@@ -40,7 +40,7 @@ Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - drop non-Polish (diacritic ratio): **0**
 - exact cross-source dedup (sha1): **0**
 - OCR alpha-ratio < 0.70 (OCR sources only): **0**
-- read 243,060 → kept 243,060
+- read 243,060 → kept 242,968
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.

data/eurlex/eurlex.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:44cc0dfb0c73c1462635cebc23ed7c1f46e6c509e57e118477a8cfc7cc74c84c
-size 1691885842
+oid sha256:17e4112c40d2f961f01e6c4c0b31157c77d5ba89b4c86935d19a82fe0496a2ef
+size 1671120091

data/eurlex/eurlex.stats.json

@@ -1,16 +1,17 @@
 {
   "read": 243060,
-  "kept": 243060,
+  "kept": 242968,
   "drop_short": 0,
   "drop_lang": 0,
   "drop_dup": 0,
   "drop_ocr": 0,
-  "chars": 5976949249,
-  "tokens": 2378055718,
+  "chars": 5902889135,
+  "tokens": 2350709056,
   "licenses": {
-    "LicenseRef-EU-Reuse-Policy": 243060
+    "LicenseRef-EU-Reuse-Policy": 242968
   },
   "authors_with_value": 0,
   "license": "LicenseRef-EU-Reuse-Policy",
-  "stats_recomputed_from_parquet": true
+  "stats_recomputed_from_parquet": true,
+  "drop_iasb_notice": 92
 }

src/clean_eurlex.py

@@ -1,16 +1,20 @@
 #!/usr/bin/env python3
 """eurlex rights-audit actions (slayerlabs/polish-dynaword-v2#57).
 
-relabel (default): the v0.2.5 release labelled every row `CC-BY-4.0`. The EUR-Lex legal
+clean (default): the v0.2.5 release labelled every row `CC-BY-4.0`. The EUR-Lex legal
 notice licenses under CC BY 4.0 only "the editorial content of this website, the summaries
 of EU legislation and the consolidated texts"; the legal documents themselves are reusable
 under the Commission's reuse policy (Decision 2011/833/EU). Rewrites the per-row `license`
-column to `LicenseRef-EU-Reuse-Policy` and recomputes `eurlex.stats.json` with
-`normalize_schema.normalize_one`. No row is dropped or edited. Raises, and leaves the
-parquet as it was, if any row carries a licence other than the old or the new label.
+column to `LicenseRef-EU-Reuse-Policy`, drops the 92 hand-checked documents carrying the
+IASB notice (all rights reserved outside the EEA; maintainer decision 2026-10-06), and
+recomputes `eurlex.stats.json` with `normalize_schema.normalize_one`. No kept row is edited
+except its `license`. Raises, and leaves the parquet as it was, if any row carries a licence
+other than the old or the new label, if a row carries the IASB notice but is not in the
+pinned list, or if a pinned id is missing from the input or lacks the notice.
 
 --scan: report-only count of documents the notice's third-party / special-conditions
-exclusions may reach. Writes `data/eurlex/eurlex.third-party-scan.json`. Nothing is dropped.
+exclusions may reach, read from the v0.2.5 input. Writes `data/eurlex/eurlex.third-party-scan.json`,
+whose `iasb_notice_ids` is the pinned drop list; it refuses to change a pinned list.
 The regexes are heuristics: counts are lower bounds on what they target, and recall for
 third-party text they do not target is unknown.
 
@@ -58,28 +62,57 @@ HEADER_RULES = {
 }
 
 
-def relabel(path: Path = PARQUET, old: str = OLD_LICENSE, new: str = NEW_LICENSE) -> dict:
-    """Rewrite `license` of every row to `new`, then recompute stats. Returns the stats."""
+def pinned_iasb_ids(path: Path = SCAN_JSON) -> frozenset[str]:
+    """The hand-checked IASB-notice ids recorded by --scan on the v0.2.5 input."""
+    return frozenset(json.loads(path.read_text())["iasb_notice_ids"])
+
+
+def clean(path: Path = PARQUET, withhold: frozenset[str] | None = None,
+          old: str = OLD_LICENSE, new: str = NEW_LICENSE) -> dict:
+    """Rewrite `license` of every row to `new`, drop the `withhold` rows, then recompute stats.
+
+    `withhold` defaults to `pinned_iasb_ids()`. Each row must carry the IASB notice exactly when
+    its id is in `withhold`, and every `withhold` id must be in the input. Returns the stats.
+    """
+    withhold = pinned_iasb_ids() if withhold is None else withhold
+    iasb = WHOLE_TEXT_RULES["iasb_notice"]
     tmp = path.with_suffix(".parquet.tmp")
     pf = pq.ParquetFile(path)
     schema = pf.schema_arrow
     index = schema.get_field_index("license")
     writer = pq.ParquetWriter(tmp, schema, compression="zstd")
+    dropped: set[str] = set()
     try:
         for batch in pf.iter_batches(batch_size=BATCH):
             tbl = pa.Table.from_batches([batch])
             found = set(pc.unique(tbl["license"]).to_pylist())
             if not found <= {old, new}:
                 raise ValueError(f"{path.name}: unexpected licence(s) {sorted(map(str, found - {old, new}))}")
+            keep = []
+            for doc_id, text in zip(tbl["id"].to_pylist(), tbl["text"].to_pylist()):
+                notice, listed = iasb.search(text) is not None, doc_id in withhold
+                if notice != listed:
+                    raise ValueError(f"{path.name}: {doc_id} has IASB notice={notice} but pinned={listed}")
+                if listed:
+                    dropped.add(doc_id)
+                keep.append(not listed)
+            tbl = tbl.filter(pa.array(keep))
             tbl = tbl.set_column(index, schema.field(index), pa.array([new] * tbl.num_rows, type=pa.string()))
             writer.write_table(tbl)
+        if missing := withhold - dropped:
+            raise ValueError(f"{path.name}: {len(missing)} pinned id(s) not in the input, e.g. {sorted(missing)[:3]}; "
+                             "restore the v0.2.5 input first")
         writer.close()
         tmp.replace(path)
     except BaseException:
         writer.close()
         tmp.unlink(missing_ok=True)
         raise
-    return normalize_one(path)
+    stats = normalize_one(path)
+    stats["read"] += len(dropped)
+    stats["drop_iasb_notice"] = len(dropped)
+    path.with_name(f"{SOURCE}.stats.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2) + "\n")
+    return stats
 
 
 def scan(path: Path = PARQUET) -> dict:
@@ -113,11 +146,15 @@ def main() -> None:
     args = ap.parse_args()
     if args.scan:
         result = scan(args.parquet)
+        if SCAN_JSON.exists() and (pinned := pinned_iasb_ids(SCAN_JSON)) and pinned != set(result["iasb_notice_ids"]):
+            raise SystemExit(f"{SCAN_JSON.name} pins {len(pinned)} IASB ids, this input has "
+                             f"{len(result['iasb_notice_ids'])}: --scan reads the v0.2.5 input (see the docstring)")
         SCAN_JSON.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
         print(json.dumps({k: v for k, v in result.items() if k != "iasb_notice_ids"}, ensure_ascii=False, indent=2))
     else:
-        stats = relabel(args.parquet)
-        print(f"{SOURCE}: {stats['kept']:,} docs | {stats['tokens']:,} tokens | licences {stats['licenses']}")
+        stats = clean(args.parquet)
+        print(f"{SOURCE}: {stats['read']:,} -> {stats['kept']:,} docs (IASB dropped {stats['drop_iasb_notice']}) | "
+              f"{stats['tokens']:,} tokens | licences {stats['licenses']}")
 
 
 if __name__ == "__main__":

src/sources.py

@@ -232,13 +232,14 @@ SOURCES = {
                       "Art. 2(2)(a)-(b) exclude documents covered by industrial property rights "
                       "or third-party intellectual property rights, and the notice says the "
                       "International Accounting Standards may carry special conditions of use. "
-                      "92 documents (74.1M characters, 1.24%) contain the IASB notice allowing "
-                      "reproduction within the EEA and reserving all rights outside it: 64 "
-                      "Official Journal acts adopting or amending IAS/IFRS and 28 consolidated "
-                      "versions (Regulations 1126/2008, 1725/2003, 475/2012, 1361/2014). 97 "
-                      "documents contain a (c) sign; 33 of them are third-party credits or short "
-                      "data citations (photographs, maps, OECD, IHS Markit, McKinsey, Springer), "
-                      "the rest EU credits or extraction noise. Nothing was removed. Ids and "
+                      "92 documents (74.1M characters, 1.24% of v0.2.5) carried the IASB notice "
+                      "allowing reproduction within the EEA and reserving all rights outside it: "
+                      "64 Official Journal acts adopting or amending IAS/IFRS and 28 consolidated "
+                      "versions (Regulations 1126/2008, 1725/2003, 475/2012, 1361/2014). They "
+                      "were removed in v0.2.6 (243,060 -> 242,968 documents). 97 documents "
+                      "contain a (c) sign; 33 of them are third-party credits or short data "
+                      "citations (photographs, maps, OECD, IHS Markit, McKinsey, Springer), the "
+                      "rest EU credits or extraction noise; they were kept. Ids and "
                       "counts are in `eurlex.third-party-scan.json` and "
                       "`eurlex.license-evidence.json`; recall for third-party text the patterns "
                       "do not target is unknown. Decision 2011/833/EU itself covers documents "

src/test_eurlex_contract.py

@@ -1,4 +1,4 @@
-"""Contract tests for the eurlex licence relabel (slayerlabs/polish-dynaword-v2#57)."""
+"""Contract tests for the eurlex licence relabel and IASB drop (slayerlabs/polish-dynaword-v2#57)."""
 from __future__ import annotations
 
 import hashlib
@@ -19,7 +19,8 @@ from clean_eurlex import (
     NEW_LICENSE,
     OLD_LICENSE,
     WHOLE_TEXT_RULES,
-    relabel,
+    clean,
+    pinned_iasb_ids,
     scan,
 )
 from normalize_schema import SCHEMA, string_len_sum
@@ -42,42 +43,66 @@ def row(i: int, text: str = "Rozporządzenie. " * 20, license: str = OLD_LICENSE
 
 
 # normalize_one reads the registry entry by directory name, so the fixture lives in <tmp>/eurlex/.
+# eurlex_3 carries the IASB notice and is the one pinned id.
+PINNED = frozenset({"eurlex_3"})
+
+
 @pytest.fixture
 def parquet(tmp_path):
-    return write_parquet(tmp_path / "eurlex" / "eurlex.parquet", [row(0), row(1), row(2, license=NEW_LICENSE)])
+    return write_parquet(tmp_path / "eurlex" / "eurlex.parquet", [
+        row(0), row(1), row(2, license=NEW_LICENSE), row(3, text=f"Standard\n{IASB_NOTICES[0]}\n" + "a" * 200),
+    ])
+
+
+def assert_refused(path: Path, match: str, withhold: frozenset[str]) -> None:
+    digest = hashlib.sha256(path.read_bytes()).hexdigest()
+    with pytest.raises(ValueError, match=match):
+        clean(path, withhold)
+    assert hashlib.sha256(path.read_bytes()).hexdigest() == digest
+    assert not path.with_suffix(".parquet.tmp").exists()
 
 
-def test_relabel_changes_only_the_license_column(parquet):
+def test_clean_relabels_and_drops_only_the_pinned_rows(parquet):
     before = pq.read_table(parquet)
-    stats = relabel(parquet)
+    stats = clean(parquet, PINNED)
     after = pq.read_table(parquet)
+    kept = before.slice(0, 3)
 
     assert after.schema == before.schema
+    assert after["id"].to_pylist() == ["eurlex_0", "eurlex_1", "eurlex_2"]
     assert after["license"].to_pylist() == [NEW_LICENSE] * 3
     for name in before.schema.names:
         if name != "license":
-            assert after[name].equals(before[name]), name
-    assert stats["kept"] == 3
+            assert after[name].equals(kept[name]), name
+    assert (stats["read"], stats["kept"], stats["drop_iasb_notice"]) == (4, 3, 1)
     assert stats["licenses"] == {NEW_LICENSE: 3}
     assert stats["license"] == NEW_LICENSE == CFG["license"]
-    assert stats["chars"] == string_len_sum(before["text"])
-    assert stats["tokens"] == sum(before["token_count"].to_pylist())
+    assert stats["chars"] == string_len_sum(kept["text"])
+    assert stats["tokens"] == sum(kept["token_count"].to_pylist())
     assert json.loads(parquet.with_name("eurlex.stats.json").read_text()) == stats
     assert not parquet.with_suffix(".parquet.tmp").exists()
 
 
-def test_relabel_is_idempotent(parquet):
-    first = relabel(parquet)
-    assert relabel(parquet) == first
+def test_clean_refuses_an_unpinned_iasb_row(parquet):
+    assert_refused(parquet, "eurlex_3 has IASB notice=True but pinned=False", frozenset())
+
+
+def test_clean_refuses_a_pinned_row_without_the_notice(parquet):
+    assert_refused(parquet, "eurlex_0 has IASB notice=False but pinned=True", PINNED | {"eurlex_0"})
 
 
-def test_relabel_refuses_an_unexpected_license_and_leaves_the_file_alone(tmp_path):
+def test_clean_refuses_a_pinned_id_missing_from_the_input(parquet):
+    assert_refused(parquet, "1 pinned id.*eurlex_9", PINNED | {"eurlex_9"})
+
+
+def test_clean_refuses_to_rerun_on_its_own_output(parquet):
+    clean(parquet, PINNED)
+    assert_refused(parquet, "restore the v0.2.5 input", PINNED)
+
+
+def test_clean_refuses_an_unexpected_license(tmp_path):
     path = write_parquet(tmp_path / "eurlex" / "eurlex.parquet", [row(0), row(1, license="CC-BY-SA-4.0")])
-    digest = hashlib.sha256(path.read_bytes()).hexdigest()
-    with pytest.raises(ValueError, match="CC-BY-SA-4.0"):
-        relabel(path)
-    assert hashlib.sha256(path.read_bytes()).hexdigest() == digest
-    assert not path.with_suffix(".parquet.tmp").exists()
+    assert_refused(path, "CC-BY-SA-4.0", frozenset())
 
 
 # The three wordings of the IASB notice in the corpus (Polish text of the OJ), and text that must not match.
@@ -133,6 +158,22 @@ def test_scan_counts_documents_per_rule(tmp_path):
     assert rules["iasb_notice"]["chars"] == len(pq.read_table(path)["text"][0].as_py())
 
 
+
+@pytest.mark.parametrize("pinned, refused", [(["eurlex_3"], False), (["eurlex_7"], True), ([], False)])
+def test_scan_never_changes_a_pinned_id_list(parquet, tmp_path, monkeypatch, pinned, refused):
+    import clean_eurlex
+    pin = tmp_path / "eurlex.third-party-scan.json"
+    pin.write_text(json.dumps({"iasb_notice_ids": pinned}))
+    monkeypatch.setattr(clean_eurlex, "SCAN_JSON", pin)
+    monkeypatch.setattr(sys, "argv", ["clean_eurlex.py", "--scan", "--parquet", str(parquet)])
+    if refused:
+        with pytest.raises(SystemExit, match="pins 1 IASB ids, this input has 1"):
+            clean_eurlex.main()
+        assert json.loads(pin.read_text()) == {"iasb_notice_ids": pinned}
+    else:
+        clean_eurlex.main()
+        assert json.loads(pin.read_text())["iasb_notice_ids"] == ["eurlex_3"]
+
 def test_registry_label_and_basis():
     assert CFG["license"] == CFG["license_spdx"] == NEW_LICENSE
     assert CFG["release"] == "0.2.0"
@@ -164,14 +205,17 @@ def test_release_artifact_matches_label_stats_and_evidence():
     assert sources == {"eurlex"}
     assert (rows, chars, tokens) == (stats["kept"], stats["chars"], stats["tokens"])
     assert stats["licenses"] == {CFG["license"]: rows} and stats["license"] == CFG["license"]
-    # the relabel drops nothing: same totals as v0.2.5
-    assert (rows, chars, tokens) == (243060, 5976949249, 2378055718)
+    # v0.2.5 (243,060 docs, 5,976,949,249 chars, 2,378,055,718 tokens) minus the 92 IASB documents
+    assert (rows, chars, tokens) == (242968, 5902889135, 2350709056)
+    assert (stats["read"], stats["drop_iasb_notice"]) == (243060, 92)
+    ids = set(pq.read_table(path, columns=["id"])["id"].to_pylist())
+    assert len(ids) == rows and not ids & pinned_iasb_ids()
 
     digest = hashlib.sha256()
     with open(path, "rb") as handle:
         for block in iter(lambda: handle.read(1 << 24), b""):
             digest.update(block)
-    assert digest.hexdigest() == evidence["parquet"]["after_relabel_sha256"]
+    assert digest.hexdigest() == evidence["parquet"]["after_sha256"]
 
 
 def test_evidence_and_scan_agree():
@@ -180,15 +224,21 @@ def test_evidence_and_scan_agree():
     check = evidence["third_party_check"]
 
     assert evidence["label"] == CFG["license"] and evidence["previous_label"] == OLD_LICENSE
-    assert check["dropped"] == 0
+    assert check["dropped"] == check["iasb_notice"]["documents"] == 92
     assert check["iasb_notice"]["documents"] == result["rules"]["iasb_notice"]["docs"] == len(result["iasb_notice_ids"])
+    assert len(set(result["iasb_notice_ids"])) == 92
     assert check["iasb_notice"]["characters"] == result["rules"]["iasb_notice"]["chars"]
     assert check["copyright_sign"]["documents"] == result["rules"]["copyright_sign"]["docs"]
     third_party = check["copyright_sign"]["hand_labelled_third_party_credit_or_citation"]
     assert len(third_party) == len(set(third_party)) == check["copyright_sign"]["hand_labelled_third_party_count"]
     for name in ("ecb_act", "eesc", "state_aid_sa", "un_ece_regulation"):
         assert check["author_header_categories"][name] == result["rules"][name]["docs"]
-    assert (result["rows"], result["chars"]) == (evidence["parquet"]["rows"], evidence["parquet"]["chars"])
+    # the scan reads the v0.2.5 input; the release is that input minus the IASB documents
+    parquet = evidence["parquet"]
+    assert (result["rows"], result["chars"]) == (parquet["v0_2_5_rows"], parquet["v0_2_5_chars"])
+    assert parquet["rows"] == parquet["v0_2_5_rows"] - check["dropped"]
+    assert parquet["chars"] == parquet["v0_2_5_chars"] - check["iasb_notice"]["characters"]
+    assert parquet["tokens"] == parquet["v0_2_5_tokens"] - check["iasb_notice"]["tokens"]
 
     urls = [doc["url"] for doc in evidence["reuse_basis"]["documents"]]
     assert urls == ["https://eur-lex.europa.eu/content/legal-notice/legal-notice.html",