biblioteka_nauki: per-record licence versions from the API (42,068 -> 42,055 docs, v2#57) (#81)

- biblioteka_nauki: per-record licence versions from the API (42,068 -> 42,055 docs, v0.2.6, v2#57) (38c3442a1269dbf3a701d4a9f5b7371579920608)
- biblioteka_nauki: say where the text came from (SpeakLeash), not "direct rebuild" (v2#57) (fed6b6b61d927132910c42cddc0543708b98ad5f)
- biblioteka_nauki: withhold 71 rows by id, relabel articles_2011995 (maintainer 2026-10-06, v2#57) (5fb1715a69eb87c302cbe6002648dddbc75f289d)

artifacts/source_findings.md

@@ -2174,3 +2174,43 @@ rights audit action "check live site manually (CAPTCHA); resolve 3.0 vs 4.0".
 
 **Lesson:** the audit found the live site behind a verification page, yet a plain read-only
 GET returned it on 2026-10-06. Retry that before routing a check to a human.
+
+## biblioteka_nauki — licence versions restored from the API (2026-10-06)
+
+**Verdict** — `added`, kept for v0.2.6 minus 83 rows (polish-dynaword-v2#57; maintainer approval
+2026-10-06). 42,068 → 41,985 documents, 673,112,676 → 669,909,430 tokens (−3,203,246),
+1,747,387,478 → 1,739,004,913 characters. The `license` column now carries the version the API
+gives per record: CC-BY-4.0 17,768, CC-BY-3.0-PL 8,098, CC-BY-3.0 2,413, CC-BY-2.0 1, CC-BY-SA-4.0
+10,944, CC-BY-SA-3.0-PL 2,754, CC-BY-SA-3.0 7. Before, 28,335 rows said `cc-by` and 13,733
+`cc-by-sa`, and the card said 4.0 for all. Only that column changed: same ids in the same
+order, same text hashes for the 41,985 shipped rows (digest in `stats.json` and the evidence file).
+
+**Method** — `data/biblioteka_nauki/recover_license_versions.py` asked
+`bibliotekanauki.pl/api/{type}/{id}` once per row of the previous release (2026-10-05/06, one
+request clock, 3 workers, back-off on 429/5xx, stop on 403). 42,056 answered 200; no block, no
+CAPTCHA. The responses are committed as `biblioteka_nauki.license-api.json`. The cleaner labels
+a row only when the `creativecommons.org` URL, the English name and the icon agree with each other
+and with the earlier label, for CC BY / BY-SA 2.0 to 4.0 (generic or PL); anything else is withheld.
+
+**Withheld (83)** — 12 rows the API now answers with 404 (`articles_512191`, `604103`, `605338`,
+`694689`, `699376`, `699392`, `699396`, `699422`, `699424`, `699432`, `699440`, `699442`; asked
+again by hand, 404 again); 56 rows whose text prints an NC or ND licence (Krytyka Prawa 2019 21,
+Journal of Health Sciences 2014 12, 23 others) and 15 rows whose text says it is reprinted or
+translated by permission of a publisher (Oxford University Press 3, others 12), both lists decided
+by the maintainer on 2026-10-06 and kept by id, with a reason per id, in
+`src/clean_biblioteka_nauki.py`. `articles_2011995`, whose API licence is CC BY-SA 4.0 while the
+earlier recovery said CC BY, is kept as CC-BY-SA-4.0. Why the platform dropped the 12 records, and
+whether it changed that licence after the first recovery, is not known.
+
+**Not resolved** — the 3 Public Domain Mark rows were already gone (Hub PR 62). The 128 rows
+the earlier review found with "all rights reserved" in the text could not be reproduced exactly (regex variants give
+121 to 137, 127 for the whitespace-tolerant one; 4 of the 127 are among the withheld rows). All of them have a CC BY or CC BY-SA licence in
+the API, none is all-rights-reserved there. They stay in; the footer-versus-API conflict is a
+rights decision. 5 kept rows carry `reprintPublication` (2) or `translationPublication` (3);
+none has `restricted`. The card and registry say the text came from the SpeakLeash
+redistribution (Hub PR 11) with licence and attribution recovered per document from the API; the
+text-assembly script (`build_parquet.py`) is not in the repo or on the Hub, so how the text layer
+was assembled is not re-verified.
+
+**Lesson** — a label that drops the version is not a licence. 28,280 rows are CC BY and
+13,705 CC BY-SA, and 13,273 of the 41,985 rows are not 4.0.

data/biblioteka_nauki/biblioteka_nauki.license-evidence.json

@@ -0,0 +1,155 @@
+{
+ "source": "biblioteka_nauki",
+ "checked_at": "2026-10-06",
+ "status": "admitted: per-record CC BY / CC BY-SA, version carried per row",
+ "license_spdx": "MIXED (per row: CC-BY-2.0, CC-BY-3.0, CC-BY-3.0-PL, CC-BY-4.0, CC-BY-SA-3.0, CC-BY-SA-3.0-PL, CC-BY-SA-4.0)",
+ "review_scope": "Licence name, URL and version of every one of the 42,068 rows of the previous release (v0.2.5 after the Public Domain Mark drop, Hub PR 62), read from the platform API. Not a review of the texts, of the authors' standing to license, or of third-party material inside the items.",
+ "finding": "The API gives CC BY 2.0 / 3.0 / 3.0 PL / 4.0 and CC BY-SA 3.0 / 3.0 PL / 4.0 per record; v0.2.5 and the first v0.2.6 build collapsed all of them to 4.0 by keeping only license.iconId. The `license` column now holds the API's version. 12 rows the API no longer serves (HTTP 404) are withheld; so are, by the maintainer's decision of 2026-10-06, 56 rows whose text prints a NonCommercial or NoDerivatives licence and 15 rows whose text says it is reprinted or translated by permission of a publisher. articles_2011995 (API: CC BY-SA 4.0; earlier recovery: CC BY) is kept, labelled CC-BY-SA-4.0. No row's text changed.",
+ "upstream_api": "https://bibliotekanauki.pl/api/{articles|books|chapters}/{id}",
+ "retrieved": "2026-10-05..2026-10-06",
+ "retrieval_script": "data/biblioteka_nauki/recover_license_versions.py (one global request clock, 3 workers, 0.15 s between request starts, back-off on 429/5xx, stops on 403 or a non-JSON 200; no CAPTCHA or terms page was met)",
+ "sidecar": "data/biblioteka_nauki/biblioteka_nauki.license-api.json",
+ "sidecar_sha256": "51e0bf7900e016f4b0102eecfd5032f3969a566899bf8ba094abad9f4f4578b5",
+ "api_licenses": [
+  {
+   "api_license_id": 21,
+   "label": "CC-BY-2.0",
+   "nameEn": "CC BY: Creative Commons Attribution 2.0 Generic",
+   "urlEn": "https://creativecommons.org/licenses/by/2.0/legalcode",
+   "api_rows": 13,
+   "shipped": 1
+  },
+  {
+   "api_license_id": 14,
+   "label": "CC-BY-3.0",
+   "nameEn": "CC BY: Creative Commons Attribution 3.0 Unported",
+   "urlEn": "https://creativecommons.org/licenses/by/3.0/legalcode",
+   "api_rows": 2413,
+   "shipped": 2413
+  },
+  {
+   "api_license_id": 7,
+   "label": "CC-BY-3.0-PL",
+   "nameEn": "CC BY: Creative Commons Attribution 3.0 PL",
+   "urlEn": "https://creativecommons.org/licenses/by/3.0/pl/legalcode",
+   "api_rows": 8104,
+   "shipped": 8098
+  },
+  {
+   "api_license_id": 1,
+   "label": "CC-BY-4.0",
+   "nameEn": "CC BY: Creative Commons Attribution 4.0",
+   "urlEn": "https://creativecommons.org/licenses/by/4.0/legalcode.en",
+   "api_rows": 17800,
+   "shipped": 17768
+  },
+  {
+   "api_license_id": 15,
+   "label": "CC-BY-SA-3.0",
+   "nameEn": "CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 Unported",
+   "urlEn": "https://creativecommons.org/licenses/by-sa/3.0/legalcode",
+   "api_rows": 7,
+   "shipped": 7
+  },
+  {
+   "api_license_id": 8,
+   "label": "CC-BY-SA-3.0-PL",
+   "nameEn": "CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 PL",
+   "urlEn": "https://creativecommons.org/licenses/by-sa/3.0/pl/legalcode",
+   "api_rows": 2761,
+   "shipped": 2754
+  },
+  {
+   "api_license_id": 2,
+   "label": "CC-BY-SA-4.0",
+   "nameEn": "CC BY-SA: Creative Commons Attribution-ShareAlike 4.0",
+   "urlEn": "https://creativecommons.org/licenses/by-sa/4.0/legalcode.en",
+   "api_rows": 10958,
+   "shipped": 10944
+  }
+ ],
+ "withheld": 83,
+ "withheld_reasons": {
+  "API: http404": 12,
+  "text prints a NonCommercial or NoDerivatives licence (maintainer decision 2026-10-06)": 56,
+  "text says it is reprinted or translated by permission of a publisher (maintainer decision 2026-10-06)": 15
+ },
+ "maintainer_decision": "2026-10-06 (polish-dynaword-v2#57, Hub PR 81): keep the 12 HTTP 404 rows withheld; relabel articles_2011995 to CC-BY-SA-4.0 and keep it; withhold 56 rows whose text prints an NC or ND licence and 15 rows whose text says it is reprinted or translated by permission of a publisher; keep rows whose wording is a citation, a quoted work's notice, prose about licence types, a permission for a figure or table, or a translation permitted by the author alone. The ids and one reason per id are in src/clean_biblioteka_nauki.py (TEXT_NC_ND, TEXT_REPRINT) and in the stats `withheld`.",
+ "flagged": {
+  "translationPublication": 3,
+  "reprintPublication": 2
+ },
+ "flagged_action": "kept; the flags (reprintPublication, translationPublication) are not a licence signal and restricted is set on no row",
+ "public_domain_mark": "3 rows (API licence id 22) already dropped in Hub PR 62; absent from the shard and from the sidecar",
+ "all_rights_reserved_text_phrase": {
+  "note": "Rows whose text contains the phrase. The earlier review counted 128 (88 cc-by, 40 cc-by-sa); this scan could not reproduce that exactly: four regex variants give 121, 126, 127 (87 CC BY, 40 CC BY-SA) and 137. Every one of them has a CC BY or CC BY-SA licence in the API; none is all-rights-reserved there. Kept; undecided. Counted on the 42,068 rows of Hub PR 62; of them 2 (cs) and 4 (ci, ws_ci) are among the 71 rows withheld on 2026-10-06, so the shipped shard has 119 / 122 / 123 (ws_ci_hyph not recomputed).",
+  "api_licenses_by_variant": {
+   "cs": {
+    "pattern": "case-sensitive 'Wszelkie prawa zastrzeżone' | 'All rights reserved'",
+    "rows": 121,
+    "api_licenses": {
+     "CC-BY-3.0-PL": 55,
+     "CC-BY-4.0": 29,
+     "CC-BY-SA-3.0-PL": 18,
+     "CC-BY-SA-4.0": 19
+    }
+   },
+   "ci": {
+    "pattern": "same, case-insensitive",
+    "rows": 126,
+    "api_licenses": {
+     "CC-BY-3.0-PL": 57,
+     "CC-BY-4.0": 30,
+     "CC-BY-SA-3.0-PL": 18,
+     "CC-BY-SA-4.0": 21
+    }
+   },
+   "ws_ci": {
+    "pattern": "case-insensitive, any whitespace between words (NFKC text)",
+    "rows": 127,
+    "api_licenses": {
+     "CC-BY-3.0-PL": 57,
+     "CC-BY-4.0": 30,
+     "CC-BY-SA-3.0-PL": 19,
+     "CC-BY-SA-4.0": 21
+    }
+   },
+   "ws_ci_hyph": {
+    "pattern": "as ws_ci, plus a hyphenated line break and 'wszystkie prawa zastrzeżone'",
+    "rows": 137,
+    "api_licenses": {
+     "CC-BY-3.0-PL": 59,
+     "CC-BY-4.0": 31,
+     "CC-BY-SA-3.0-PL": 24,
+     "CC-BY-SA-4.0": 23
+    }
+   }
+  }
+ },
+ "unchanged_vs_pr62": {
+  "pr62_parquet_sha256": "6b57b8eec198c9899198a73cea1af372df09b43783a49474a856ccbf83c97da4",
+  "rows_compared": 41985,
+  "rule": "same ids in the same order, same SHA-256 of every text, every column except `license` equal; digest from src/clean_biblioteka_nauki.py content_digest, taken over PR 62's rows minus the 83 withheld ids",
+  "content_sha256": "cc4ad9ce16aaef3c7bc5197743ad58182e3d5011f78cbf53896083e7a8541954"
+ },
+ "verified": [
+  "V: license object (id, iconId, nameEn, urlEn, creativeCommons) of all 42,068 rows fetched via the API on 2026-10-05/06; 42,056 answered 200, 12 answered 404 (re-asked once by hand, 404 again)",
+  "V: for each kept row the creativecommons.org URL, English name and icon agree and match the label recovered earlier",
+  "V: ids, order, text and all non-license columns equal to Hub PR 62 for the 41,985 shipped rows",
+  "V: the 3 Public Domain Mark ids are absent from the shard",
+  "V: the contract test asserts that none of the 71 text-based withheld ids is in the shard and that articles_2011995 is labelled CC-BY-SA-4.0"
+ ],
+ "inferred": [
+  "I: that the API `license` field states the licence the rights holder granted for the full text in the corpus"
+ ],
+ "not_checked": [
+  "Whether the licence field matches the licence printed in each PDF or publisher page; about 120 shipped texts contain 'all rights reserved' although the API says CC",
+  "Authors' and publishers' standing to license, and third-party material (figures, quotations) inside CC items",
+  "Why 12 records answer 404 now (deleted, withdrawn, or an API change) and why articles_2011995 changed from the earlier CC BY label to CC BY-SA 4.0",
+  "Whether the earlier licence recovery was run before a licence change on the platform: its date is not recorded",
+  "The text-assembly script of the v0.2.4 build is not in the repository; the text comes from the SpeakLeash redistribution (Hub PR 11) and how it was assembled was not re-verified",
+  "Attribution strings were not re-fetched in this change",
+  "Reprint / translation flagged rows (5) were not separately reviewed",
+  "The text-based withheld classes rest on one reader's pass over about 300 characters of context around regex hits (a CC licence URL or name with NC or ND; permission wording near 'reprint', 'translated', 'za zgodą'); other spellings, other languages and wordings the regexes do not match were not searched"
+ ]
+}

data/biblioteka_nauki/biblioteka_nauki.md

@@ -6,29 +6,62 @@ Biblioteka Nauki — Polish open-access scholarly corpus (scientific articles, b
 - **Source (upstream):** https://bibliotekanauki.pl (operated by ICM, University of Warsaw — Centrum Otwartej Nauki)
 - **Domain:** academic (scientific articles, books, chapters)
 - **Language:** Polish (pl)
-- **License:** per-document — CC BY 4.0 28,335 · CC BY-SA 4.0 13,733
+- **License:** per-document, with the version the upstream API gives for each record — CC BY (2.0, 3.0, 3.0 PL, 4.0) 28,280 · CC BY-SA (3.0, 3.0 PL, 4.0) 13,705; table below
 - **Created (range):** per-document publication year, from each item's bibliotekanauki.pl metadata
 - **Added:** 2026-06-27
 
 ## Licensing — traceable basis
-The SpeakLeash blob carries no per-document license field, and ~53% of the upstream collection is
-all-rights-reserved, so a per-item gate was mandatory. Each item's license was recovered from the
-bibliotekanauki.pl API (`bibliotekanauki.pl/api/{type}/<id>` → `license.iconId`). Only openly-licensed
-items are kept; all-rights-reserved and unknown items are gated out. Recovery yielded 43,576 clean ids.
+The upstream collection includes all-rights-reserved items, so a per-item gate is mandatory. Each row's
+licence was read from the bibliotekanauki.pl API (`bibliotekanauki.pl/api/{type}/{id}` → `license`:
+name, URL, icon) on 2026-10-05/06, one request per row of the previous release
+(`data/biblioteka_nauki/recover_license_versions.py`). The API responses are committed as
+`biblioteka_nauki.license-api.json`. The earlier recovery stored only `license.iconId` (`cc-by` /
+`cc-by-sa`), which drops the version, so v0.2.5 labelled every row 4.0 although the API gives 2.0, 3.0,
+3.0 PL and 4.0 (polish-dynaword-v2#57).
 
-| license | documents |
-|---|---:|
-| CC BY 4.0 | 28,335 |
-| CC BY-SA 4.0 | 13,733 |
+| `license` label | documents | API licence (`nameEn`) |
+|---|---:|---|
+| CC-BY-2.0 | 1 | CC BY: Creative Commons Attribution 2.0 Generic |
+| CC-BY-3.0 | 2,413 | CC BY: Creative Commons Attribution 3.0 Unported |
+| CC-BY-3.0-PL | 8,098 | CC BY: Creative Commons Attribution 3.0 PL |
+| CC-BY-4.0 | 17,768 | CC BY: Creative Commons Attribution 4.0 |
+| CC-BY-SA-3.0 | 7 | CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 Unported |
+| CC-BY-SA-3.0-PL | 2,754 | CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 PL |
+| CC-BY-SA-4.0 | 10,944 | CC BY-SA: Creative Commons Attribution-ShareAlike 4.0 |
 
-The per-document license is carried in the parquet `license` column.
+The label is carried in the parquet `license` column. `src/clean_biblioteka_nauki.py` accepts a row only
+when the API licence is a Creative Commons BY or BY-SA licence of version 2.0 to 4.0 (generic or the
+Polish port), its `creativecommons.org` URL, English name and icon agree, and the kind matches the
+label recovered earlier. Anything else is withheld, not guessed (12 rows the API now answers with
+HTTP 404). `articles_2011995` is the one row whose API licence (CC BY-SA 4.0) differs from the earlier
+recovery (CC BY); it is kept and labelled CC-BY-SA-4.0 (maintainer decision 2026-10-06). Only the
+`license` column differs from the previous release; ids, order and text are unchanged for the 41,985
+rows shipped.
 
 Three items labelled "Domena publiczna" were dropped for v0.2.6 (`src/clean_biblioteka_nauki.py`,
 polish-dynaword-v2#52): `books_2142716`, `books_2147851`, `articles_2097363` (376,155 tokens).
 Biblioteka Nauki gives them API licence id 22, the CC Public Domain Mark 1.0, which is a label, not a
 waiver or a licence. They are original works first published 2019-2022, so the Polish life+70 term has
-not run out, and `books_2147851` itself prints "Copyright by Jerzy Zając 2019". Only CC BY, CC BY-SA
-and CC0 values are kept; any other value fails the script.
+not run out, and `books_2147851` itself prints "Copyright by Jerzy Zając 2019".
+
+The API also flags 5 kept rows as a reprint (2) or translation (3) publication; none has `restricted`
+set. The licence check does not look at those flags.
+
+## Withheld rows
+83 of the 42,068 rows of the previous release are not shipped. The ids, with one reason per id, are in
+`biblioteka_nauki.stats.json` (`withheld`) and, for the two text-based classes, in
+`src/clean_biblioteka_nauki.py`, whose build fails if a listed id is not reached. The text-based
+classes were decided by the maintainer on 2026-10-06 (polish-dynaword-v2#57, Hub PR 81).
+
+| reason class | rows | what it is |
+|---|---:|---|
+| API HTTP 404 | 12 | the API no longer serves the record, so its licence cannot be confirmed; why is not known |
+| text prints a NonCommercial or NoDerivatives licence | 56 | the text itself (front matter, colophon or a licence URL) prints CC BY-NC, BY-NC-SA, BY-NC-ND or BY-ND while the API says CC BY or CC BY-SA: Krytyka Prawa 2019 (21), Journal of Health Sciences 2014 (12), 23 others |
+| text says it is reprinted or translated by permission of a publisher | 15 | "reprinted by permission of ..." on the whole text (Oxford University Press 3, other publishers or journals 12); nothing shows that the permission covers redistribution under CC |
+
+Rows are kept when the wording is only a citation, a quoted work's own notice, prose about licence
+types, a permission for a figure or table, or a translation permitted by the author alone. These
+readings are one reader's judgement of about 300 characters of context around each match.
 
 ## Attribution
 Per-document attribution (author · year · title · publisher) was re-fetched 1:1 from
@@ -36,14 +69,17 @@ bibliotekanauki.pl (43,576 / 43,576 ok) and is carried in the parquet `attributi
 satisfying the CC BY / CC BY-SA attribution requirement that applies to every document here.
 
 ## Provenance
-Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `biblioteka_nauki_pl_corpus`)
-of the upstream source above. SpeakLeash credited as intermediate aggregator; upstream license and
-attribution recovered per document and preserved.
+Text from the SpeakLeash redistribution; licence and attribution recovered per document from the
+Biblioteka Nauki API (Hub PR 11); assembly script not in the repository. Hub PR 11, which added this
+source, says the SpeakLeash blob has no per-document licence and that the Parquet ships ready-built;
+the key is `biblioteka_nauki_pl_corpus`. This release only filters and relabels the shipped Parquet
+(`src/clean_biblioteka_nauki.py`, pinned to the v0.2.5 file by SHA-256); how the text layer was
+assembled is not re-verified here.
 
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 42,068 | 1,747,387,478 | 673,112,676 |
+| 41,985 | 1,739,004,913 | 669,909,430 |
 
 ## Filters applied (build_dynaword.py)
 Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
@@ -52,15 +88,21 @@ Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - exact cross-source dedup (sha1): **180**
 - OCR alpha-ratio < 0.70 (OCR source): **400**
 - licence not an established grant, CC Public Domain Mark (`src/clean_biblioteka_nauki.py`): **3**
-- read 43,576 → kept 42,068
+- licence not confirmed by the API as an allowlisted CC BY / BY-SA version, HTTP 404 (`src/clean_biblioteka_nauki.py`): **12**
+- text prints a NonCommercial or NoDerivatives licence (`src/clean_biblioteka_nauki.py`): **56**
+- text says it is reprinted or translated by permission of a publisher (`src/clean_biblioteka_nauki.py`): **15**
+- read 43,576 → kept 41,985
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.
 
 ## Limitations
-- **Mixed license.** Roughly one third of the documents are CC BY-SA 4.0 (share-alike); the exact
-  per-document license is in the `license` column. Downstream redistribution must respect share-alike
-  for those documents.
+- **Mixed license.** Roughly one third of the documents are CC BY-SA (3.0, 3.0 PL or 4.0; share-alike);
+  the exact per-document licence and version is in the `license` column. Downstream redistribution must
+  respect share-alike for those documents, under their own version.
+- **Licence is the API's word.** About 120 texts contain the phrase "all rights reserved" although
+  their API licence is CC BY or CC BY-SA. The rows are kept; the conflict between a footer in the
+  extracted text and the platform's licence field is not resolved here.
 - **OCR / extraction noise.** Text is extracted from publisher PDFs; some layout and hyphenation
   artefacts remain after the alpha-ratio filter.
 - **Per-document dates.** `created` is the publication year from upstream metadata; finer-grained

data/biblioteka_nauki/biblioteka_nauki.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6b57b8eec198c9899198a73cea1af372df09b43783a49474a856ccbf83c97da4
-size 1075953966
+oid sha256:d829f835c20ec5ed578552b9adcea6a0de457404066734cec858cc7b57bfd768
+size 1070808754

data/biblioteka_nauki/biblioteka_nauki.stats.json

@@ -1,18 +1,112 @@
 {
   "read": 43576,
-  "kept": 42068,
+  "kept": 41985,
   "drop_short": 0,
   "drop_lang": 925,
   "drop_dup": 180,
   "drop_ocr": 400,
-  "chars": 1747387478,
-  "tokens": 673112676,
+  "chars": 1739004913,
+  "tokens": 669909430,
   "secs": 484.1,
-  "license": "CC-BY-4.0 / CC-BY-SA-4.0",
+  "license": "CC-BY-2.0 / CC-BY-3.0 / CC-BY-3.0-PL / CC-BY-4.0 / CC-BY-SA-3.0 / CC-BY-SA-3.0-PL / CC-BY-SA-4.0",
   "drop_rights": 3,
   "licenses": {
-    "cc-by": 28335,
-    "cc-by-sa": 13733
+    "CC-BY-2.0": 1,
+    "CC-BY-3.0": 2413,
+    "CC-BY-3.0-PL": 8098,
+    "CC-BY-4.0": 17768,
+    "CC-BY-SA-3.0": 7,
+    "CC-BY-SA-3.0-PL": 2754,
+    "CC-BY-SA-4.0": 10944
   },
-  "input_sha256": "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26"
+  "input_sha256": "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26",
+  "drop_license_unverified": 12,
+  "withheld": {
+    "biblioteka_nauki_articles_1032116": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032173": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032215": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032225": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032276": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032302": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032351": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032417": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032461": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032495": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032501": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1032509": "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence",
+    "biblioteka_nauki_articles_1191739": "the text prints CC BY-NC-SA 4.0",
+    "biblioteka_nauki_articles_1621507": "translated by permission of the author and the publisher (Darton, Longman and Todd)",
+    "biblioteka_nauki_articles_1622259": "reprinted by permission of the University of Arkansas Press, via The Permissions Company",
+    "biblioteka_nauki_articles_1622298": "Polish translation published by permission of the author and Oxford University Press; further reproduction needs the publisher's consent",
+    "biblioteka_nauki_articles_1917546": "translated and published by permission of the author and of the journal's publisher (Nova et Vetera)",
+    "biblioteka_nauki_articles_1963167": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963170": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963181": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963183": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963187": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963190": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963193": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1963195": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1964252": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1964253": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1964255": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1964257": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1966144": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1991243": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_1992050": "translated and published by permission of the author and of the journal's publisher (Nova et Vetera)",
+    "biblioteka_nauki_articles_2040728": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_2040731": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_2057193": "the text prints a CC-BY-NC-ND 4.0 licence URL",
+    "biblioteka_nauki_articles_2057203": "the text prints a CC-BY-NC-ND 4.0 licence URL",
+    "biblioteka_nauki_articles_2082818": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082821": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082824": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082827": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082829": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082837": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2082857": "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0",
+    "biblioteka_nauki_articles_2089605": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_2089606": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_2089607": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_2089616": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_486876": "the issue colophon prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_487021": "the text prints CC BY-NC-ND 4.0",
+    "biblioteka_nauki_articles_512191": "API: http404",
+    "biblioteka_nauki_articles_520085": "the text prints CC BY-NC-ND 2.0 and says it is translated by permission of the author",
+    "biblioteka_nauki_articles_604103": "API: http404",
+    "biblioteka_nauki_articles_605338": "API: http404",
+    "biblioteka_nauki_articles_623064": "reprinted by permission of Sage",
+    "biblioteka_nauki_articles_623121": "translated and reproduced with permission of International Affairs",
+    "biblioteka_nauki_articles_630597": "reprinted with the editors' permission",
+    "biblioteka_nauki_articles_634914": "translated and reprinted by permission of Oxford University Press (for the Oral History Association); limited-rights notice with a licence number",
+    "biblioteka_nauki_articles_634916": "translated and reprinted by permission of Oxford University Press (for the Oral History Association); limited-rights notice with a licence number",
+    "biblioteka_nauki_articles_634918": "reprinted from the Oral History Review by permission of the Oral History Association",
+    "biblioteka_nauki_articles_643727": "\"Reprinted by Permission of SAGE Publications\"",
+    "biblioteka_nauki_articles_643809": "\"Reprinted by Permission of SAGE Publications\"",
+    "biblioteka_nauki_articles_643825": "reprinted by permission of Indiana University Press",
+    "biblioteka_nauki_articles_694180": "reprinted by permission of Westview Press",
+    "biblioteka_nauki_articles_694689": "API: http404",
+    "biblioteka_nauki_articles_699376": "API: http404",
+    "biblioteka_nauki_articles_699392": "API: http404",
+    "biblioteka_nauki_articles_699396": "API: http404",
+    "biblioteka_nauki_articles_699422": "API: http404",
+    "biblioteka_nauki_articles_699424": "API: http404",
+    "biblioteka_nauki_articles_699432": "API: http404",
+    "biblioteka_nauki_articles_699440": "API: http404",
+    "biblioteka_nauki_articles_699442": "API: http404",
+    "biblioteka_nauki_books_1076493": "the colophon prints CC BY-NC-ND 3.0 PL",
+    "biblioteka_nauki_books_1191609": "the colophon prints CC BY-NC-ND 3.0 PL",
+    "biblioteka_nauki_books_1377755": "the colophon prints CC BY-NC-ND 3.0 PL",
+    "biblioteka_nauki_books_1396563": "the front page prints CC BY-NC-SA 4.0 (its colophon says CC BY-SA 4.0)",
+    "biblioteka_nauki_books_1396571": "the colophon prints CC BY-NC 3.0 PL",
+    "biblioteka_nauki_books_1409913": "the colophon prints CC BY-ND 3.0 PL",
+    "biblioteka_nauki_books_1788278": "the colophon prints CC BY-NC 3.0 PL; the text and the attribution field name different works",
+    "biblioteka_nauki_books_2010681": "the colophon prints a NonCommercial licence, contradicting its own CC BY-SA 4.0 abbreviation",
+    "biblioteka_nauki_books_2028459": "the text prints CC BY-NC-SA 4.0",
+    "biblioteka_nauki_books_2143725": "the text prints CC BY-NC 3.0 PL (its foreword says CC BY)",
+    "biblioteka_nauki_books_2159317": "the text prints CC BY-NC-SA 4.0"
+  },
+  "content_sha256": "cc4ad9ce16aaef3c7bc5197743ad58182e3d5011f78cbf53896083e7a8541954",
+  "drop_text_nc_nd": 56,
+  "drop_text_reprint": 15
 }

data/biblioteka_nauki/recover_license_versions.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Re-fetch the licence name, URL and version of every shipped Biblioteka Nauki row.
+
+recover_licenses.py kept only `license.iconId` (cc-by / cc-by-sa), which drops the licence version
+(polish-dynaword-v2#57). This asks `GET bibliotekanauki.pl/api/{type}/{id}` once per row of the
+shipped Parquet and stores the API's own `license` object. It judges nothing: the allowlist and the
+fail-closed handling live in src/clean_biblioteka_nauki.py.
+
+Polite by construction: one global request clock (`--interval`), a few workers, back-off on
+429/5xx and connection errors (Retry-After honoured), and a circuit breaker. The run stops, and
+exits 2, on a 403, on a 200 that is not the JSON record (an interstitial or CAPTCHA page), or after
+`--max-failures` consecutive requests that exhausted their retries. It never works around a block.
+The cache is append-only JSONL, so a stopped run resumes where it left off.
+
+  python3 data/biblioteka_nauki/recover_license_versions.py fetch  --cache CACHE.jsonl --parquet SHARD
+  python3 data/biblioteka_nauki/recover_license_versions.py export --cache CACHE.jsonl --parquet SHARD
+
+The committed sidecar covers the 42,068 rows of the shard before the 13 unverifiable rows were withheld
+(Hub PR 62, SHA-256 6b57b8eec198c9899198a73cea1af372df09b43783a49474a856ccbf83c97da4). Pass that file as
+SHARD to reproduce it; the default, the shipped shard, no longer has those 13 rows.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import sys
+import threading
+import time
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import requests
+
+SOURCE = "biblioteka_nauki"
+HERE = Path(__file__).resolve().parent
+PARQUET = HERE / f"{SOURCE}.parquet"
+SIDECAR = HERE / f"{SOURCE}.license-api.json"
+API = "https://bibliotekanauki.pl/api/{type}/{id}"
+USER_AGENT = "polish-dynaword-rights-recheck/1.0 (+https://huggingface.co/datasets/SlayerLab/polish-dynaword)"
+ROW_ID = re.compile(rf"^{SOURCE}_(articles|books|chapters)_(\d+)$")
+FINAL = {"ok", "http404", "http410", "id_mismatch"}  # a restart does not ask again
+FLAGS = ("restricted", "reprintPublication", "translationPublication")
+LICENSE_FIELDS = ("id", "iconId", "nameEn", "urlEn", "creativeCommons")
+MAX_RETRY = 6
+
+
+class Blocked(Exception):
+    """The host refused us or answered with something other than the JSON record. Stop and report."""
+
+
+def parse_row_id(row_id: str) -> tuple[str, int]:
+    match = ROW_ID.match(row_id)
+    if not match:
+        raise ValueError(f"not a {SOURCE} row id: {row_id!r}")
+    return match.group(1), int(match.group(2))
+
+
+class Clock:
+    """Hands out request slots at least `interval` seconds apart across all threads."""
+
+    def __init__(self, interval: float):
+        self.interval, self._next, self._lock = interval, 0.0, threading.Lock()
+
+    def wait(self) -> None:
+        with self._lock:
+            now = time.monotonic()
+            slot = max(now, self._next)
+            self._next = slot + self.interval
+        time.sleep(max(0.0, slot - now))
+
+
+def fetch_one(session, clock: Clock, row_id: str, sleep=time.sleep) -> dict | None:
+    """One cache line for `row_id`, or None when retries ran out (not final, asked again on restart)."""
+    typ, num = parse_row_id(row_id)
+    for attempt in range(MAX_RETRY):
+        clock.wait()
+        try:
+            resp = session.get(API.format(type=typ, id=num), timeout=30)
+        except requests.RequestException:
+            sleep(min(2 ** attempt, 60) + random.random())
+            continue
+        if resp.status_code in (404, 410):
+            return {"id": row_id, "status": f"http{resp.status_code}", "license": None, "flags": []}
+        if resp.status_code == 403:
+            raise Blocked(f"HTTP 403 on {row_id}")
+        if resp.status_code == 429 or resp.status_code >= 500:
+            retry_after = resp.headers.get("Retry-After", "")
+            sleep(float(retry_after) if retry_after.isdigit() else min(2 ** attempt, 60) + random.random())
+            continue
+        if resp.status_code != 200:
+            raise Blocked(f"HTTP {resp.status_code} on {row_id}")
+        try:
+            record = resp.json()
+        except ValueError:
+            raise Blocked(f"HTTP 200 but not JSON on {row_id}: {resp.text[:80]!r}") from None
+        if not isinstance(record, dict) or "license" not in record:
+            raise Blocked(f"HTTP 200 but no `license` key on {row_id}")
+        lic = record["license"]
+        return {
+            "id": row_id,
+            "status": "ok" if record.get("id") == num else "id_mismatch",
+            "api_id": record.get("id"),
+            "license": {k: lic.get(k) for k in LICENSE_FIELDS} if isinstance(lic, dict) else None,
+            "flags": [k for k in FLAGS if record.get(k)],
+            "fetched": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
+        }
+    return None
+
+
+def read_cache(path: Path) -> dict[str, dict]:
+    cache: dict[str, dict] = {}
+    if path.exists():
+        for line in path.read_text(encoding="utf-8").splitlines():
+            if line.strip():
+                row = json.loads(line)
+                cache[row["id"]] = row
+    return cache
+
+
+def fetch(args) -> int:
+    ids = pq.read_table(args.parquet, columns=["id"]).column("id").to_pylist()
+    cache = read_cache(args.cache)
+    pending = [i for i in ids if cache.get(i, {}).get("status") not in FINAL]
+    todo = pending[: args.limit]
+    print(f"rows={len(ids)} cached={len(ids) - len(pending)} todo={len(todo)} "
+          f"workers={args.workers} interval={args.interval}s", flush=True)
+    session_local, clock, lock = threading.local(), Clock(args.interval), threading.Lock()
+    state = {"done": 0, "failures": 0, "stop": None}
+    counts: Counter = Counter()
+    started = time.time()
+    out = args.cache.open("a", encoding="utf-8")
+
+    def work(row_id: str) -> None:
+        if state["stop"]:
+            return
+        if not hasattr(session_local, "s"):
+            session_local.s = requests.Session()
+            session_local.s.headers.update({"User-Agent": USER_AGENT, "Accept": "application/json"})
+        try:
+            line = fetch_one(session_local.s, clock, row_id)
+        except Blocked as exc:
+            state["stop"] = str(exc)
+            return
+        with lock:
+            if line is None:
+                state["failures"] += 1
+                if state["failures"] >= args.max_failures:
+                    state["stop"] = f"{state['failures']} consecutive requests exhausted their retries"
+                return
+            state["failures"] = 0
+            out.write(json.dumps(line, ensure_ascii=False) + "\n")
+            counts[line["status"]] += 1
+            state["done"] += 1
+            if state["done"] % 500 == 0:
+                out.flush()
+                rate = state["done"] / (time.time() - started)
+                print(f"{state['done']}/{len(todo)}  {rate:.1f}/s  ETA {(len(todo) - state['done']) / rate / 60:.0f}m  "
+                      f"{dict(counts)}", flush=True)
+
+    try:
+        with ThreadPoolExecutor(max_workers=args.workers) as pool:
+            list(pool.map(work, todo))
+    finally:
+        out.close()
+    print(f"fetched {state['done']} of {len(todo)}  {dict(counts)}", flush=True)
+    if state["stop"]:
+        print(f"STOPPED: {state['stop']}. Not retrying; report to the maintainer. Rerun resumes.", file=sys.stderr)
+        return 2
+    return 0
+
+
+def export(args) -> int:
+    ids = pq.read_table(args.parquet, columns=["id"]).column("id").to_pylist()
+    cache = read_cache(args.cache)
+    if missing := [i for i in ids if cache.get(i, {}).get("status") not in FINAL]:
+        raise SystemExit(f"{len(missing)} rows not fetched yet, e.g. {missing[:3]}; run `fetch` first")
+    licenses: dict[str, dict] = {}
+    rows: dict[str, int] = {}
+    unresolved: dict[str, str] = {}
+    flagged: dict[str, list[str]] = {}
+    for row_id in ids:
+        line = cache[row_id]
+        if line["flags"]:
+            flagged[row_id] = line["flags"]
+        lic = line["license"]
+        if line["status"] != "ok":
+            unresolved[row_id] = line["status"]
+        elif not lic or lic.get("id") is None:
+            unresolved[row_id] = "no_license"
+        else:
+            key = str(lic["id"])
+            if licenses.setdefault(key, lic) != lic:
+                raise SystemExit(f"API licence id {key} came back with two different bodies: {licenses[key]} vs {lic}")
+            rows[row_id] = lic["id"]
+    dates = sorted({line["fetched"] for line in cache.values() if line.get("fetched")})
+    sidecar = {
+        "api": API,
+        "retrieved": dates[0] if len(dates) == 1 else f"{dates[0]}..{dates[-1]}",
+        "rows_total": len(ids),
+        "licenses": dict(sorted(licenses.items(), key=lambda kv: int(kv[0]))),
+        "unresolved": unresolved,
+        "flagged": flagged,
+        "rows": rows,
+    }
+    tmp = args.out.with_name(args.out.name + ".tmp")
+    tmp.write_text(json.dumps(sidecar, ensure_ascii=False, separators=(",", ":")) + "\n", encoding="utf-8")
+    os.replace(tmp, args.out)
+    print(f"{args.out}: {len(rows)} rows, {len(licenses)} licences, {len(unresolved)} unresolved, {len(flagged)} flagged")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    for name, fn in (("fetch", fetch), ("export", export)):
+        p = sub.add_parser(name)
+        p.add_argument("--parquet", type=Path, default=PARQUET)
+        p.add_argument("--cache", type=Path, required=True)
+        p.set_defaults(fn=fn)
+        if name == "fetch":
+            p.add_argument("--workers", type=int, default=3)
+            p.add_argument("--interval", type=float, default=0.15, help="seconds between request starts, all workers")
+            p.add_argument("--max-failures", type=int, default=10)
+            p.add_argument("--limit", type=int, default=None, help="fetch at most this many rows (smoke test)")
+        else:
+            p.add_argument("--out", type=Path, default=SIDECAR)
+    args = parser.parse_args()
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/clean_biblioteka_nauki.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Drop Biblioteka Nauki rows whose licence is not an established grant.
+"""Drop Biblioteka Nauki rows whose licence is not an established grant, and label the rest per record.
 
 Kept: `cc-by`, `cc-by-sa` and `cc0` (none in v0.2.5), the per-item Creative Commons licence read from
 bibliotekanauki.pl/api/{type}/{id} (`license.iconId`) by data/biblioteka_nauki/recover_licenses.py.
@@ -9,6 +9,24 @@ a waiver or a licence, and the 3 tagged items are original works first published
 the Polish life+70 term cannot have run out (polish-dynaword-v2#52,
 artifacts/rights_audit_2026-10/reports/academic.md). Any other licence value fails the run.
 
+Relabel (polish-dynaword-v2#57): `iconId` drops the licence version, so v0.2.5 and the first v0.2.6
+build said cc-by / cc-by-sa while the API gives 2.0, 3.0, 3.0 PL and 4.0. The `license` column now
+carries the API's own licence, e.g. `CC-BY-3.0-PL`, read from the sidecar
+data/biblioteka_nauki/biblioteka_nauki.license-api.json (written by recover_license_versions.py from one
+API call per row). Only CC BY / CC BY-SA 2.0-4.0, generic or Poland port, whose URL, name and icon agree
+with each other and with the stored label are labelled. A row the API did not resolve, or whose licence is
+anything else, is withheld (dropped and listed in stats `withheld`), never kept under a guessed label.
+No other column changes.
+
+Maintainer decisions of 2026-10-06 (polish-dynaword-v2#57, Hub PR 81), applied by id, one reason per id:
+  API_OVERRIDES   `articles_2011995` is labelled with the API's current CC BY-SA 4.0 although the earlier
+                  recovery stored cc-by; the row is kept.
+  TEXT_NC_ND      56 rows whose own text prints a NonCommercial and/or NoDerivatives licence while the API
+                  says CC BY or CC BY-SA. Withheld.
+  TEXT_REPRINT    15 rows whose text says it is a translation or reprint published by a publisher's
+                  permission (Oxford University Press and 12 other publishers or journals). Withheld.
+The build fails if a listed id is not reached, i.e. not among the rows that would otherwise be kept.
+
 The v0.2.4 assembly script (build_parquet.py) was never committed, so this filters the shipped
 v0.2.5 Parquet, pinned by SHA-256, and updates the stats file in place. Rerun:
   git checkout v0.2.5 -- data/biblioteka_nauki/biblioteka_nauki.parquet
@@ -20,6 +38,7 @@ import argparse
 import hashlib
 import json
 import os
+import re
 from collections import Counter
 from pathlib import Path
 
@@ -32,6 +51,58 @@ DATA = Path(__file__).resolve().parents[1] / "data" / SOURCE
 INPUT_SHA256 = "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26"  # v0.2.5
 KEEP = {"cc-by", "cc-by-sa", "cc0"}  # = CLEAN in data/biblioteka_nauki/recover_attribution.py
 DROP = {"public-domain"}  # CC Public Domain Mark: a label, not a grant (see docstring)
+SIDECAR = DATA / f"{SOURCE}.license-api.json"
+# creativecommons.org/licenses/by/3.0/pl/legalcode, .../by-sa/4.0/legalcode.en, .../by/2.0/legalcode
+LICENSE_URL = re.compile(r"^https://creativecommons\.org/licenses/(by|by-sa)/(\d\.\d)/(?:([a-z]{2})/)?legalcode(?:\.[a-z]{2})?$")
+VERSIONS = {"2.0", "2.5", "3.0", "4.0"}
+JURISDICTIONS = {None, "pl"}  # None = generic / Unported
+API_OVERRIDES = {f"{SOURCE}_articles_2011995": "CC-BY-SA-4.0"}  # {id: label the API's own licence must give}
+
+
+def _group(kind: str, numbers: str, reason: str) -> dict[str, str]:
+    return {f"{SOURCE}_{kind}_{number}": reason for number in numbers.split()}
+
+
+# Printed licence read in the text (front or back matter) against a CC BY / CC BY-SA API label.
+TEXT_NC_ND = {
+    **_group("articles", "1966144 2082824 1963195 1964252 1963167 1963170 1963181 1963183 1963187 1964253 1964257 "
+             "2082818 2082821 2082837 1963190 1991243 2082827 2082829 1964255 2082857 1963193",
+             "Krytyka Prawa 2019: the text prints CC BY-NC-ND 3.0"),
+    **_group("articles", "1032417 1032173 1032302 1032215 1032351 1032276 1032116 1032495 1032509 1032225 1032501 1032461",
+             "Journal of Health Sciences 2014 (Radom): the text prints the Creative Commons Attribution Noncommercial licence"),
+    **_group("articles", "2040728 2040731 2089607 2089605 2089606 2089616", "the text prints CC BY-NC-ND 4.0"),
+    **_group("articles", "2057203 2057193", "the text prints a CC-BY-NC-ND 4.0 licence URL"),
+    **_group("articles", "486876", "the issue colophon prints CC BY-NC-ND 4.0"),
+    **_group("articles", "520085", "the text prints CC BY-NC-ND 2.0 and says it is translated by permission of the author"),
+    **_group("articles", "1191739", "the text prints CC BY-NC-SA 4.0"),
+    **_group("articles", "487021", "the text prints CC BY-NC-ND 4.0"),
+    **_group("books", "1076493 1377755 1191609", "the colophon prints CC BY-NC-ND 3.0 PL"),
+    **_group("books", "1788278", "the colophon prints CC BY-NC 3.0 PL; the text and the attribution field name different works"),
+    **_group("books", "1396571", "the colophon prints CC BY-NC 3.0 PL"),
+    **_group("books", "1409913", "the colophon prints CC BY-ND 3.0 PL"),
+    **_group("books", "2010681", "the colophon prints a NonCommercial licence, contradicting its own CC BY-SA 4.0 abbreviation"),
+    **_group("books", "2159317 2028459", "the text prints CC BY-NC-SA 4.0"),
+    **_group("books", "2143725", "the text prints CC BY-NC 3.0 PL (its foreword says CC BY)"),
+    **_group("books", "1396563", "the front page prints CC BY-NC-SA 4.0 (its colophon says CC BY-SA 4.0)"),
+}
+# The text says it was translated or reprinted by permission of a publisher or journal; nothing shows that permission
+# covers redistribution under CC BY / BY-SA.
+TEXT_REPRINT = {
+    **_group("articles", "634914 634916", "translated and reprinted by permission of Oxford University Press (for the Oral History Association); "
+             "limited-rights notice with a licence number"),
+    **_group("articles", "1622298", "Polish translation published by permission of the author and Oxford University Press; "
+             "further reproduction needs the publisher's consent"),
+    **_group("articles", "1622259", "reprinted by permission of the University of Arkansas Press, via The Permissions Company"),
+    **_group("articles", "1621507", "translated by permission of the author and the publisher (Darton, Longman and Todd)"),
+    **_group("articles", "623064", "reprinted by permission of Sage"),
+    **_group("articles", "623121", "translated and reproduced with permission of International Affairs"),
+    **_group("articles", "643727 643809", "\"Reprinted by Permission of SAGE Publications\""),
+    **_group("articles", "643825", "reprinted by permission of Indiana University Press"),
+    **_group("articles", "694180", "reprinted by permission of Westview Press"),
+    **_group("articles", "630597", "reprinted with the editors' permission"),
+    **_group("articles", "634918", "reprinted from the Oral History Review by permission of the Oral History Association"),
+    **_group("articles", "1917546 1992050", "translated and published by permission of the author and of the journal's publisher (Nova et Vetera)"),
+}
 
 
 def filter_table(table: pa.Table) -> pa.Table:
@@ -41,30 +112,119 @@ def filter_table(table: pa.Table) -> pa.Table:
     return table.filter(pc.is_in(table.column("license"), pa.array(sorted(KEEP))))
 
 
+def license_label(api_license: dict, stored: str) -> str:
+    """SPDX-style label (CC-BY-3.0-PL) for one API licence object. Raises ValueError, with the reason, unless it
+    is an allowlisted CC BY / BY-SA whose URL, English name and icon agree with each other and with `stored`."""
+    if not api_license.get("creativeCommons"):
+        raise ValueError(f"API licence {api_license.get('id')} is not marked creativeCommons")
+    match = LICENSE_URL.match(api_license.get("urlEn") or "")
+    if not match:
+        raise ValueError(f"licence URL not allowlisted: {api_license.get('urlEn')!r}")
+    kind, version, port = match.groups()
+    if version not in VERSIONS or port not in JURISDICTIONS:
+        raise ValueError(f"licence version/port not allowlisted: {api_license['urlEn']!r}")
+    name = api_license.get("nameEn") or ""
+    if f" {version}" not in name or (port and f" {port.upper()}" not in name):
+        raise ValueError(f"licence name {name!r} disagrees with URL {api_license['urlEn']!r}")
+    if not (api_license.get("iconId") == stored == f"cc-{kind}"):
+        raise ValueError(f"API icon {api_license.get('iconId')!r}, URL kind {kind!r} and stored {stored!r} disagree")
+    return f"CC-{kind.upper()}-{version}" + (f"-{port.upper()}" if port else "")
+
+
+def relabel(table: pa.Table, sidecar: dict, overrides: dict[str, str] | None = None) -> tuple[pa.Table, dict[str, str]]:
+    """Versioned `license` for every row from the API sidecar. Returns the table without withheld rows and
+    {id: reason} for them. Fails closed: unresolved, missing or non-allowlisted rows are withheld. Only `license` changes.
+    A row in `overrides` is labelled from its API licence alone (the earlier stored label may differ), which must
+    give the listed label; the run fails if such a row is not reached (absent, unresolved or not in the sidecar)."""
+    overrides = overrides or {}
+    ids, stored = table.column("id").to_pylist(), table.column("license").to_pylist()
+    reached: set[str] = set()
+    resolved: dict[tuple[int, str], str | None] = {}  # (API licence id, stored label) -> label, None = withheld
+    reasons: dict[tuple[int, str], str] = {}
+    new, withheld = [], {}
+    for row_id, old in zip(ids, stored):
+        label = None
+        if row_id in sidecar["unresolved"]:
+            withheld[row_id] = f"API: {sidecar['unresolved'][row_id]}"
+        elif row_id not in sidecar["rows"]:
+            withheld[row_id] = "not in the API sidecar"
+        elif row_id in overrides:
+            reached.add(row_id)
+            api_license = sidecar["licenses"][str(sidecar["rows"][row_id])]
+            label = license_label(api_license, api_license["iconId"])
+            if label != overrides[row_id]:
+                raise SystemExit(f"{row_id}: the API gives {label}, the override expects {overrides[row_id]}")
+        else:
+            key = (sidecar["rows"][row_id], old)
+            if key not in resolved:
+                try:
+                    resolved[key] = license_label(sidecar["licenses"][str(key[0])], old)
+                except ValueError as exc:
+                    resolved[key], reasons[key] = None, str(exc)
+            label = resolved[key]
+            if label is None:
+                withheld[row_id] = reasons[key]
+        new.append(label)
+    if unreached := sorted(set(overrides) - reached):
+        raise SystemExit(f"override ids not reached: {unreached}")
+    index = table.schema.get_field_index("license")
+    relabelled = table.set_column(index, table.schema.field(index), pa.array(new, pa.string()))
+    return relabelled.filter(pa.array([label is not None for label in new])), withheld
+
+
+def withhold_listed(table: pa.Table, listed: dict[str, str]) -> tuple[pa.Table, dict[str, str]]:
+    """The table without the rows in `listed` ({id: reason}). Fails if a listed id is not in `table`."""
+    if unreached := sorted(set(listed) - set(table.column("id").to_pylist())):
+        raise SystemExit(f"listed ids not reached: {unreached}")
+    return table.filter(pc.invert(pc.is_in(table.column("id"), pa.array(sorted(listed), pa.string())))), dict(listed)
+
+
+def content_digest(path: Path, skip: frozenset[str] = frozenset()) -> str:
+    """SHA-256 over every (id, SHA-256 of text) in file order, minus ids in `skip`. Equal digests mean the same
+    rows in the same order with the same text, whatever the other columns say."""
+    digest = hashlib.sha256()
+    for batch in pq.ParquetFile(path).iter_batches(columns=["id", "text"], batch_size=2000):
+        for row_id, text in zip(batch.column("id").to_pylist(), batch.column("text").to_pylist()):
+            if row_id not in skip:
+                digest.update(f"{row_id}\t{hashlib.sha256(text.encode()).hexdigest()}\n".encode())
+    return digest.hexdigest()
+
+
 def build(input_path: Path, out_dir: Path) -> dict:
     with input_path.open("rb") as stream:
         if hashlib.file_digest(stream, "sha256").hexdigest() != INPUT_SHA256:
             raise SystemExit(f"{input_path} is not the v0.2.5 Parquet; restore it with "
                              f"`git checkout v0.2.5 -- data/{SOURCE}/{SOURCE}.parquet`")
     table = pq.read_table(input_path)
-    kept = filter_table(table)
-    dropped = sorted(set(table.column("id").to_pylist()) - set(kept.column("id").to_pylist()))
+    granted = filter_table(table)
+    dropped = sorted(set(table.column("id").to_pylist()) - set(granted.column("id").to_pylist()))
+    labelled, api_withheld = relabel(granted, json.loads(SIDECAR.read_text(encoding="utf-8")), API_OVERRIDES)
+    labelled, nc_nd = withhold_listed(labelled, TEXT_NC_ND)
+    kept, reprint = withhold_listed(labelled, TEXT_REPRINT)
+    withheld = {**api_withheld, **nc_nd, **reprint}
+    assert len(withheld) == len(api_withheld) + len(nc_nd) + len(reprint)
 
     stats_path = out_dir / f"{SOURCE}.stats.json"
     stats = json.loads(stats_path.read_text(encoding="utf-8"))  # keeps build_dynaword's read/drop_* counts
     stats.update(
         kept=kept.num_rows,
-        drop_rights=table.num_rows - kept.num_rows,
+        drop_rights=table.num_rows - granted.num_rows,
+        drop_license_unverified=len(api_withheld),
+        drop_text_nc_nd=len(nc_nd),
+        drop_text_reprint=len(reprint),
         chars=pc.sum(pc.utf8_length(kept.column("text"))).as_py(),
         tokens=pc.sum(kept.column("token_count")).as_py(),
+        license=" / ".join(sorted(set(kept.column("license").to_pylist()))),
         licenses=dict(sorted(Counter(kept.column("license").to_pylist()).items())),
+        withheld=dict(sorted(withheld.items())),
         input_sha256=INPUT_SHA256,
     )
     parquet_tmp = out_dir / f"{SOURCE}.parquet.tmp"
     stats_tmp = out_dir / f"{SOURCE}.stats.json.tmp"
     pq.write_table(kept, parquet_tmp)
-    stats_tmp.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     os.replace(parquet_tmp, out_dir / f"{SOURCE}.parquet")
+    stats["content_sha256"] = content_digest(out_dir / f"{SOURCE}.parquet")
+    stats_tmp.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     os.replace(stats_tmp, stats_path)
     return {**stats, "dropped_ids": dropped}
 

src/sources.py

@@ -717,15 +717,30 @@ SOURCES = {
         "pretty": "Biblioteka Nauki",
         "license": "per-record upstream license",
         "license_spdx": "MIXED",
-        "traceable": "Documents are accepted only when the direct upstream record "
-                     "exposes a reusable license. The parquet carries the "
-                     "per-document `license` and `author` fields from the upstream "
-                     "metadata collected by the source-specific rebuild script.",
+        "traceable": "Every retained row carries the licence name and version that the "
+                     "Biblioteka Nauki API gave for that record on 2026-10-05/06 "
+                     "(CC BY 2.0, 3.0, 3.0 PL, 4.0; CC BY-SA 3.0, 3.0 PL, 4.0), checked "
+                     "against the licence URL and icon. The API licence objects are "
+                     "committed as biblioteka_nauki.license-api.json.",
         "upstream": "https://bibliotekanauki.pl/",
-        "provenance": "Fetched directly from Biblioteka Nauki via the contributor "
-                      "rebuild script, not from the SpeakLeash redistribution. "
-                      "License and author metadata are checked document by document "
-                      "before normalization into the DynaWord schema.",
+        "provenance": "Text from the SpeakLeash redistribution; licence and attribution "
+                      "recovered per document from the Biblioteka Nauki API (Hub PR 11); "
+                      "assembly script not in the repository. The per-record values come from "
+                      "bibliotekanauki.pl/api/{type}/{id} "
+                      "(recover_license_versions.py, recover_attribution.py); rows the API "
+                      "did not resolve to an allowlisted CC BY or CC BY-SA licence are "
+                      "withheld by clean_biblioteka_nauki.py.",
+        "legal_note": "The `license` column holds the per-record version, not a single "
+                      "CC BY 4.0 / CC BY-SA 4.0 label: CC BY-SA rows (about one third) are "
+                      "share-alike under their own version (3.0, 3.0 PL or 4.0). Dropped: "
+                      "3 items carrying the CC Public Domain Mark (a label, not a grant; "
+                      "v2#52), 12 rows the API no longer serves (HTTP 404), 56 rows whose own "
+                      "text prints a NonCommercial or NoDerivatives licence and 15 rows whose "
+                      "text says it is reprinted or translated by permission of a publisher "
+                      "(maintainer decision 2026-10-06, v2#57). About 120 texts contain the "
+                      "phrase \"all rights reserved\" although their API licence is CC; that is "
+                      "not resolved here. How the text layer was assembled from the SpeakLeash "
+                      "blob is not re-verified: the assembly script was not committed.",
         "domain": "academic",
         "created": "unknown",
         "is_ocr": False,

src/test_biblioteka_nauki_contract.py

@@ -1,7 +1,10 @@
-"""Contract checks for biblioteka_nauki after the public-domain drop (src/clean_biblioteka_nauki.py)."""
+"""Contract checks for biblioteka_nauki: public-domain drop, per-record licence versions and the withheld rows
+(src/clean_biblioteka_nauki.py, data/biblioteka_nauki/recover_license_versions.py)."""
 
+import hashlib
 import importlib.util
 import json
+import re
 import sys
 from collections import Counter
 from pathlib import Path
@@ -13,17 +16,53 @@ import pytest
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
-from clean_biblioteka_nauki import DATA, KEEP, filter_table
+from clean_biblioteka_nauki import (
+    API_OVERRIDES, DATA, KEEP, SIDECAR, TEXT_NC_ND, TEXT_REPRINT, content_digest, filter_table, license_label, relabel,
+    withhold_listed)
+from sources import SOURCES
 
 PUBLIC_DOMAIN_MARK_IDS = {
     "biblioteka_nauki_books_2142716",
     "biblioteka_nauki_books_2147851",
     "biblioteka_nauki_articles_2097363",
 }
+PROVENANCE = (
+    "text from the speakleash redistribution; licence and attribution recovered per document "
+    "from the biblioteka nauki api (hub pr 11); assembly script not in the repository"
+)
+RELABELLED_ID = "biblioteka_nauki_articles_2011995"
+LABEL = re.compile(r"^CC-(BY|BY-SA)-(2\.0|2\.5|3\.0|4\.0)(-PL)?$")
 
 
-def test_shard_has_no_public_domain_rows_and_matches_stats():
-    stats = json.loads((DATA / "biblioteka_nauki.stats.json").read_text(encoding="utf-8"))
+def load_script(name):
+    spec = importlib.util.spec_from_file_location(name, DATA / f"{name}.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def api_license(lid, icon, version, url, port=""):
+    kind = "BY-SA: Creative Commons Attribution-ShareAlike" if icon == "cc-by-sa" else "BY: Creative Commons Attribution"
+    return {"id": lid, "iconId": icon, "nameEn": f"CC {kind} {version}{port}", "urlEn": url, "creativeCommons": True}
+
+
+BY_30_PL = api_license(7, "cc-by", "3.0", "https://creativecommons.org/licenses/by/3.0/pl/legalcode", " PL")
+BY_40 = api_license(1, "cc-by", "4.0", "https://creativecommons.org/licenses/by/4.0/legalcode.en")
+BYSA_40 = api_license(2, "cc-by-sa", "4.0", "https://creativecommons.org/licenses/by-sa/4.0/legalcode.en")
+BY_20 = api_license(21, "cc-by", "2.0 Generic", "https://creativecommons.org/licenses/by/2.0/legalcode")
+
+
+@pytest.fixture(scope="module")
+def stats():
+    return json.loads((DATA / "biblioteka_nauki.stats.json").read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="module")
+def sidecar():
+    return json.loads(SIDECAR.read_text(encoding="utf-8"))
+
+
+def test_shard_has_no_public_domain_rows_and_matches_stats(stats):
     path = DATA / "biblioteka_nauki.parquet"
     assert pq.read_schema(path).names == [
         "id", "text", "source", "added", "created", "token_count", "license", "attribution"]
@@ -31,27 +70,116 @@ def test_shard_has_no_public_domain_rows_and_matches_stats():
     ids = table.column("id").to_pylist()
     licenses = Counter(table.column("license").to_pylist())
 
-    assert table.num_rows == stats["kept"] == 42_068
+    assert table.num_rows == stats["kept"]
     assert len(set(ids)) == len(ids)
     assert not PUBLIC_DOMAIN_MARK_IDS & set(ids)
-    assert "public-domain" not in licenses
-    assert licenses == stats["licenses"] == {"cc-by": 28_335, "cc-by-sa": 13_733}
+    assert licenses == stats["licenses"]
+    assert all(LABEL.match(label) for label in licenses), licenses
     assert set(table.column("source").to_pylist()) == {"biblioteka_nauki"}
     assert pc.sum(table.column("token_count")).as_py() == stats["tokens"]
     assert pc.min(table.column("token_count")).as_py() > 0
     assert all(a and a.strip() for a in table.column("attribution").to_pylist())
-    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_rights")
+    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_rights",
+             "drop_license_unverified", "drop_text_nc_nd", "drop_text_reprint")
     assert stats["read"] - sum(stats[k] for k in drops) == stats["kept"]
     assert stats["drop_rights"] == 3
+    assert stats["drop_license_unverified"] + stats["drop_text_nc_nd"] + stats["drop_text_reprint"] == len(stats["withheld"])
 
 
-def test_datasheet_counts_match_stats():
-    stats = json.loads((DATA / "biblioteka_nauki.stats.json").read_text(encoding="utf-8"))
+def test_maintainer_withholds_and_relabel_of_2026_10_06(stats):
+    """Hub PR 81: 12 API 404s, 56 NC/ND rows and 15 reprint-by-permission rows are out; articles_2011995 stays, as CC BY-SA 4.0."""
+    table = pq.read_table(DATA / "biblioteka_nauki.parquet", columns=["id", "license"])
+    labels = dict(zip(table.column("id").to_pylist(), table.column("license").to_pylist()))
+    assert (len(TEXT_NC_ND), len(TEXT_REPRINT)) == (56, 15) and not set(TEXT_NC_ND) & set(TEXT_REPRINT)
+    assert not (set(TEXT_NC_ND) | set(TEXT_REPRINT)) & set(labels)
+    assert {i: stats["withheld"][i] for i in TEXT_NC_ND} == TEXT_NC_ND
+    assert {i: stats["withheld"][i] for i in TEXT_REPRINT} == TEXT_REPRINT
+    assert all(reason.strip() for reason in stats["withheld"].values())
+    api = {i: reason for i, reason in stats["withheld"].items() if i not in TEXT_NC_ND and i not in TEXT_REPRINT}
+    assert len(api) == stats["drop_license_unverified"] == 12 and set(api.values()) == {"API: http404"}
+    assert (stats["drop_text_nc_nd"], stats["drop_text_reprint"]) == (56, 15)
+    assert API_OVERRIDES == {RELABELLED_ID: "CC-BY-SA-4.0"}
+    assert labels[RELABELLED_ID] == "CC-BY-SA-4.0" and RELABELLED_ID not in stats["withheld"]
+    assert stats["kept"] == 42055 + 1 - 71
+
+
+def test_shard_labels_are_the_api_licences_in_the_sidecar(stats, sidecar):
+    """Every row's label is the one its API licence gives, and every shipped or withheld id is in the sidecar."""
+    table = pq.read_table(DATA / "biblioteka_nauki.parquet", columns=["id", "license"])
+    ids = table.column("id").to_pylist()
+    for row_id, label in zip(ids, table.column("license").to_pylist()):
+        lic = sidecar["licenses"][str(sidecar["rows"][row_id])]
+        assert label == license_label(lic, lic["iconId"]), row_id
+    assert not set(ids) & set(stats["withheld"])
+    assert set(ids) | set(stats["withheld"]) == set(sidecar["rows"]) | set(sidecar["unresolved"])
+    assert sidecar["rows_total"] == len(sidecar["rows"]) + len(sidecar["unresolved"]) == len(ids) + len(stats["withheld"])
+
+
+def test_evidence_file_matches_sidecar_and_stats(stats, sidecar):
+    evidence = json.loads((DATA / "biblioteka_nauki.license-evidence.json").read_text(encoding="utf-8"))
+    assert evidence["sidecar_sha256"] == hashlib.sha256(SIDECAR.read_bytes()).hexdigest()
+    assert evidence["retrieved"] == sidecar["retrieved"]
+    by_id = {str(row["api_license_id"]): row for row in evidence["api_licenses"]}
+    assert set(by_id) == set(sidecar["licenses"])
+    rows_per_license = Counter(sidecar["rows"].values())
+    for lid, lic in sidecar["licenses"].items():
+        row = by_id[lid]
+        assert (row["nameEn"], row["urlEn"]) == (lic["nameEn"], lic["urlEn"])
+        assert row["label"] == license_label(lic, lic["iconId"])
+        assert row["api_rows"] == rows_per_license[int(lid)]
+        assert row["shipped"] == stats["licenses"].get(row["label"], 0)
+    assert evidence["withheld"] == len(stats["withheld"])
+    assert evidence["flagged"] == Counter(flag for flags in sidecar["flagged"].values() for flag in flags)
+    assert evidence["unchanged_vs_pr62"]["content_sha256"] == stats["content_sha256"]
+
+
+def test_shard_text_and_ids_match_the_recorded_digest(stats):
+    """Text and ids are what PR 62 shipped: stats['content_sha256'] was equal to the PR 62 shard's digest
+    (evidence: unchanged_vs_pr62), and the shard on disk still hashes to it."""
+    assert content_digest(DATA / "biblioteka_nauki.parquet") == stats["content_sha256"]
+
+
+def test_content_digest_sees_text_ids_and_order_but_not_other_columns(tmp_path):
+    def digest(name, ids, texts, license_="cc-by", skip=frozenset()):
+        path = tmp_path / name
+        pq.write_table(pa.table({"id": ids, "text": texts, "license": [license_] * len(ids)}), path)
+        return content_digest(path, skip)
+
+    base = digest("a.parquet", ["x", "y"], ["tx", "ty"])
+    assert digest("b.parquet", ["x", "y"], ["tx", "ty"], license_="CC-BY-4.0") == base
+    assert digest("c.parquet", ["x", "y"], ["tx", "tY"]) != base
+    assert digest("d.parquet", ["x", "z"], ["tx", "ty"]) != base
+    assert digest("e.parquet", ["y", "x"], ["ty", "tx"]) != base
+    assert digest("f.parquet", ["x", "y", "w"], ["tx", "ty", "tw"], skip=frozenset({"w"})) == base
+
+
+def test_datasheet_counts_match_stats(stats):
     card = (DATA / "biblioteka_nauki.md").read_text(encoding="utf-8")
     assert f"| {stats['kept']:,} | {stats['chars']:,} | {stats['tokens']:,} |" in card
-    for license, docs in stats["licenses"].items():
-        assert f"{docs:,}" in card, license
+    for label, docs in stats["licenses"].items():
+        assert f"| {label} | {docs:,} |" in card, label
+    classes = {
+        "API HTTP 404": stats["drop_license_unverified"],
+        "text prints a NonCommercial or NoDerivatives licence": stats["drop_text_nc_nd"],
+        "text says it is reprinted or translated by permission of a publisher": stats["drop_text_reprint"],
+    }
+    for name, count in classes.items():
+        assert f"| {name} | {count} |" in card, name
+    assert f"read {stats['read']:,} → kept {stats['kept']:,}" in card
     assert "| Public Domain |" not in card
+    assert PROVENANCE in " ".join(card.lower().split())
+    assert "direct rebuild" not in card.lower()
+    assert "Pulled from SpeakLeash" not in card
+
+
+def test_registry_entry_says_per_record_versions_and_speakleash_text():
+    entry = SOURCES["biblioteka_nauki"]
+    assert entry["license_spdx"] == "MIXED"
+    assert "version" in entry["traceable"]
+    assert PROVENANCE in entry["provenance"].lower()
+    assert "direct rebuild" not in entry["provenance"].lower()
+    assert "not a SpeakLeash" not in entry["provenance"]
+    assert "recover_license_versions.py" in entry["provenance"]
 
 
 def test_filter_drops_public_domain_and_fails_closed():
@@ -63,7 +191,187 @@ def test_filter_drops_public_domain_and_fails_closed():
 
 
 def test_upstream_gate_matches_filter():
-    spec = importlib.util.spec_from_file_location("recover_attribution", DATA / "recover_attribution.py")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    assert module.CLEAN == KEEP
+    assert load_script("recover_attribution").CLEAN == KEEP
+
+
+@pytest.mark.parametrize("lic, stored, label", [
+    (BY_40, "cc-by", "CC-BY-4.0"),
+    (BYSA_40, "cc-by-sa", "CC-BY-SA-4.0"),
+    (BY_30_PL, "cc-by", "CC-BY-3.0-PL"),
+    (api_license(3, "cc-by", "3.0 Unported", "https://creativecommons.org/licenses/by/3.0/legalcode"), "cc-by", "CC-BY-3.0"),
+    (api_license(8, "cc-by-sa", "3.0", "https://creativecommons.org/licenses/by-sa/3.0/pl/legalcode", " PL"), "cc-by-sa", "CC-BY-SA-3.0-PL"),
+    (BY_20, "cc-by", "CC-BY-2.0"),
+])
+def test_license_label_reads_kind_version_and_port_from_the_api(lic, stored, label):
+    assert license_label(lic, stored) == label
+
+
+@pytest.mark.parametrize("lic, stored", [
+    ({**BY_40, "creativeCommons": False}, "cc-by"),
+    ({**BY_40, "urlEn": "https://creativecommons.org/publicdomain/mark/1.0/"}, "cc-by"),
+    ({**BY_40, "urlEn": "https://creativecommons.org/licenses/by-nc/4.0/legalcode"}, "cc-by"),
+    ({**BY_40, "urlEn": "https://creativecommons.org/licenses/by-nd/4.0/legalcode"}, "cc-by"),
+    ({**BY_40, "urlEn": "https://creativecommons.org/licenses/by/1.0/legalcode"}, "cc-by"),
+    ({**BY_40, "urlEn": "https://creativecommons.org/licenses/by/3.0/de/legalcode"}, "cc-by"),
+    ({**BY_40, "urlEn": "https://example.org/licenses/by/4.0/legalcode"}, "cc-by"),
+    ({**BY_40, "urlEn": None}, "cc-by"),
+    ({**BY_40, "nameEn": "CC BY: Creative Commons Attribution 3.0 PL"}, "cc-by"),  # name says 3.0, URL says 4.0
+    ({**BY_40, "iconId": "cc-by-sa"}, "cc-by"),  # icon disagrees with stored label and URL
+    (BY_40, "cc-by-sa"),  # stored label disagrees with the API
+    (BYSA_40, "cc0"),
+])
+def test_license_label_fails_closed(lic, stored):
+    with pytest.raises(ValueError):
+        license_label(lic, stored)
+
+
+def test_relabel_changes_only_license_and_withholds_what_it_cannot_verify():
+    table = pa.table({
+        "id": ["a", "b", "c", "d", "e", "f"],
+        "text": ["ta", "tb", "tc", "td", "te", "tf"],
+        "token_count": [1, 2, 3, 4, 5, 6],
+        "license": ["cc-by", "cc-by", "cc-by-sa", "cc-by", "cc-by", "cc-by-sa"],
+    })
+    sidecar = {
+        "licenses": {"7": BY_30_PL, "1": BY_40, "2": BYSA_40,
+                     "9": {**BY_40, "id": 9, "urlEn": "https://creativecommons.org/licenses/by-nc/4.0/legalcode"}},
+        "rows": {"a": 7, "b": 1, "c": 2, "d": 9, "f": 1},  # "e" is nowhere; "f" is cc-by-sa locally, BY upstream
+        "unresolved": {"e": "http404"},
+    }
+    sidecar["rows"]["e"] = 1  # unresolved wins over rows
+    out, withheld = relabel(table, sidecar)
+    assert out.column("id").to_pylist() == ["a", "b", "c"]
+    assert out.column("license").to_pylist() == ["CC-BY-3.0-PL", "CC-BY-4.0", "CC-BY-SA-4.0"]
+    for name in ("id", "text", "token_count"):
+        assert out.column(name).to_pylist() == table.filter(pa.array([True, True, True, False, False, False])).column(name).to_pylist()
+    assert out.schema == table.schema
+    assert set(withheld) == {"d", "e", "f"}
+    assert withheld["e"] == "API: http404"
+    assert "not allowlisted" in withheld["d"] and "disagree" in withheld["f"]
+    _, withheld = relabel(pa.table({"id": ["z"], "license": ["cc-by"]}), {"licenses": {}, "rows": {}, "unresolved": {}})
+    assert withheld == {"z": "not in the API sidecar"}
+
+
+def test_relabel_override_labels_from_the_api_only_and_must_be_reached():
+    table = pa.table({"id": ["a", "b"], "license": ["cc-by", "cc-by"]})
+    sidecar = {"licenses": {"1": BY_40, "2": BYSA_40}, "rows": {"a": 1, "b": 2}, "unresolved": {}}
+    out, withheld = relabel(table, sidecar, {"b": "CC-BY-SA-4.0"})  # stored cc-by, API says BY-SA: the API wins
+    assert out.column("license").to_pylist() == ["CC-BY-4.0", "CC-BY-SA-4.0"] and withheld == {}
+    _, withheld = relabel(table, sidecar)  # without the override the disagreement is withheld
+    assert set(withheld) == {"b"}
+    with pytest.raises(SystemExit, match="API gives CC-BY-SA-4.0"):
+        relabel(table, sidecar, {"b": "CC-BY-4.0"})
+    with pytest.raises(SystemExit, match="override ids not reached"):
+        relabel(table, sidecar, {"zz": "CC-BY-4.0"})  # absent
+    with pytest.raises(SystemExit, match="override ids not reached"):
+        relabel(table, {**sidecar, "unresolved": {"b": "http404"}}, {"b": "CC-BY-SA-4.0"})  # withheld by the API
+
+
+def test_withhold_listed_drops_exactly_the_listed_ids_and_fails_when_one_is_not_reached():
+    table = pa.table({"id": ["a", "b", "c"], "text": ["ta", "tb", "tc"]})
+    out, withheld = withhold_listed(table, {"c": "why c", "a": "why a"})
+    assert out.to_pydict() == {"id": ["b"], "text": ["tb"]} and withheld == {"c": "why c", "a": "why a"}
+    assert withhold_listed(table, {})[0].to_pydict() == table.to_pydict()
+    with pytest.raises(SystemExit, match="listed ids not reached: \\['zz'\\]"):
+        withhold_listed(table, {"a": "x", "zz": "y"})
+    with pytest.raises(SystemExit, match="listed ids not reached"):
+        withhold_listed(out, {"a": "x"})  # already gone: a second list may not name a first list's id
+
+
+class FakeResponse:
+    def __init__(self, status, body=None, headers=None, text=""):
+        self.status_code, self._body, self.headers, self.text = status, body, headers or {}, text
+
+    def json(self):
+        if self._body is None:
+            raise ValueError("not json")
+        return self._body
+
+
+class FakeSession:
+    def __init__(self, *responses):
+        self.responses, self.urls = list(responses), []
+
+    def get(self, url, timeout):
+        self.urls.append(url)
+        return self.responses.pop(0)
+
+
+class NoClock:
+    def wait(self):
+        pass
+
+
+RECORD = {"id": 941208, "license": BY_30_PL, "restricted": False, "reprintPublication": True, "translationPublication": False}
+
+
+def test_fetch_one_reads_the_license_object_and_flags():
+    fetch = load_script("recover_license_versions")
+    session = FakeSession(FakeResponse(200, RECORD))
+    line = fetch.fetch_one(session, NoClock(), "biblioteka_nauki_books_941208", sleep=lambda _: None)
+    assert session.urls == ["https://bibliotekanauki.pl/api/books/941208"]
+    assert line["status"] == "ok" and line["license"] == BY_30_PL and line["flags"] == ["reprintPublication"]
+    wrong = fetch.fetch_one(FakeSession(FakeResponse(200, {**RECORD, "id": 5})), NoClock(), "biblioteka_nauki_books_941208")
+    assert wrong["status"] == "id_mismatch"
+    gone = fetch.fetch_one(FakeSession(FakeResponse(404)), NoClock(), "biblioteka_nauki_articles_1")
+    assert gone["status"] == "http404" and gone["license"] is None
+    nolic = fetch.fetch_one(FakeSession(FakeResponse(200, {"id": 1, "license": None})), NoClock(), "biblioteka_nauki_articles_1")
+    assert nolic["status"] == "ok" and nolic["license"] is None
+
+
+def test_fetch_one_backs_off_on_429_and_5xx_then_gives_up():
+    fetch = load_script("recover_license_versions")
+    slept = []
+    session = FakeSession(FakeResponse(429, headers={"Retry-After": "7"}), FakeResponse(503), FakeResponse(200, RECORD))
+    assert fetch.fetch_one(session, NoClock(), "biblioteka_nauki_books_941208", sleep=slept.append)["status"] == "ok"
+    assert slept[0] == 7 and 2 <= slept[1] < 3 and len(session.urls) == 3
+    never = FakeSession(*[FakeResponse(500) for _ in range(fetch.MAX_RETRY)])
+    assert fetch.fetch_one(never, NoClock(), "biblioteka_nauki_books_1", sleep=lambda _: None) is None
+
+
+@pytest.mark.parametrize("response", [
+    FakeResponse(403),
+    FakeResponse(401),
+    FakeResponse(200, None, text="<html>Please verify you are human (CAPTCHA)</html>"),
+    FakeResponse(200, {"id": 1}),  # JSON without a `license` key
+])
+def test_fetch_one_stops_instead_of_working_around_a_block(response):
+    fetch = load_script("recover_license_versions")
+    session = FakeSession(response)
+    with pytest.raises(fetch.Blocked):
+        fetch.fetch_one(session, NoClock(), "biblioteka_nauki_books_1", sleep=lambda _: None)
+    assert len(session.urls) == 1  # no retry, no second try
+
+
+def test_row_ids_are_parsed_strictly():
+    fetch = load_script("recover_license_versions")
+    assert fetch.parse_row_id("biblioteka_nauki_chapters_42") == ("chapters", 42)
+    for bad in ("biblioteka_nauki_papers_1", "wolne_lektury_books_1", "biblioteka_nauki_books_x", "biblioteka_nauki_books_1/../2"):
+        with pytest.raises(ValueError):
+            fetch.parse_row_id(bad)
+
+
+def test_export_covers_every_row_and_separates_unresolved_and_flagged(tmp_path):
+    fetch = load_script("recover_license_versions")
+    ids = ["biblioteka_nauki_books_1", "biblioteka_nauki_books_2", "biblioteka_nauki_books_3", "biblioteka_nauki_books_4"]
+    parquet = tmp_path / "x.parquet"
+    pq.write_table(pa.table({"id": ids}), parquet)
+    day = {"fetched": "2026-10-06", "flags": []}
+    lines = [
+        {"id": ids[0], "status": "ok", "license": BY_40, **day},
+        {"id": ids[1], "status": "ok", "license": BY_40, "fetched": "2026-10-06", "flags": ["restricted"]},
+        {"id": ids[2], "status": "http404", "license": None, "flags": []},
+        {"id": ids[3], "status": "ok", "license": None, **day},
+    ]
+    cache, out = tmp_path / "cache.jsonl", tmp_path / "sidecar.json"
+    cache.write_text("\n".join(json.dumps(line) for line in lines[:3]) + "\n", encoding="utf-8")
+    args = type("Args", (), {"parquet": parquet, "cache": cache, "out": out})
+    with pytest.raises(SystemExit, match="1 rows not fetched"):
+        fetch.export(args)
+    cache.write_text("\n".join(json.dumps(line) for line in lines) + "\n", encoding="utf-8")
+    fetch.export(args)
+    result = json.loads(out.read_text(encoding="utf-8"))
+    assert result["rows"] == {ids[0]: 1, ids[1]: 1}
+    assert result["unresolved"] == {ids[2]: "http404", ids[3]: "no_license"}
+    assert result["flagged"] == {ids[1]: ["restricted"]}
+    assert result["licenses"] == {"1": BY_40} and result["retrieved"] == "2026-10-06" and result["rows_total"] == 4