govpl: drop 188 PAP reprints (gov.pl third-party carve-out), add URL sidecar

artifacts/source_findings.md

@@ -1260,3 +1260,64 @@ References: `rights_audit_2026-10/reports/citations.md` L10;
 **Lesson** — a project-wide label on an aggregator pull hides per-page licences. Pull
 from the official dump with page ids and licence templates, so each page can be
 screened and labelled.
+
+## biblioteka_nauki — public-domain-label records dropped (2026-10-06)
+
+**Verdict** — `added`, kept for v0.2.6 minus 3 records (polish-dynaword-v2#52). 42,071 →
+42,068 documents, 673,488,831 → 673,112,676 tokens (−376,155), 1,748,333,935 →
+1,747,387,478 characters. `src/clean_biblioteka_nauki.py` filters the v0.2.5 Parquet
+(pinned by SHA-256): it keeps `cc-by`, `cc-by-sa` and `cc0`, drops `public-domain`, and
+fails on any other value. `recover_attribution.py` no longer counts `public-domain` as clean.
+
+**Reason** — the 3 rows (`books_2142716`, `books_2147851`, `articles_2097363`) carry the
+platform's "Domena publiczna" label. Verified 2026-10-06 against
+`bibliotekanauki.pl/api/{type}/{id}`: licence id 22, `creativeCommons: false`, URL
+`creativecommons.org/publicdomain/mark/1.0/`. Creative Commons describes the Mark as "a tag
+or a label" for works already free of copyright; it grants nothing. All three are original
+texts (`reprintPublication` and `translationPublication` false) first published 2019, 2021
+and 2022 by named authors (Jerzy Zając, Witold Rakowski, Beata Michalec), so life+70 has
+not run out. The 2019 book's own colophon reads "Copyright by Jerzy Zając 2019 / Copyright
+by Muzeum Niepodległości w Warszawie 2019". That the authors are alive is inferred.
+
+**Not done here** — the licence version is still collapsed: rows say `cc-by`/`cc-by-sa`,
+the card and `stats.json` say 4.0. A live re-check (seed 20261006, 24 rows) found 4 of 12
+`cc-by` rows under 3.0 PL or 3.0 Unported; all 12 `cc-by-sa` rows were 4.0. Fixing it needs
+a per-record API re-fetch of name and version (tracked under polish-dynaword-v2#57). The
+card still names SpeakLeash while `src/sources.py` says direct rebuild; `licenses.jsonl`,
+`index.jsonl` and `build_parquet.py` are not in the repo. 128 kept rows (88 `cc-by`, 40
+`cc-by-sa`; 1.56% of tokens) contain "Wszelkie prawa zastrzeżone" or "All rights
+reserved" in their text (publication years 2010-2021); regex count only, not reviewed.
+
+**Lesson** — a platform's "public domain" label can be the PD Mark. Check the URL behind
+the label, and check the date: a 2019 work cannot be public domain by term in Poland.
+
+## govpl — PAP reprints dropped (2026-10-06)
+
+**Verdict** — `kept`, minus 188 PAP reprints (slayerlabs/polish-dynaword-v2#51).
+88,190 → 88,002 documents, 80,666,129 → 80,445,758 tokens (−220,371). `release` stays
+`0.2.2`. `src/clean_govpl.py` filters the pinned v0.2.5 Parquet, so ids are unchanged,
+and writes `govpl.attribution.jsonl` with each row's gov.pl URL, subsite, title and date.
+`fetch_govpl.normalize()` applies the same rule (`pap_rule`) to future crawls.
+
+**Reason** — gov.pl's copyright page grants CC BY-SA 4.0 for its text but carves out
+works whose copyright belongs to third parties; their use needs the owners' consent.
+Articles that credit PAP as their source are such works.
+- The issue's rule (`Źródło:` line naming PAP) matches 154 rows. A hand-check of 20
+  (seed 51) found 20 text source lines and no photo credits; 14 credit PAP jointly with
+  the ministry, so the text may be partly the ministry's. PAP's archive is not public, so
+  verbatim PAP authorship was not confirmed.
+- A scan of the other rows added 34 verified text attributions: misspelt or colon-less
+  source lines (9), `Na podst. … PAP` (22, all uw-podlaski), a lone `(PAP)` sign-off line
+  (2) and one PAP interview transcript (prokuratura-krajowa). Photo credits (`fot. PAP`)
+  and rows that quote or mention PAP stay.
+- Left in, flagged: a mid-text `(PAP)` after one paragraph (govpl_30227, govpl_58869), a
+  footnote crediting PAP and the health ministry (govpl_81037), a KRRiT report quoting two
+  PAP questions (govpl_86914).
+- Not reviewed: 710 kept rows carry a `Źródło:` line naming some other source (mostly
+  government bodies; some name WHO, universities, journals).
+
+References: `rights_audit_2026-10/reports/govweb.md` (govpl block);
+https://www.gov.pl/web/gov/prawa-autorskie (read 2026-10-06).
+
+**Lesson** — an open-licence footer covers the publisher's own text. On a news-style
+site, check source lines for agency copy before taking the footer at face value.

data/biblioteka_nauki/biblioteka_nauki.md

@@ -6,7 +6,7 @@ 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 · Public Domain 3
+- **License:** per-document — CC BY 4.0 28,335 · CC BY-SA 4.0 13,733
 - **Created (range):** per-document publication year, from each item's bibliotekanauki.pl metadata
 - **Added:** 2026-06-27
 
@@ -20,10 +20,16 @@ items are kept; all-rights-reserved and unknown items are gated out. Recovery yi
 |---|---:|
 | CC BY 4.0 | 28,335 |
 | CC BY-SA 4.0 | 13,733 |
-| Public Domain | 3 |
 
 The per-document license is carried in the parquet `license` column.
 
+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.
+
 ## Attribution
 Per-document attribution (author · year · title · publisher) was re-fetched 1:1 from
 bibliotekanauki.pl (43,576 / 43,576 ok) and is carried in the parquet `attribution` column,
@@ -37,7 +43,7 @@ attribution recovered per document and preserved.
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 42,071 | 1,748,333,935 | 673,488,831 |
+| 42,068 | 1,747,387,478 | 673,112,676 |
 
 ## Filters applied (build_dynaword.py)
 Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
@@ -45,7 +51,8 @@ Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - drop non-Polish (diacritic ratio): **925**
 - exact cross-source dedup (sha1): **180**
 - OCR alpha-ratio < 0.70 (OCR source): **400**
-- read 43,576 → kept 42,071
+- licence not an established grant, CC Public Domain Mark (`src/clean_biblioteka_nauki.py`): **3**
+- read 43,576 → kept 42,068
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.

data/biblioteka_nauki/biblioteka_nauki.parquet

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

data/biblioteka_nauki/biblioteka_nauki.stats.json

@@ -1,12 +1,18 @@
 {
   "read": 43576,
-  "kept": 42071,
+  "kept": 42068,
   "drop_short": 0,
   "drop_lang": 925,
   "drop_dup": 180,
   "drop_ocr": 400,
-  "chars": 1748333935,
-  "tokens": 673488831,
+  "chars": 1747387478,
+  "tokens": 673112676,
   "secs": 484.1,
-  "license": "CC-BY-4.0 / CC-BY-SA-4.0"
+  "license": "CC-BY-4.0 / CC-BY-SA-4.0",
+  "drop_rights": 3,
+  "licenses": {
+    "cc-by": 28335,
+    "cc-by-sa": 13733
+  },
+  "input_sha256": "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26"
 }

data/biblioteka_nauki/recover_attribution.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Targeted attribution pass for the CLEAN (CC-BY/CC-BY-SA/PD) Biblioteka Nauki ids ONLY.
+"""Targeted attribution pass for the CLEAN (CC-BY/CC-BY-SA/CC0) Biblioteka Nauki ids ONLY.
 The first recovery pass stored the license correctly but parsed the wrong attribution fields.
 CC-BY/CC-BY-SA legally REQUIRE attribution, so re-fetch just the ~43.6k clean ids and extract:
   authors = contributors[role=AUTHOR] firstName+lastName ; year = dates[PUBLISHED].date.year ;
@@ -16,7 +16,10 @@ HERE = os.path.dirname(os.path.abspath(__file__))
 LIC = os.path.join(HERE, "licenses.jsonl")
 OUT = os.path.join(HERE, "attribution.jsonl")
 PROG = os.path.join(HERE, "attribution_progress.txt")
-CLEAN = {"cc-by", "cc-by-sa", "cc0", "public-domain"}
+# The v0.2.4 run also kept "public-domain": the CC Public Domain Mark, a label rather than a grant
+# (polish-dynaword-v2#52). src/clean_biblioteka_nauki.py drops it from the shipped Parquet; its KEEP
+# set must equal this one.
+CLEAN = {"cc-by", "cc-by-sa", "cc0"}
 WORKERS = 8
 UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
       "(KHTML, like Gecko) Chrome/124 Safari/537.36")

data/govpl/govpl.attribution.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff137d2042ff32198ec7eb28347631dbf21735ab27afc2d823f8c27d0904aa33
+size 26318408

data/govpl/govpl.md

@@ -8,34 +8,46 @@ gov.pl — Polish government press releases
 - **Language:** Polish (pl)
 - **License:** `CC-BY-SA-4.0`
 - **Created (range):** 2005-09-26, 2026-07-19
-- **Added:** 2026-07-19
+- **Added:** 2026-07-19; PAP reprints removed 2026-10-06
 
 ## Licensing — traceable basis
-All textual content on gov.pl is published under CC-BY-SA 4.0 (site footer: "Treści tekstowe publikowane w serwisie … są udostępniane na licencji CC BY-SA 4.0"). Authored and hosted by the Polish government, which holds the right to license it — same open family as Polish Wikipedia.
+gov.pl publishes its text under CC BY-SA 4.0 (site footer and https://www.gov.pl/web/gov/prawa-autorskie: "Treści tekstowe publikowane w serwisie … są udostępniane na licencji CC BY-SA 4.0"). The same page excludes works whose copyright belongs to third parties; using those needs the owners' consent. Articles crediting PAP are therefore dropped (legal note).
 
 ## Provenance
-Ministry/agency press releases fetched directly from gov.pl (editor-content per article, HTML stripped) by src/fetch_govpl.py. Subsites + their non-uniform news-section paths are enumerated by src/discover_govpl.py into the committed manifest src/govpl_subsites.json (gov.pl has no sitemap/API). Each record's meta.url resolves on gov.pl.
+Ministry/agency press releases fetched directly from gov.pl (editor-content per article, HTML stripped) by src/fetch_govpl.py. Subsites + their non-uniform news-section paths are enumerated by src/discover_govpl.py into the committed manifest src/govpl_subsites.json (gov.pl has no sitemap/API). v0.2.6 removes PAP reprints from the v0.2.5 Parquet with src/clean_govpl.py, which also writes govpl.attribution.jsonl: each row's gov.pl URL, subsite, title and date.
+
+## Attribution
+CC BY-SA 4.0 requires credit and a link to the source. `govpl.attribution.jsonl` has one
+line per row, in Parquet order: `id`, `url` (the gov.pl article), `subsite` (the publishing
+ministry or agency), `title`, `date` (as listed on gov.pl) and `license`. Rows were matched
+to the 2026-07-19 crawl on SHA-1 of the stripped text; for 1,189 rows the same text was
+fetched from more than one URL, and the first in fetch order is given.
 
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 88,190 | 218,099,000 | 80,666,129 |
-
+| 88,002 | 217,515,240 | 80,445,758 |
 
 ## Per-document license metadata
 | license | documents |
 |---|---:|
-| `CC-BY-SA-4.0` | 88,190 |
+| `CC-BY-SA-4.0` | 88,002 |
 
 Author metadata present for **0** documents. Empty values mean the upstream record did not expose a machine-readable author field.
 
-## Filters applied (build_dynaword.py)
-Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
+## Legal scope note
+gov.pl's copyright page carves out "utwory, co do których prawa autorskie przysługują osobom trzecim" from its CC BY-SA 4.0 grant. Articles crediting PAP (Polish Press Agency) as their source are such works, so 188 are dropped (rule fetch_govpl.pap_rule, applied by src/clean_govpl.py): a "Źródło:" line naming PAP (163), "Na podst. … PAP" (22), a "(PAP)" sign-off line (2) and one PAP interview transcript (1). PAP photo credits and articles that only quote or mention PAP stay. Other third-party text is not screened: 710 kept articles carry a "Źródło:" line naming some other source; they were not reviewed.
+
+## Filters applied
+`build_dynaword.py` (v0.2.2), minimal per Dynaword guidelines:
 - drop documents < 200 chars: **0**
 - drop non-Polish (diacritic ratio): **24**
 - exact cross-source dedup (sha1): **1,926**
-- OCR alpha-ratio < 0.70 (OCR sources only): **0**
 - read 90,140 → kept 88,190
 
+`src/clean_govpl.py` (v0.2.6), third-party carve-out:
+- drop PAP reprints: **188** (`Źródło:` line 163, `Na podst.` 22, `(PAP)` sign-off 2, interview 1)
+- read 88,190 → kept 88,002
+
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.

data/govpl/govpl.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c0310fcdf45804e6547bd197cba55f58f12df618cd3d8b92b8e9077a3720b9f
-size 82940575
+oid sha256:5e97d5b1ec04aebadaddd9ecb9fc6835324885606f59d4e8569f5516528f839b
+size 82308595

data/govpl/govpl.stats.json

@@ -1,16 +1,25 @@
 {
   "read": 90140,
-  "kept": 88190,
   "drop_short": 0,
   "drop_lang": 24,
   "drop_dup": 1926,
   "drop_ocr": 0,
-  "chars": 218099000,
-  "tokens": 80666129,
+  "drop_pap": 188,
+  "drop_pap_by_rule": {
+    "source_line": 163,
+    "sign_off": 2,
+    "based_on": 22,
+    "interview": 1
+  },
+  "kept": 88002,
+  "chars": 217515240,
+  "tokens": 80445758,
   "licenses": {
-    "CC-BY-SA-4.0": 88190
+    "CC-BY-SA-4.0": 88002
   },
   "authors_with_value": 0,
-  "secs": 2.9,
-  "license": "CC-BY-SA-4.0"
-}
+  "license": "CC-BY-SA-4.0",
+  "input_rows": 88190,
+  "input_sha256": "9c0310fcdf45804e6547bd197cba55f58f12df618cd3d8b92b8e9077a3720b9f",
+  "fetched_sha256": "368259d0ea8522eced71b426ae238556d5330a410aa994bdcbdc7427478d783a"
+}

src/clean_biblioteka_nauki.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Drop Biblioteka Nauki rows whose licence is not an established grant.
+
+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.
+Dropped: `public-domain`. The platform shows it for items tagged with the CC Public Domain Mark 1.0
+(API licence id 22, https://creativecommons.org/publicdomain/mark/1.0/). The Mark is a label, not
+a waiver or a licence, and the 3 tagged items are original works first published 2019-2022, so
+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.
+
+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
+  python3 src/clean_biblioteka_nauki.py
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from collections import Counter
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+SOURCE = "biblioteka_nauki"
+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)
+
+
+def filter_table(table: pa.Table) -> pa.Table:
+    """Rows whose `license` is in KEEP. Fails on any value in neither KEEP nor DROP."""
+    if unknown := set(table.column("license").unique().to_pylist()) - KEEP - DROP:
+        raise SystemExit(f"unexpected license values: {sorted(unknown, key=str)}")
+    return table.filter(pc.is_in(table.column("license"), pa.array(sorted(KEEP))))
+
+
+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()))
+
+    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,
+        chars=pc.sum(pc.utf8_length(kept.column("text"))).as_py(),
+        tokens=pc.sum(kept.column("token_count")).as_py(),
+        licenses=dict(sorted(Counter(kept.column("license").to_pylist()).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")
+    os.replace(stats_tmp, stats_path)
+    return {**stats, "dropped_ids": dropped}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet")
+    parser.add_argument("--out", type=Path, default=DATA)
+    args = parser.parse_args()
+    print(json.dumps(build(args.input, args.out), indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

src/clean_govpl.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Drop PAP reprints from `govpl` and write a per-row URL sidecar.
+
+gov.pl's copyright page (https://www.gov.pl/web/gov/prawa-autorskie) licenses the
+site's text under CC BY-SA 4.0 but excludes works whose copyright belongs to third
+parties. Articles that credit PAP (Polish Press Agency) as their source are such
+works (slayerlabs/polish-dynaword-v2#51). `fetch_govpl.pap_rule` names them; this
+script removes them from the released Parquet, so ids and the other rows stay as they
+are (a rebuild through build_dynaword.py would renumber ids).
+
+`govpl.attribution.jsonl` gives each kept row the gov.pl URL, subsite, title and date
+of the fetched article, matched on build_dynaword's dedup key (SHA-1 of the stripped
+text) in the fetch output `govpl.jsonl.zst`. Where the same text was fetched from
+several URLs, the first one in fetch order is used.
+
+Both inputs are pinned by SHA-256. Restore the Parquet before a rerun:
+  git checkout v0.2.5 -- data/govpl/govpl.parquet
+  python3 src/clean_govpl.py --fetched ~/speakleash/govpl.jsonl.zst
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import os
+import sys
+from collections import Counter
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import zstandard
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from fetch_govpl import KEY as SOURCE, pap_rule  # one rule for fetch and release
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+INPUT_SHA256 = "9c0310fcdf45804e6547bd197cba55f58f12df618cd3d8b92b8e9077a3720b9f"  # v0.2.5
+FETCHED_SHA256 = "368259d0ea8522eced71b426ae238556d5330a410aa994bdcbdc7427478d783a"  # 2026-07-19 crawl
+BUILD_STATS = {  # build_dynaword.py counts for the v0.2.5 Parquet, kept for the datasheet
+    "read": 90140, "drop_short": 0, "drop_lang": 24, "drop_dup": 1926, "drop_ocr": 0,
+}
+
+
+def text_key(text: str) -> bytes:
+    """build_dynaword's dedup key."""
+    return hashlib.sha1(text.strip().encode("utf-8")).digest()
+
+
+def fetched_meta(path: Path) -> dict[bytes, dict]:
+    """text_key -> meta of the first fetched record with that text."""
+    meta: dict[bytes, dict] = {}
+    with path.open("rb") as compressed:
+        lines = io.TextIOWrapper(zstandard.ZstdDecompressor().stream_reader(compressed), encoding="utf-8")
+        for line in lines:
+            if line.strip():
+                record = json.loads(line)
+                meta.setdefault(text_key(record["text"]), record["meta"])
+    return meta
+
+
+def check_pin(path: Path, expected: str, restore: str) -> None:
+    with path.open("rb") as stream:
+        actual = hashlib.file_digest(stream, "sha256").hexdigest()
+    if actual != expected:
+        raise SystemExit(f"{path} does not match the pinned SHA-256; {restore}")
+
+
+def build(input_path: Path, fetched_path: Path, out_dir: Path) -> dict:
+    check_pin(input_path, INPUT_SHA256, "restore it with `git checkout v0.2.5 -- data/govpl/govpl.parquet`")
+    check_pin(fetched_path, FETCHED_SHA256, "it is not the 2026-07-19 gov.pl crawl")
+    table = pq.read_table(input_path)
+    meta = fetched_meta(fetched_path)
+
+    kept, attribution, dropped = [], [], Counter()
+    for row in table.to_pylist():
+        if rule := pap_rule(row["text"]):
+            dropped[rule] += 1
+            continue
+        found = meta.get(text_key(row["text"]))
+        if found is None:
+            raise SystemExit(f"{row['id']}: text not found in {fetched_path}")
+        kept.append(row)
+        attribution.append({
+            "id": row["id"], "url": found["url"], "subsite": found["subsite"],
+            "title": found["title"], "date": found["date"], "license": row["license"],
+        })
+
+    stats = {
+        **BUILD_STATS, "drop_pap": sum(dropped.values()), "drop_pap_by_rule": dict(dropped),
+        "kept": len(kept),
+        "chars": sum(len(r["text"]) for r in kept), "tokens": sum(r["token_count"] for r in kept),
+        "licenses": dict(Counter(r["license"] for r in kept)),
+        "authors_with_value": sum(bool(r["author"]) for r in kept), "license": "CC-BY-SA-4.0",
+        "input_rows": table.num_rows, "input_sha256": INPUT_SHA256, "fetched_sha256": FETCHED_SHA256,
+    }
+    build_drops = sum(v for k, v in BUILD_STATS.items() if k.startswith("drop_"))
+    if stats["read"] - build_drops != table.num_rows:
+        raise SystemExit("BUILD_STATS does not add up to the input row count")
+    staged = {
+        out_dir / f"{SOURCE}.parquet.tmp": lambda p: pq.write_table(
+            table.from_pylist(kept, schema=table.schema), p, compression="zstd"),
+        out_dir / f"{SOURCE}.attribution.jsonl.tmp": lambda p: p.write_text(
+            "".join(json.dumps(a, ensure_ascii=False) + "\n" for a in attribution), encoding="utf-8"),
+        out_dir / f"{SOURCE}.stats.json.tmp": lambda p: p.write_text(
+            json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"),
+    }
+    for path, write in staged.items():
+        write(path)
+    for path in staged:
+        os.replace(path, path.with_suffix(""))
+    return stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet")
+    parser.add_argument("--fetched", type=Path, required=True, help="govpl.jsonl.zst from fetch_govpl.py")
+    parser.add_argument("--out", type=Path, default=DATA)
+    args = parser.parse_args()
+    print(json.dumps(build(args.input, args.fetched, args.out), indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

src/fetch_govpl.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 """Fetch gov.pl ministry/agency press releases into a SpeakLeash-style
 .jsonl.zst, so build_dynaword.py consumes it unchanged (native source, not via
-SpeakLeash). All textual content on gov.pl is published under CC-BY-SA 4.0 (site
-footer: "Treści tekstowe publikowane w serwisie … CC BY-SA 4.0"), authored and
-hosted by the Polish government — so the redistributor genuinely holds the right
-to license it.
+SpeakLeash). gov.pl publishes its text under CC-BY-SA 4.0 (site footer: "Treści
+tekstowe publikowane w serwisie … CC BY-SA 4.0"), but its copyright page excludes
+works whose copyright belongs to third parties. Articles that credit PAP (Polish
+Press Agency) as their source are such works, so normalize() drops them
+(pap_rule below; the same rule filters the released Parquet in clean_govpl.py).
 
 Enumeration is driven by the committed manifest src/govpl_subsites.json (built
 by discover_govpl.py): {slug, news_path, pages} per subsite. This keeps the
@@ -30,6 +31,35 @@ from html_text import html_to_text
 KEY = "govpl"  # build_dynaword reads <KEY>.jsonl.zst
 MIN_CHARS = 200  # same floor as build_dynaword; skip stubs early
 
+# PAP attribution forms seen in the fetched articles (hand-checked, issue
+# slayerlabs/polish-dynaword-v2#51). A photo credit ("fot. PAP") is not one of them.
+_PAP = r"(?:\bPAP\b|\bPolsk\w*\s+Agencj\w*\s+Prasow\w*)"
+PAP_RULES = {
+    # "Źródło: /PAP, MKiDN/", "Źródła: PAP, Culture.pl", "Źródło informacji: PAP/MKIDN",
+    # "Żródło: Polska Agencja Prasowa". Covers the issue's rule
+    # (?i)\bźr[óo]d[łl]o\s*:\s*/?[^\n]{0,60}\bPAP\b and its misspellings.
+    "source_line": re.compile(
+        r"(?i)\b[źżz]r[óo]d[łl][oa](?:\s+informacji)?\s*:?\s*/?[^\n]{0,60}" + _PAP),
+    # "Na podst. PAP", "Na podst. PKP S.A. i PAP" (uw-podlaski)
+    "based_on": re.compile(r"(?i)\bna\s+podst\.[^\n]{0,60}\bPAP\b"),
+    # a line holding only "(PAP)" or "/PAP/", the agency's own sign-off
+    "sign_off": re.compile(r"(?m)^[ \t]*[/(*]?[ \t]*PAP[ \t]*[)/]?\.?[ \t\r]*$"),
+}
+# A PAP interview transcript: the agency's questions start lines with "PAP:".
+# ponytail: three such lines; one KRRiT report quoting two PAP questions stays in.
+_PAP_QUESTION = re.compile(r"(?m)^PAP\s*:")
+PAP_INTERVIEW_MIN_QUESTIONS = 3
+
+
+def pap_rule(text: str) -> str | None:
+    """Name of the first PAP rule that matches `text`, or None."""
+    for name, rx in PAP_RULES.items():
+        if rx.search(text):
+            return name
+    if len(_PAP_QUESTION.findall(text)) >= PAP_INTERVIEW_MIN_QUESTIONS:
+        return "interview"
+    return None
+
 # Body ends where the editor-content region gives way to gallery/attachments/tags.
 _END_MARKER = re.compile(
     r'<[^>]+class="[^"]*(?:attachments|art-tags|tags|social|share|gallery|files)[^"]*"'
@@ -54,12 +84,15 @@ def article_body(html: str) -> str:
 
 
 def normalize(art: dict, html: str, slug: str) -> dict | None:
-    """Listing entry {url,title,date} + article HTML -> record, or None if thin."""
+    """Listing entry {url,title,date} + article HTML -> record, or None if thin
+    or a PAP reprint."""
     body = article_body(html)
     if len(body) < MIN_CHARS:
         return None
     title = art.get("title") or ""
     text = f"{title}\n\n{body}" if title else body
+    if pap_rule(text):
+        return None
     return {
         "text": text,
         "meta": {

src/sources.py

@@ -471,22 +471,38 @@ SOURCES = {
         "pretty": "gov.pl — Polish government press releases",
         "license": "CC-BY-SA-4.0",
         "license_spdx": "CC-BY-SA-4.0",
-        "traceable": "All textual content on gov.pl is published under CC-BY-SA "
-                     "4.0 (site footer: \"Treści tekstowe publikowane w serwisie "
-                     "… są udostępniane na licencji CC BY-SA 4.0\"). Authored and "
-                     "hosted by the Polish government, which holds the right to "
-                     "license it — same open family as Polish Wikipedia.",
+        "traceable": "gov.pl publishes its text under CC BY-SA 4.0 (site footer and "
+                     "https://www.gov.pl/web/gov/prawa-autorskie: \"Treści tekstowe "
+                     "publikowane w serwisie … są udostępniane na licencji CC BY-SA "
+                     "4.0\"). The same page excludes works whose copyright belongs to "
+                     "third parties; using those needs the owners' consent. "
+                     "Articles crediting PAP are therefore dropped (legal note).",
         "upstream": "https://www.gov.pl/",
         "provenance": "Ministry/agency press releases fetched directly from gov.pl "
                       "(editor-content per article, HTML stripped) by "
                       "src/fetch_govpl.py. Subsites + their non-uniform news-section "
                       "paths are enumerated by src/discover_govpl.py into the "
                       "committed manifest src/govpl_subsites.json (gov.pl has no "
-                      "sitemap/API). Each record's meta.url resolves on gov.pl.",
+                      "sitemap/API). v0.2.6 removes PAP reprints from the v0.2.5 "
+                      "Parquet with src/clean_govpl.py, which also writes "
+                      "govpl.attribution.jsonl: each row's gov.pl URL, subsite, "
+                      "title and date.",
+        "legal_note": "gov.pl's copyright page carves out \"utwory, co do których "
+                      "prawa autorskie przysługują osobom trzecim\" from its CC BY-SA "
+                      "4.0 grant. Articles crediting PAP (Polish Press Agency) as their "
+                      "source are such works, so 188 are dropped (rule "
+                      "fetch_govpl.pap_rule, applied by src/clean_govpl.py): a "
+                      "\"Źródło:\" line naming PAP (163), \"Na podst. … PAP\" (22), a "
+                      "\"(PAP)\" sign-off line (2) and one PAP interview transcript (1). "
+                      "PAP photo credits and articles that only quote or mention PAP "
+                      "stay. Other third-party text is not screened: 710 kept articles "
+                      "carry a \"Źródło:\" line naming some other source; they were "
+                      "not reviewed.",
         "domain": "government",
         # actual min/max of article dates in the fetched corpus (90,124 dated).
         "created": "2005-09-26, 2026-07-19",
         "is_ocr": False,
+        "custom_datasheet": True,
     },
     "samorzad_gov_pl": {
         "added": "2026-08-14",

src/test_biblioteka_nauki_contract.py

@@ -0,0 +1,69 @@
+"""Contract checks for biblioteka_nauki after the public-domain drop (src/clean_biblioteka_nauki.py)."""
+
+import importlib.util
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from clean_biblioteka_nauki import DATA, KEEP, filter_table
+
+PUBLIC_DOMAIN_MARK_IDS = {
+    "biblioteka_nauki_books_2142716",
+    "biblioteka_nauki_books_2147851",
+    "biblioteka_nauki_articles_2097363",
+}
+
+
+def test_shard_has_no_public_domain_rows_and_matches_stats():
+    stats = json.loads((DATA / "biblioteka_nauki.stats.json").read_text(encoding="utf-8"))
+    path = DATA / "biblioteka_nauki.parquet"
+    assert pq.read_schema(path).names == [
+        "id", "text", "source", "added", "created", "token_count", "license", "attribution"]
+    table = pq.read_table(path, columns=["id", "source", "token_count", "license", "attribution"])
+    ids = table.column("id").to_pylist()
+    licenses = Counter(table.column("license").to_pylist())
+
+    assert table.num_rows == stats["kept"] == 42_068
+    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 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")
+    assert stats["read"] - sum(stats[k] for k in drops) == stats["kept"]
+    assert stats["drop_rights"] == 3
+
+
+def test_datasheet_counts_match_stats():
+    stats = json.loads((DATA / "biblioteka_nauki.stats.json").read_text(encoding="utf-8"))
+    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
+    assert "| Public Domain |" not in card
+
+
+def test_filter_drops_public_domain_and_fails_closed():
+    table = pa.table({"id": ["a", "b", "c", "d"], "license": ["cc-by", "public-domain", "cc-by-sa", "cc0"]})
+    assert filter_table(table).column("id").to_pylist() == ["a", "c", "d"]
+    for bad in ("cc-by-nc", "cc-by-nd", "all-rights-reserved", None):
+        with pytest.raises(SystemExit):
+            filter_table(pa.table({"license": ["cc-by", bad]}))
+
+
+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

src/test_govpl_contract.py

@@ -1,12 +1,20 @@
 """TDD contract for the direct gov.pl (press releases) ingestion path."""
+import json
+import re
 import sys
 import unittest
 from pathlib import Path
 
+import pyarrow.parquet as pq
+
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from discover_govpl import listing_articles, news_candidates, max_page
-from fetch_govpl import article_body, normalize, BASE
+from fetch_govpl import article_body, normalize, pap_rule, BASE
+
+DATA = Path(__file__).resolve().parents[1] / "data" / "govpl"
+ISSUE_51_RULE = re.compile(r"(?i)\bźr[óo]d[łl]o\s*:\s*/?[^\n]{0,60}\bPAP\b")  # polish-dynaword-v2#51
+RELEASED_ROWS = 88002  # 88,190 in v0.2.5 minus 188 PAP reprints
 
 LISTING = """
 <div class="art-prev">
@@ -79,6 +87,83 @@ class GovplContractTest(unittest.TestCase):
         self.assertEqual(max_page('<a href="?page=2">2</a><a href="?page=294">294</a>'), 294)
         self.assertEqual(max_page("<html>no pager</html>"), 1)  # single-page listing
 
+    def test_pap_reprints_are_named(self):
+        cases = {
+            "Tekst.\n\nŹródło: /PAP, MKiDN/\n\nZdjęcia (3)": "source_line",
+            "Tekst.\n\nŹródło: PAP": "source_line",
+            "Tekst. Źródło PAP, MKiDN": "source_line",
+            "Źródło informacji: PAP/MKIDN": "source_line",
+            "żródło: /PAP,MKiDN/": "source_line",
+            "Źródła: dzieje.pl, Mariusz Jarosiński (PAP), Muzeum Historii Polski": "source_line",
+            "Żródło: Polska Agencja Prasowa": "source_line",
+            "Tekst.\n\nNa podst. PKP S.A. i PAP\n\r\nZdjęcia (13)": "based_on",
+            "Tekst.\n\n(PAP)\n\n\r\nZdjęcia (1)": "sign_off",
+            "Wywiad\n\nPAP: Pytanie?\nOdpowiedź.\nPAP: Drugie?\nTak.\nPAP: Trzecie?\nNie.": "interview",
+        }
+        for text, rule in cases.items():
+            self.assertEqual(pap_rule(text), rule, text)
+
+    def test_pap_mentions_and_photo_credits_are_kept(self):
+        for text in (
+            "Minister na konferencji. Fot. PAP/Leszek Szymański",
+            "fot. PAP\n\nZdjęcia (2)",
+            "– powiedziała minister w rozmowie z PAP.",
+            "Wyniki ogłoszono w Centrum Prasowym PAP.",
+            "Akapit kończy się tak (PAP). Dalej tekst ministerstwa.",
+            "Źródło: MKiDN\n\nfot. PAP",
+            "Raport KRRiT\n\nPAP: Pytanie?\nOdpowiedź.\nPAP: Drugie?\nTak.",
+        ):
+            self.assertIsNone(pap_rule(text), text)
+
+    def test_normalize_drops_pap_reprint(self):
+        art = {"url": "/web/kultura/x", "title": "Nagłówek", "date": "14.07.2026"}
+        reprint = ARTICLE.replace("</p>", "</p><p>Źródło: /PAP, MKiDN/</p>", 1)
+        self.assertIsNotNone(normalize(art, ARTICLE, "kultura"))
+        self.assertIsNone(normalize(art, reprint, "kultura"))
+
+
+class GovplReleaseContractTest(unittest.TestCase):
+    """The released files: PAP reprints gone, stats and URL sidecar match the Parquet."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.table = pq.read_table(DATA / "govpl.parquet")
+        cls.stats = json.loads((DATA / "govpl.stats.json").read_text(encoding="utf-8"))
+        with (DATA / "govpl.attribution.jsonl").open(encoding="utf-8") as stream:
+            cls.sidecar = [json.loads(line) for line in stream]
+
+    def test_no_pap_reprints(self):
+        texts = self.table.column("text").to_pylist()
+        self.assertEqual([t for t in texts if ISSUE_51_RULE.search(t)], [])
+        self.assertEqual([t for t in texts if pap_rule(t)], [])
+
+    def test_row_count_and_stats(self):
+        st = self.stats
+        self.assertEqual(self.table.num_rows, RELEASED_ROWS)
+        self.assertEqual(st["kept"], RELEASED_ROWS)
+        self.assertEqual(st["drop_pap"], sum(st["drop_pap_by_rule"].values()))
+        self.assertEqual(st["input_rows"] - st["drop_pap"], st["kept"])
+        drops = sum(v for k, v in st.items() if k.startswith("drop_") and isinstance(v, int))
+        self.assertEqual(st["read"] - drops, st["kept"])
+        self.assertEqual(st["tokens"], sum(self.table.column("token_count").to_pylist()))
+        self.assertEqual(st["chars"], sum(map(len, self.table.column("text").to_pylist())))
+        self.assertEqual(st["licenses"], {"CC-BY-SA-4.0": RELEASED_ROWS})
+        ids = self.table.column("id").to_pylist()
+        self.assertEqual(len(set(ids)), len(ids))
+
+    def test_datasheet_matches_stats(self):
+        st, md = self.stats, (DATA / "govpl.md").read_text(encoding="utf-8")
+        self.assertIn(f"| {st['kept']:,} | {st['chars']:,} | {st['tokens']:,} |", md)
+        self.assertIn(f"drop PAP reprints: **{st['drop_pap']:,}**", md)
+        self.assertIn(f"read {st['input_rows']:,} → kept {st['kept']:,}", md)
+
+    def test_sidecar_gives_every_row_a_govpl_url(self):
+        self.assertEqual([a["id"] for a in self.sidecar], self.table.column("id").to_pylist())
+        for a in self.sidecar:
+            self.assertEqual(set(a), {"id", "url", "subsite", "title", "date", "license"})
+            self.assertTrue(a["url"].startswith(BASE + "/web/" + a["subsite"] + "/"), a)
+            self.assertEqual(a["license"], "CC-BY-SA-4.0")
+
 
 if __name__ == "__main__":
     unittest.main()