Add kultura_bez_barier_pl: accessibility guides (scoped to source files)

- data/kultura_bez_barier_pl/* (9 records, 217,932 tokens), build script,
contract test, ontology manifest.
- Datasheet: license at the origin (catalogue statement quoted + per-guide
coverage and the 3 rights-based rejections), texts (genre/register/2017-11-20
.. 2024-04-19), scrubber named (pattern pass, not NERGAL) with an all-9
residual-PII spot check - real contacts found in
podsumowanie_wizyt_studyjnych (Tel./SMS label variants).
- artifacts/source_findings.md: entry appended.
- Registry entry unchanged: kultura_bez_barier_pl is already on main.

artifacts/kultura_bez_barier_pl_ontology_manifest.json

@@ -0,0 +1,181 @@
+{
+  "actors": [
+    {
+      "id": "actor:piotrsty",
+      "type": "Contributor"
+    },
+    {
+      "id": "actor:fundacja-kultury-bez-barier",
+      "type": "Organization"
+    },
+    {
+      "id": "actor:codex",
+      "type": "Agent"
+    }
+  ],
+  "claims": [
+    {
+      "falsification_condition": "A published checksum differs or the builder cannot reproduce retained text from the pinned raw PDFs.",
+      "id": "claim:replayable",
+      "statement": "The retained dataset files replay from the pinned catalogue and PDF snapshot under the published protocol.",
+      "supported_by": [
+        "evidence:checksums:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922"
+      ]
+    },
+    {
+      "falsification_condition": "The pinned catalogue lacks that declaration or a selected file is outside its demonstrated scope.",
+      "id": "claim:rights-qualified",
+      "statement": "The official catalogue presents the linked foundation-authored publications as CC BY-SA 3.0; per-PDF embedded licensing is not asserted.",
+      "supported_by": [
+        "evidence:qa:87b67c4b2f35b27cb6f9b0f80efcd335df4d6f96351635f262e527361277dd19"
+      ]
+    }
+  ],
+  "evidence": [
+    {
+      "id": "evidence:checksums:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "observation_type": "checksums",
+      "payload": {
+        "NOTICE.md": "69db282ba649ab9d7dee2d52cee24005b046fdf3371198642ecbb15f6d110d12",
+        "README.md": "04ff8ca176daa3b7a5ca926c1ee9c0f9aa481d05c9f7b68e074ca91c98cb1d77",
+        "artifacts/attribution.jsonl": "4e592737d4d9c93a67c6437d5ad3881e92f8fb9aec62064eaaa84625144cf538",
+        "artifacts/catalog.html": "7bc2a7c995dd67a58e592e63311a53f5bebe0c2c580ca403574437a3254253bf",
+        "artifacts/decisions.jsonl": "edc18820ed6819721650d59d530375246daa32e86fd7ff6e66d8bcada08ea16e",
+        "artifacts/inventory.json": "496bd4655b15e9573e346fc6322b42a59b40739580fc249c9b318e0c91d9acc5",
+        "artifacts/qa.json": "3946eb001b0f43248a54256099ff98021cf14eec4e9e94c402210f88563ead58",
+        "artifacts/raw/abc_gosc_niepelnosprawny.pdf": "8918966789ed103efca9c2272363ff7ea51e703bb90585633f16e6198dbe6ff6",
+        "artifacts/raw/abc_gosc_niepelnosprawny_cz2.pdf": "ad16b7ed02fb1aebd03c640d52c1baf664b6f7e77e013230985e5902c4dffcf1",
+        "artifacts/raw/audiodeskrypcja_obrazow.pdf": "ee6b90bf064f3ab9affc5a2568bc28a89a519a9a1cf87506ed1e0b877cba0664",
+        "artifacts/raw/audiodeskrypcja_zasady.pdf": "ada6db63e05aa2f4dd3474d1f7c7a41b74fd10c19de335015d40eb814ecba97f",
+        "artifacts/raw/checklisty_warsztaty_kulinarne.pdf": "ca8b0adbe3142fdad18bac76b35e1406b3ed020a556c26a3187efdc1d5f31095",
+        "artifacts/raw/filmolekcje.pdf": "fde70eecb7c26bbb7c3881d3c1ad1931c1ceb16e6d5ff13dfe102ddfa4aedd2a",
+        "artifacts/raw/jak_udostepniac_kulture.pdf": "9b3ad5a21a15d41025ad9d1b9ecbac95149ba8b192e85429871c57458a7d7f04",
+        "artifacts/raw/model_dostepnej_kultury_2023.pdf": "96f0600ec29fb3e4845099c03eee3c08e89d2c703ddc08db305d5c1c043abeea",
+        "artifacts/raw/napisy_dla_nieslyszacych.pdf": "ca979ff6fd85dde0d2a5e1affb5e9b6bb83e8cda6743ab231eebf0f96f8dce96",
+        "artifacts/raw/paszport_do_sztuki.pdf": "d07ae6db501eeb7cf73972e5a9efcf92f9ada5786163d87d8df20d8bc8ca539e",
+        "artifacts/raw/podsumowanie_wizyt_studyjnych.pdf": "7df24e84f13fb51ef9b4257dce527e626c18c2c55fc80b3ef38489a96f6b6ac5",
+        "artifacts/raw/przewodnik_po_dostepnosci.pdf": "84cf7c9694556be3c5926fee6613cd81a57416346c69a6e03a749c9432931fc8",
+        "artifacts/run.json": "d2513ac92491de72a18ddbec55c38b79d17f37d6060cd49a0671be9e07df6c25",
+        "artifacts/sample.jsonl": "9ce1a4cc8f2b6a8882f1a795d3b7f8bbb133c9c81ae6507830bb7b2a2f1bd7e5",
+        "artifacts/stats.json": "5fc1c11510ed0536bb3a4f2c86397006642911d8542c9c28bc88dacefa392ac3",
+        "data/train-00000-of-00001.parquet": "1d9cd403ab297b3a8a84ce6ae7a25e4f4fd5025b37be959e4692a5170ed64642",
+        "src/build_kultura_bez_barier_pl.py": "18ce80a8e4fcc7555c687e5fc810b97565eef51255667f69375b3dd6e5932b27",
+        "src/requirements.txt": "807ccb72d622706ea3b41d39190c6258a17d4f5472eeab294a9d483eb4c44ac1",
+        "src/test_kultura_bez_barier_contribution.py": "68bce1bd6c383130f94b27e2c8dea384298e45848e002a22be6718158c967777"
+      },
+      "produced_by": "run:3aa251975f82e4a35004fad877d29b933ed49d4308072502e3b193f90babd737"
+    },
+    {
+      "id": "evidence:qa:87b67c4b2f35b27cb6f9b0f80efcd335df4d6f96351635f262e527361277dd19",
+      "observation_type": "qa",
+      "payload": {
+        "benchmark_overlap": "pending",
+        "cross_source_dedup": "pending target integration",
+        "exact_normalized_dedup": true,
+        "license_gate": "official catalogue-level CC BY-SA 3.0 declaration; per-PDF embedded notices not required or asserted",
+        "limitations": [
+          "catalogue-level rights statement requires maintainer/legal interpretation for each linked publication",
+          "PDF extraction can flatten tables and omit images",
+          "embedded third-party quotations require review",
+          "pattern checks are not comprehensive de-identification",
+          "text novelty and training benefit are not asserted"
+        ],
+        "near_dedup": {
+          "method": "seeded MinHash 128 / LSH 0.8 candidates / exact 5-word Jaccard >= 0.9",
+          "removed": []
+        },
+        "pii_pattern_matches": {
+          "email": 16,
+          "labelled_phone": 1
+        }
+      },
+      "produced_by": "run:e451d83a46337b6ac0db4abe552a9775b110b06876b6ec252922ddb4c18fd657"
+    }
+  ],
+  "objects": [
+    {
+      "id": "object:source:kultura-bez-barier",
+      "type": "Source"
+    },
+    {
+      "id": "object:dataset:kultura-bez-barier-pl",
+      "type": "Dataset"
+    }
+  ],
+  "pending": [
+    "cross-source deduplication",
+    "benchmark contamination check",
+    "maintainer/legal review of catalogue-level license scope",
+    "controlled training ablation"
+  ],
+  "protocols": [
+    {
+      "id": "protocol:pdf-text-v1",
+      "procedure": "allowlist, pdfplumber extraction, normalization, PII patterns, exact and seeded near dedup"
+    },
+    {
+      "id": "protocol:contract-v1",
+      "procedure": "schema, checksum, sample, rights-evidence and ontology contract checks"
+    }
+  ],
+  "relations": [
+    {
+      "predicate": "DERIVED_FROM",
+      "source": "version:dataset:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "target": "version:source:a0e0c66be7bd6125a223d7d3be7143f0cc9bd7cc6026e8c4051ebdd8670c3c00"
+    },
+    {
+      "predicate": "GENERATED_BY",
+      "source": "version:dataset:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "target": "run:e451d83a46337b6ac0db4abe552a9775b110b06876b6ec252922ddb4c18fd657"
+    },
+    {
+      "predicate": "VALIDATED_AGAINST",
+      "source": "version:dataset:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "target": "run:3aa251975f82e4a35004fad877d29b933ed49d4308072502e3b193f90babd737"
+    }
+  ],
+  "runs": [
+    {
+      "finished_at": "2026-09-07T06:52:45.774841+00:00",
+      "id": "run:e451d83a46337b6ac0db4abe552a9775b110b06876b6ec252922ddb4c18fd657",
+      "protocol": "protocol:pdf-text-v1",
+      "started_at": "2026-09-07T06:51:36.737857+00:00",
+      "success": true
+    },
+    {
+      "finished_at": "2026-09-07T06:56:10.112370+00:00",
+      "id": "run:3aa251975f82e4a35004fad877d29b933ed49d4308072502e3b193f90babd737",
+      "protocol": "dataset-contract-and-checksum-validation-v1",
+      "started_at": "2026-09-07T06:56:10.112370+00:00",
+      "stats": {
+        "acquired": 12,
+        "added": "2026-09-07",
+        "author_coverage": 1.0,
+        "characters": 608827,
+        "discovered": 12,
+        "kept": 9,
+        "pages": 316,
+        "rejected": 3,
+        "sample_count": 9,
+        "tokens": 217932,
+        "unknown_created": 0
+      },
+      "success": true,
+      "target_main_revision": "a916edecabc2be8832e08fb2bd9dfafcc1d2dd71"
+    }
+  ],
+  "schema": "slayer-research-ontology-profile-v1",
+  "versions": [
+    {
+      "content_address": "a0e0c66be7bd6125a223d7d3be7143f0cc9bd7cc6026e8c4051ebdd8670c3c00",
+      "id": "version:source:a0e0c66be7bd6125a223d7d3be7143f0cc9bd7cc6026e8c4051ebdd8670c3c00",
+      "object": "object:source:kultura-bez-barier"
+    },
+    {
+      "content_address": "99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "id": "version:dataset:99aefe134f168e718b685ddd6c7b7cd722ff56b66afa3ed27742fc827c02a922",
+      "object": "object:dataset:kultura-bez-barier-pl"
+    }
+  ]
+}

artifacts/source_findings.md

@@ -685,3 +685,38 @@ suffices.
 label-anchored patterns (same lesson as `open_icm_pl`'s glyph noise): a zero
 pattern count is not evidence in contact-bearing registers — run the spot check
 and the model scrubber.
+
+---
+
+## kultura_bez_barier_pl — cultural-accessibility guides (FKzB)
+
+**Investigated** — 2026-09-07 (review round 2026-09-28).
+
+**Verdict** — `added` (proposed with `release: None`). 9 guides / 218k
+`cl100k_base` tokens (316 pages) of prepared didactic Polish for cultural-sector
+accessibility work - tiny, but a clean CC BY-SA 3.0 source with preserved raw
+PDFs and per-record evidence.
+
+**Enumeration** — the foundation's catalogue <https://kulturabezbarier.org/publikacje/>:
+12 linked publications discovered, 9 retained. 3 rejected conservatively: 2 NIMOZ
+co-published volumes (PDF copyright notices name the third-party institute) and
+1 for legacy-font extraction damage.
+
+**License evidence** — the catalogue's own statement (quoted in the datasheet)
+offers the foundation-authored publications under CC BY-SA 3.0 with attribution
+and share-alike terms; reading is catalogue-level ("plik pierwotny"), pictograms
+explicitly included, no per-PDF embedded assertion claimed. Per-record
+corroboration: PDF metadata + credit lines; `attribution.jsonl` pins the
+evidence URL and scope note.
+
+**Blockers** — none to merge with `release: None`. Before release: NERGAL pass —
+the all-9 spot check found **real residual contacts** in
+`podsumowanie_wizyt_studyjnych` (coordinator names + phones under `Tel./SMS`
+label variants the pattern misses, e-mails beside them redacted) — and
+maintainer sign-off on the catalogue-level scope reading.
+
+**Lesson** — catalogue-level license statements need the reading written down
+(what "je" covers), and the safest per-record confirmation is negative: reject
+every item with third-party authorship signals, as this PR does with the NIMOZ
+volumes. Also: `Tel./SMS`-style label variants defeat label-anchored phone
+patterns — third independent pattern-evasion case in this review round.

data/kultura_bez_barier_pl/NOTICE.md

@@ -0,0 +1,7 @@
+# Notice and attribution
+
+Source: https://kulturabezbarier.org/publikacje/
+
+The official catalogue describes the linked publications as authored by Fundacja Kultury bez Barier and states that they are made available under CC BY-SA 3.0. The catalogue HTML, raw PDFs, source URLs and SHA-256 digests are preserved. This is catalogue-level evidence; an embedded per-PDF license assertion is not claimed.
+
+Dataset transformations: text extraction, removal of page-number-only lines, line-wrap repair, Unicode/whitespace normalization, limited PII-pattern redaction, exact and near deduplication. Images are not included in the training text. Attribution and a modification notice must be preserved under CC BY-SA 3.0.

data/kultura_bez_barier_pl/kultura_bez_barier_pl.attribution.jsonl

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

data/kultura_bez_barier_pl/kultura_bez_barier_pl.decisions.jsonl

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

data/kultura_bez_barier_pl/kultura_bez_barier_pl.md

@@ -0,0 +1,91 @@
+---
+license: cc-by-sa-3.0
+language:
+- pl
+task_categories:
+- text-generation
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-00000-of-00001.parquet
+---
+
+# Kultura bez Barier PL
+
+Polish text extracted from openly published accessibility guides by Fundacja Kultury bez Barier.
+
+- Input publications: 12
+- Retained records: 9
+- Extracted pages: 316
+- Tokens: 217,932 (`cl100k_base` proxy)
+- License evidence: catalogue-level CC BY-SA 3.0 declaration
+- Author coverage: 100.0%
+
+See `NOTICE.md` and `artifacts/` for the source inventory, raw PDFs, attribution, selection decisions, QA, checksums, samples and Slayer ontology manifest.
+
+## License at the origin (and per-guide coverage)
+
+The origin is the foundation's own publication catalogue:
+<https://kulturabezbarier.org/publikacje/>. Its statement, verbatim: "Poniżej
+znajdują się publikacje autorstwa Fundacji Kultury bez Barier, takie jak
+przewodniki i poradniki pomocne w pracy z osobami z niepełnosprawnościami. Wśród
+nich znajdują się piktogramy ilustrujące dostępność. Oddajemy je na licencji
+Creative Commons (CC BY-SA 3.0). Oznacza to, że można ich używać (podając
+autora), zmieniać (wskazując te zmiany) i rozpowszechniać (na tej samej
+licencji co plik pierwotny, czyli nasz)." The grant ("Oddajemy je na licencji…",
+with the distribution terms referring to "plik pierwotny") covers the offered
+foundation-authored publication files, with the accessibility pictograms
+highlighted as included; the pronoun sits next to "piktogramy", so the reading
+is catalogue-level, not per-PDF — exactly what `license_scope_note` records in
+`attribution.jsonl`. The catalogue HTML is pinned in the source snapshot.
+
+Per-guide coverage for the 9 retained records: each is a foundation-authored
+entry of that catalogue (authorship corroborated per record by the catalogue
+statement plus PDF metadata/credit lines in `attribution.jsonl`). The 3 other
+catalogue items were **rejected on rights/authorship grounds** - both volumes of
+`ABC gość niepełnosprawny` name Narodowy Instytut Muzealnictwa i Ochrony
+Zbiorów (NIMOZ) in the PDF copyright notice (the foundation is a project
+partner there), and `Audiodeskrypcja - zasady` was dropped for legacy-font
+extraction damage. A third-party-authorship red flag therefore removes the item
+rather than being argued away.
+
+## What the texts are
+
+- **Genre**: accessibility guides and handbooks for cultural institutions -
+  practical checklists ("Warsztaty kulinarne dla osób niewidomych"), rules and
+  how-to guides ("Napisy dla osób niesłyszących", "Przewodnik po dostępności"),
+  a strategic report ("Model dostępnej kultury 2023"), study-visit summaries.
+- **Register**: prepared didactic/institutional Polish - clear instructive prose,
+  lists, checklists, directory-style contact sections; professionally edited,
+  aimed at cultural-sector staff. Not OCR'd (born-digital PDFs), not
+  machine-translated.
+- **Time span**: PDF creation dates `2017-11-20` - `2024-04-19` (per-record
+  `created`; `created_semantics` records the provenance of each date).
+
+## Scrubber and residual-PII spot check
+
+Scrubber that ran: **pattern redaction in `src/build_kultura_bez_barier_pl.py`**
+(e-mail -> `[REDACTED:EMAIL]`, labelled phone -> `[REDACTED:PHONE]`, limited
+patterns). This is **not**
+[SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL); the shard must be
+re-run through NERGAL before it is admitted to a release. Merge with
+`release: None` is fine meanwhile.
+
+The spot check covers **all 9 records** (the shard is tiny): 14 e-mail
+redactions confirm the scrubber works, but **real residual contacts survive in
+`kultura_bez_barier_pl_podsumowanie_wizyt_studyjnych`** - a published directory
+of museum accessibility coordinators where names and phones stay while the
+e-mail beside them is redacted: "Emila Kamola Tel./SMS + 48 509 490 034
+e-mail: [REDACTED:EMAIL]", "Katarzyna Lubas Tel./SMS: 535 36 37 09", and a bare
+"Tel/SMS: 504449027". The label-anchored phone pattern misses the `Tel./SMS` /
+`Tel/SMS` label variants and unlabelled numbers, and personal names are out of
+its scope entirely. Other hits are benign: 8 museum addresses (`ul.`), 17
+instructive mentions of "telefon", one Facebook URL with an id. These are
+published professional contacts in a CC BY-SA guide, but they are identifiable
+individuals' data - residual risk is HIGH for this record, low for the other
+eight.
+
+## Limitations
+
+The source catalogue provides the licensing statement; an embedded statement was not found or required for every PDF. Maintainer/legal review of that scope remains appropriate. PDF extraction may flatten tables and omit visual meaning. Cross-source DynaWord deduplication, benchmark-overlap checks and controlled training ablations remain pending.

data/kultura_bez_barier_pl/kultura_bez_barier_pl.parquet

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

data/kultura_bez_barier_pl/kultura_bez_barier_pl.qa.json

@@ -0,0 +1,21 @@
+{
+  "benchmark_overlap": "pending",
+  "cross_source_dedup": "pending target integration",
+  "exact_normalized_dedup": true,
+  "license_gate": "official catalogue-level CC BY-SA 3.0 declaration; per-PDF embedded notices not required or asserted",
+  "limitations": [
+    "catalogue-level rights statement requires maintainer/legal interpretation for each linked publication",
+    "PDF extraction can flatten tables and omit images",
+    "embedded third-party quotations require review",
+    "pattern checks are not comprehensive de-identification",
+    "text novelty and training benefit are not asserted"
+  ],
+  "near_dedup": {
+    "method": "seeded MinHash 128 / LSH 0.8 candidates / exact 5-word Jaccard >= 0.9",
+    "removed": []
+  },
+  "pii_pattern_matches": {
+    "email": 16,
+    "labelled_phone": 1
+  }
+}

data/kultura_bez_barier_pl/kultura_bez_barier_pl.stats.json

@@ -0,0 +1,13 @@
+{
+  "acquired": 12,
+  "added": "2026-09-07",
+  "author_coverage": 1.0,
+  "characters": 608827,
+  "discovered": 12,
+  "kept": 9,
+  "pages": 316,
+  "rejected": 3,
+  "sample_count": 9,
+  "tokens": 217932,
+  "unknown_created": 0
+}

src/build_kultura_bez_barier_pl.py

@@ -0,0 +1,578 @@
+#!/usr/bin/env python3
+"""Acquire, normalize, validate and publish Polish Kultura bez Barier publications."""
+from __future__ import annotations
+
+import argparse
+import ast
+from collections import Counter
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import pprint
+import re
+import shutil
+import subprocess
+import sys
+import time
+import unicodedata
+from urllib.parse import unquote
+
+import pdfplumber
+import requests
+from pypdf import PdfReader
+
+CATALOG = "https://kulturabezbarier.org/publikacje/"
+SOURCE = "kultura_bez_barier_pl"
+OWN_REPO = "PiotrSty/kultura-bez-barier-pl"
+TARGET = "SlayerLab/polish-dynaword"
+LICENSE = "CC-BY-SA-3.0"
+LICENSE_URL = "https://creativecommons.org/licenses/by-sa/3.0/"
+AUTHOR = "Fundacja Kultury bez Barier"
+FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+UA = "KulturaBezBarierTextResearch/1.0 (PiotrSty; open Polish publication corpus)"
+
+PUBLICATIONS = (
+    ("checklisty_warsztaty_kulinarne", "Checklisty - warsztaty kulinarne dla osob z niepelnosprawnosciami", "https://kulturabezbarier.org/wp-content/uploads/2024/04/Checklisty-%E2%80%94-warsztaty-kulinarne-dla-osob-z-niepelnosprawnosciami.pdf"),
+    ("model_dostepnej_kultury_2023", "Model dostepnej kultury", "https://kulturabezbarier.org/wp-content/uploads/2024/04/Model_Dostepnej_Kultury_2023.pdf"),
+    ("audiodeskrypcja_obrazow", "Audiodeskrypcja obrazow - publikacja na 10 lat wspolnej pracy", "https://kulturabezbarier.org/wp-content/uploads/2022/04/Audiodeskrypcja-obrazo%CC%81w_publikacja-na-10-lat-wspo%CC%81lnej-pracy.pdf"),
+    ("jak_udostepniac_kulture", "Jak udostepniac kulture osobom z niepelnosprawnosciami", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Publikacja_FKBB.pdf"),
+    ("podsumowanie_wizyt_studyjnych", "Podsumowanie wizyt studyjnych", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Podsumowanie.pdf"),
+    ("przewodnik_po_dostepnosci", "Przewodnik po dostepnosci", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Otwarci-dla-wszystkich-publikacja-www.pdf"),
+    ("paszport_do_sztuki", "Paszport do sztuki - dziennik z wyprawy", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Gietko_FKBB_Paszport_do_sztuki_publikacja_do_netu.pdf"),
+    ("filmolekcje", "Filmolekcje dla kazdego", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Filmolekcje-2.pdf"),
+    ("abc_gosc_niepelnosprawny", "ABC Gosc niepelnosprawny w muzeum", "https://kulturabezbarier.org/wp-content/uploads/2019/12/ABC_Gosc_niepelnosprawny_lekki.pdf"),
+    ("abc_gosc_niepelnosprawny_cz2", "ABC Gosc niepelnosprawny w muzeum cz. 2", "https://kulturabezbarier.org/wp-content/uploads/2019/12/ABC_Gosc_niepelnosprawny_cz2.pdf"),
+    ("audiodeskrypcja_zasady", "Audiodeskrypcja - zasady tworzenia", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Audiodeskrypcja-zasady-tworzenia.pdf"),
+    ("napisy_dla_nieslyszacych", "Napisy dla osob nieslyszacych i slaboslyszacych - zasady tworzenia", "https://kulturabezbarier.org/wp-content/uploads/2019/12/Napisy-dla-nieslyszacych_zasady-tworzenia_2019.pdf"),
+)
+
+AUTHORS = {
+    "checklisty_warsztaty_kulinarne": "Julianna Matuszewska",
+    "model_dostepnej_kultury_2023": "Fundacja Kultury bez Barier; Robert Więckowski",
+    "audiodeskrypcja_obrazow": "Robert Więckowski; Anna Żórawska; Fundacja Kultury bez Barier",
+    "jak_udostepniac_kulture": "Fundacja Kultury bez Barier",
+    "podsumowanie_wizyt_studyjnych": "Fundacja Kultury bez Barier",
+    "przewodnik_po_dostepnosci": "Monika Dubiel; Izabela Sopalska-Rybak; Aleksandra Szorc; Aleksandra Sztajerwald; Robert Więckowski",
+    "paszport_do_sztuki": "Fundacja Kultury bez Barier",
+    "filmolekcje": "Monika Dubiel; Aleksandra Szorc",
+    "napisy_dla_nieslyszacych": "Izabela Künstler; Urszula Butkiewicz",
+}
+
+RIGHTS_CONFLICTS = {
+    "abc_gosc_niepelnosprawny": "PDF copyright notice names Narodowy Instytut Muzealnictwa i Ochrony Zbiorów",
+    "abc_gosc_niepelnosprawny_cz2": "PDF identifies the NIMOZ training series and foundation as a project partner",
+}
+
+LEGACY_GARBLE_WORDS = (
+    "widad", "dad", "mied", "byd", "kooca", "przestrzeo", "poznad", "zostad",
+    "współgrad", "uwzględnid", "zamieścid",
+)
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def sha(value):
+    if not isinstance(value, bytes):
+        value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()
+    return hashlib.sha256(value).hexdigest()
+
+
+def save(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+
+
+def load(path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_lines(path, rows):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+
+
+def read_lines(path):
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+
+
+def normalize(text):
+    text = unicodedata.normalize("NFKC", text).replace("\u00ad", "").replace("\u200b", "")
+    text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text)
+    lines = [re.sub(r"[ \t\xa0]+", " ", line).strip() for line in text.splitlines()]
+    return re.sub(r"\n{3,}", "\n\n", "\n".join(lines)).strip()
+
+
+def http_get(url, attempts=5):
+    response = None
+    for attempt in range(attempts):
+        response = requests.get(url, timeout=(20, 120), headers={"User-Agent": UA, "Accept-Language": "pl"})
+        if response.status_code not in (429, 500, 502, 503, 504):
+            response.raise_for_status()
+            return response
+        time.sleep(2 ** attempt)
+    response.raise_for_status()
+
+
+def catalog_license_evidence(html):
+    text = normalize(re.sub(r"<[^>]+>", " ", html))
+    compact = " ".join(text.split())
+    required = ("publikacje autorstwa Fundacji Kultury bez Barier", "CC BY-SA 3.0")
+    if not all(phrase.casefold() in compact.casefold() for phrase in required):
+        raise ValueError("catalogue-level authorship/license declaration not found")
+    if re.search(r"(?i)CC\s*BY[- ]NC|licenses/by-nc", compact):
+        raise ValueError("noncommercial marker found in catalogue")
+    marker = compact.casefold().index("publikacje autorstwa")
+    return compact[marker:marker + 700]
+
+
+def pdf_created(metadata):
+    raw = str((metadata or {}).get("/CreationDate", ""))
+    match = re.search(r"D:(\d{4})(\d{2})(\d{2})", raw)
+    if match:
+        year, month, day = map(int, match.groups())
+        if 1990 <= year <= datetime.now().year and 1 <= month <= 12 and 1 <= day <= 31:
+            return f"{year:04d}-{month:02d}-{day:02d}"
+    return "unknown"
+
+
+def extract_pdf(path):
+    reader = PdfReader(path)
+    pages = []
+    failures = []
+    with pdfplumber.open(path) as document:
+        for index, page in enumerate(document.pages, 1):
+            try:
+                pages.append(normalize(page.extract_text() or ""))
+            except Exception as error:
+                pages.append("")
+                failures.append({"page": index, "error": str(error)})
+    return {
+        "page_count": len(reader.pages),
+        "metadata": {str(k): str(v) for k, v in (reader.metadata or {}).items()},
+        "pages": pages,
+        "page_failures": failures,
+    }
+
+
+def acquire(out):
+    if (out / "inventory.json").exists():
+        raise ValueError("inventory exists; use a fresh output for a new immutable acquisition")
+    out.mkdir(parents=True, exist_ok=True)
+    raw_dir = out / "raw"
+    raw_dir.mkdir(exist_ok=True)
+    catalog = http_get(CATALOG)
+    (out / "catalog.html").write_bytes(catalog.content)
+    declaration = catalog_license_evidence(catalog.text)
+    normalized_catalog = unicodedata.normalize("NFC", unquote(catalog.text)).casefold()
+    records, failures = [], []
+    for index, (slug, title, url) in enumerate(PUBLICATIONS, 1):
+        try:
+            normalized_name = unicodedata.normalize("NFC", unquote(Path(url).name)).casefold()
+            if normalized_name not in normalized_catalog:
+                raise ValueError("allowlisted URL not found in catalogue HTML")
+            response = http_get(url)
+            if not response.content.startswith(b"%PDF"):
+                raise ValueError("response is not a PDF")
+            path = raw_dir / f"{slug}.pdf"
+            path.write_bytes(response.content)
+            extracted = extract_pdf(path)
+            records.append({"slug": slug, "title": title, "url": url, "observed_at": now(),
+                "pdf_sha256": sha(response.content), "bytes": len(response.content), **extracted})
+        except Exception as error:
+            failures.append({"slug": slug, "url": url, "error": str(error)})
+        print(f"Acquired {index}/{len(PUBLICATIONS)}; failures={len(failures)}", flush=True)
+        time.sleep(0.2)
+    save(out / "inventory.json", {"catalog_url": CATALOG, "catalog_sha256": sha(catalog.content),
+        "catalog_observed_at": now(), "catalog_license_evidence": declaration,
+        "license_scope_note": "Catalogue-level declaration adjacent to the linked publications; not a per-PDF embedded assertion.",
+        "selected_publications": [list(item) for item in PUBLICATIONS], "records": records, "failures": failures,
+        "explicit_exclusions": ["German Model edition", "PNG/SVG pictograms", "Igor comic", "duplicate DOCX rendition"]})
+    if failures:
+        raise ValueError("acquisition incomplete; inspect inventory failures")
+
+
+def repair_wrapped_text(pages):
+    output = []
+    for page in pages:
+        lines = [line for line in page.splitlines() if not re.fullmatch(r"\s*\d{1,3}\s*", line)]
+        text = "\n".join(lines)
+        text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text)
+        text = re.sub(r"(?<![.!?:;])\n(?=[a-ząćęłńóśźż])", " ", text)
+        output.append(normalize(text))
+    return normalize("\n\n".join(part for part in output if part))
+
+
+def credit_lines(pages):
+    selected = pages[:3] + pages[-3:]
+    pattern = re.compile(r"(?i)(?:^|\b)(autor(?:zy|ka|ki)?|teksty|opracowanie|redakcja|publikację wspólnie stworzyli|copyright|©)(?:\b|:)")
+    return [normalize(line)[:500] for page in selected for line in page.splitlines() if pattern.search(line)][:40]
+
+
+def near_dedup(rows):
+    from datasketch import MinHash, MinHashLSH
+    index = MinHashLSH(threshold=0.8, num_perm=128)
+    features, kept, removed = {}, [], []
+    for row in rows:
+        words = re.findall(r"\w+", row["text"].casefold())
+        shingles = {" ".join(words[i:i + 5]).encode() for i in range(max(0, len(words) - 4))}
+        sig = MinHash(num_perm=128, seed=1)
+        if not shingles:
+            kept.append(row)
+            continue
+        sig.update_batch(sorted(shingles))
+        for candidate in sorted(index.query(sig)):
+            score = len(shingles & features[candidate]) / len(shingles | features[candidate])
+            if score >= 0.9:
+                removed.append({"id": row["id"], "duplicate_of": candidate, "jaccard": score})
+                break
+        else:
+            kept.append(row)
+            features[row["id"]] = shingles
+            index.insert(row["id"], sig)
+    return kept, removed
+
+
+def build(out):
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    import tiktoken
+    from langid.langid import LanguageIdentifier, model
+    inventory = load(out / "inventory.json")
+    if inventory["failures"] or len(inventory["records"]) != len(PUBLICATIONS):
+        raise ValueError("cannot build from incomplete inventory")
+    encoder = tiktoken.get_encoding("cl100k_base")
+    identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
+    identifier.set_languages(["pl", "en", "de", "cs", "sk", "uk", "ru"])
+    rows, attribution, decisions, seen = [], [], [], {}
+    pii = Counter()
+    added = inventory["catalog_observed_at"][:10]
+    for record in sorted(inventory["records"], key=lambda item: item["slug"]):
+        path = out / "raw" / f"{record['slug']}.pdf"
+        if sha(path.read_bytes()) != record["pdf_sha256"]:
+            raise ValueError("raw PDF checksum mismatch: " + record["slug"])
+        body = repair_wrapped_text(record["pages"])
+        letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", body))
+        garbled_controls = sum(0x80 <= ord(char) <= 0x9F or ord(char) == 0xFFFD for char in body)
+        combining_marks = sum(unicodedata.combining(char) > 0 for char in body)
+        legacy_garble_words = sum(body.casefold().count(word.casefold()) for word in LEGACY_GARBLE_WORDS)
+        reason = ""
+        if record["slug"] in RIGHTS_CONFLICTS:
+            reason = "rights_or_authorship_conflict"
+        elif record["page_failures"]:
+            reason = "page_extraction_failure"
+        elif garbled_controls:
+            reason = "text_extraction_garbled"
+        elif combining_marks:
+            reason = "text_extraction_split_diacritics"
+        elif legacy_garble_words > 10:
+            reason = "text_extraction_legacy_font_mapping"
+        elif len(body) < 1000:
+            reason = "too_little_extractable_text"
+        elif letters / max(len(body), 1) < 0.55:
+            reason = "low_letter_ratio"
+        language, confidence = identifier.classify(body[:20000]) if body else ("unknown", 0.0)
+        if not reason and language != "pl" and confidence >= 0.98:
+            reason = "non_polish"
+        body, emails = re.subn(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", "[REDACTED:EMAIL]", body)
+        body, phones = re.subn(r"(?i)(?:\btelefon|\btel\.)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b", "[REDACTED:PHONE]", body)
+        pii.update(email=emails, labelled_phone=phones)
+        text = body
+        key = " ".join(text.casefold().split())
+        if not reason and key in seen:
+            reason = "normalized_duplicate"
+        row_id = SOURCE + "_" + record["slug"]
+        decisions.append({"id": row_id, "selected": not bool(reason), "reason": reason or "include",
+            "pdf_sha256": record["pdf_sha256"], "page_count": record["page_count"],
+            "language": language, "language_confidence": float(confidence), "garbled_controls": garbled_controls,
+            "combining_marks": combining_marks, "legacy_garble_words": legacy_garble_words,
+            "rights_conflict": RIGHTS_CONFLICTS.get(record["slug"])})
+        if reason:
+            continue
+        seen[key] = row_id
+        created = pdf_created(record["metadata"])
+        author = AUTHORS[record["slug"]]
+        rows.append({"id": row_id, "text": text, "source": SOURCE, "added": added,
+            "created": created, "token_count": len(encoder.encode_ordinary(text)), "license": LICENSE, "author": author})
+        attribution.append({"id": row_id, "slug": record["slug"], "title": record["title"], "url": record["url"], "publisher": AUTHOR,
+            "author": author, "author_basis": "Official catalogue authorship statement plus PDF metadata or publication credit lines where available.",
+            "pdf_metadata": record["metadata"], "credit_lines": credit_lines(record["pages"]),
+            "created": created, "created_semantics": "PDF CreationDate metadata when valid; otherwise unknown",
+            "license": LICENSE, "license_url": LICENSE_URL, "license_evidence_url": CATALOG,
+            "license_scope_note": inventory["license_scope_note"], "pdf_sha256": record["pdf_sha256"],
+            "text_sha256": sha(text.encode()), "page_count": record["page_count"], "language": language,
+            "language_confidence": float(confidence), "transformations": ["pdfplumber page text extraction", "page-number removal",
+                "line-wrap and hyphen repair", "Unicode and whitespace normalization", "email and labelled-phone redaction"]})
+    rows, near_removed = near_dedup(rows)
+    removed = {item["id"]: item for item in near_removed}
+    for decision in decisions:
+        if decision["id"] in removed:
+            decision.update(selected=False, reason="near_duplicate", duplicate_of=removed[decision["id"]]["duplicate_of"], jaccard=removed[decision["id"]]["jaccard"])
+    kept_ids = {row["id"] for row in rows}
+    attribution = [item for item in attribution if item["id"] in kept_ids]
+    root = out / "hf_repo"
+    (root / "data").mkdir(parents=True, exist_ok=True)
+    (root / "artifacts/raw").mkdir(parents=True, exist_ok=True)
+    schema = pa.schema([(field, pa.int64() if field == "token_count" else pa.string()) for field in FIELDS])
+    pq.write_table(pa.Table.from_pylist(rows, schema=schema), root / "data/train-00000-of-00001.parquet", compression="zstd")
+    write_lines(root / "artifacts/attribution.jsonl", attribution)
+    write_lines(root / "artifacts/decisions.jsonl", decisions)
+    samples = sorted(rows, key=lambda row: sha(("sample:" + row["id"]).encode()))[:12]
+    write_lines(root / "artifacts/sample.jsonl", samples)
+    inventory_copy = dict(inventory)
+    inventory_copy["records"] = [{k: v for k, v in item.items() if k != "pages"} for item in inventory["records"]]
+    save(root / "artifacts/inventory.json", inventory_copy)
+    catalog_snapshot = out / "catalog.html"
+    if sha(catalog_snapshot.read_bytes()) != inventory["catalog_sha256"]:
+        raise ValueError("catalogue snapshot checksum mismatch")
+    shutil.copy2(catalog_snapshot, root / "artifacts/catalog.html")
+    for record in inventory["records"]:
+        shutil.copy2(out / "raw" / f"{record['slug']}.pdf", root / "artifacts/raw" / f"{record['slug']}.pdf")
+    stats = {"discovered": len(PUBLICATIONS), "acquired": len(inventory["records"]), "kept": len(rows),
+        "rejected": len(decisions) - len(rows), "tokens": sum(row["token_count"] for row in rows),
+        "characters": sum(len(row["text"]) for row in rows), "pages": sum(item["page_count"] for item in attribution),
+        "sample_count": len(samples), "author_coverage": sum(bool(row["author"]) for row in rows) / len(rows) if rows else 0,
+        "unknown_created": sum(row["created"] == "unknown" for row in rows), "added": added}
+    qa = {"license_gate": "official catalogue-level CC BY-SA 3.0 declaration; per-PDF embedded notices not required or asserted",
+        "pii_pattern_matches": dict(pii), "exact_normalized_dedup": True,
+        "near_dedup": {"method": "seeded MinHash 128 / LSH 0.8 candidates / exact 5-word Jaccard >= 0.9", "removed": near_removed},
+        "cross_source_dedup": "pending target integration", "benchmark_overlap": "pending",
+        "limitations": ["catalogue-level rights statement requires maintainer/legal interpretation for each linked publication",
+            "PDF extraction can flatten tables and omit images", "embedded third-party quotations require review",
+            "pattern checks are not comprehensive de-identification", "text novelty and training benefit are not asserted"]}
+    save(root / "artifacts/stats.json", stats)
+    save(root / "artifacts/qa.json", qa)
+    run = {"id": "run:" + sha({"code": sha(Path(__file__).read_bytes()), "catalog": inventory["catalog_sha256"],
+        "pdfs": [item["pdf_sha256"] for item in inventory["records"]]}), "started_at": inventory["catalog_observed_at"],
+        "finished_at": now(), "code_sha256": sha(Path(__file__).read_bytes()), "success": True,
+        "inputs": {"catalog_sha256": inventory["catalog_sha256"], "pdf_sha256": [item["pdf_sha256"] for item in inventory["records"]]}, "stats": stats}
+    save(root / "artifacts/run.json", run)
+    print(json.dumps(stats, ensure_ascii=False, indent=2), flush=True)
+
+
+def checksums(root):
+    excluded = {"artifacts/checksums.json", "artifacts/ontology.json", "artifacts/validation_run.json"}
+    return {path.relative_to(root).as_posix(): sha(path.read_bytes()) for path in sorted(root.rglob("*"))
+            if path.is_file() and path.relative_to(root).as_posix() not in excluded}
+
+
+def registry(base):
+    tree = ast.parse(base)
+    node = next(item.value for item in tree.body if isinstance(item, ast.Assign)
+                and any(isinstance(target, ast.Name) and target.id == "SOURCES" for target in item.targets))
+    if SOURCE in ast.literal_eval(node):
+        raise ValueError("source already registered")
+    entry = {"file_key": SOURCE, "pretty": "Kultura bez Barier - Polish accessibility guides",
+        "license": LICENSE, "license_spdx": LICENSE,
+        "traceable": "Official publication catalogue declares the linked foundation-authored materials CC BY-SA 3.0; raw PDFs, catalogue HTML, URLs, hashes, attribution and exclusions are preserved.",
+        "upstream": CATALOG, "provenance": "Pinned PiotrSty/kultura-bez-barier-pl snapshot acquired from the official Fundacja Kultury bez Barier publication catalogue.",
+        "domain": "instructional/cultural-accessibility", "created": "per-record PDF metadata or unknown", "is_ocr": False, "custom_datasheet": True}
+    offset = sum(len(line) for line in base.splitlines(keepends=True)[:node.lineno - 1]) + node.col_offset + 1
+    return base[:offset] + "\n    " + repr(SOURCE) + ": " + pprint.pformat(entry, width=96, sort_dicts=False).replace("\n", "\n    ") + "," + base[offset:]
+
+
+def verify_core(out):
+    import pyarrow.parquet as pq
+    root = out / "hf_repo"
+    table = pq.read_table(root / "data/train-00000-of-00001.parquet")
+    rows = table.to_pylist()
+    stats = load(root / "artifacts/stats.json")
+    attribution = read_lines(root / "artifacts/attribution.jsonl")
+    decisions = read_lines(root / "artifacts/decisions.jsonl")
+    sample = read_lines(root / "artifacts/sample.jsonl")
+    assert table.column_names == FIELDS
+    assert len(rows) == stats["kept"] == len(attribution)
+    assert len(decisions) == stats["discovered"]
+    assert sum(bool(item["selected"]) for item in decisions) == stats["kept"]
+    assert sum(row["token_count"] for row in rows) == stats["tokens"]
+    assert {row["id"] for row in rows} == {item["id"] for item in attribution}
+    assert all(row["source"] == SOURCE and row["license"] == LICENSE and row["author"] for row in rows)
+    assert not ({item["slug"] for item in attribution} & set(RIGHTS_CONFLICTS))
+    assert all(not re.search(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", row["text"]) for row in rows)
+    by_id = {row["id"]: row for row in rows}
+    assert len(sample) == min(12, len(rows)) and all(by_id[item["id"]] == item for item in sample)
+    if (root / "artifacts/checksums.json").exists():
+        for name, digest in load(root / "artifacts/checksums.json").items():
+            assert sha((root / name).read_bytes()) == digest
+    return stats
+
+
+def prepare(out, target_revision):
+    root = out / "hf_repo"
+    (root / "src").mkdir(exist_ok=True)
+    shutil.copy2(Path(__file__), root / "src/build_kultura_bez_barier_pl.py")
+    shutil.copy2(Path(__file__).with_name("kultura_bez_barier_requirements.txt"), root / "src/requirements.txt")
+    shutil.copy2(Path(__file__).with_name("test_kultura_bez_barier_contribution.py"), root / "src/test_kultura_bez_barier_contribution.py")
+    stats = load(root / "artifacts/stats.json")
+    notice = f"""# Notice and attribution\n\nSource: {CATALOG}\n\nThe official catalogue describes the linked publications as authored by Fundacja Kultury bez Barier and states that they are made available under CC BY-SA 3.0. The catalogue HTML, raw PDFs, source URLs and SHA-256 digests are preserved. This is catalogue-level evidence; an embedded per-PDF license assertion is not claimed.\n\nDataset transformations: text extraction, removal of page-number-only lines, line-wrap repair, Unicode/whitespace normalization, limited PII-pattern redaction, exact and near deduplication. Images are not included in the training text. Attribution and a modification notice must be preserved under CC BY-SA 3.0.\n"""
+    (root / "NOTICE.md").write_text(notice, encoding="utf-8")
+    readme = f"""---\nlicense: cc-by-sa-3.0\nlanguage:\n- pl\ntask_categories:\n- text-generation\nconfigs:\n- config_name: default\n  data_files:\n  - split: train\n    path: data/train-00000-of-00001.parquet\n---\n\n# Kultura bez Barier PL\n\nPolish text extracted from openly published accessibility guides by Fundacja Kultury bez Barier.\n\n- Input publications: {stats['discovered']}\n- Retained records: {stats['kept']}\n- Extracted pages: {stats['pages']}\n- Tokens: {stats['tokens']:,} (`cl100k_base` proxy)\n- License evidence: catalogue-level CC BY-SA 3.0 declaration\n- Author coverage: {stats['author_coverage']:.1%}\n\nSee `NOTICE.md` and `artifacts/` for the source inventory, raw PDFs, attribution, selection decisions, QA, checksums, samples and Slayer ontology manifest.\n\n## Limitations\n\nThe source catalogue provides the licensing statement; an embedded statement was not found or required for every PDF. Maintainer/legal review of that scope remains appropriate. PDF extraction may flatten tables and omit visual meaning. Cross-source DynaWord deduplication, benchmark-overlap checks and controlled training ablations remain pending.\n"""
+    (root / "README.md").write_text(readme, encoding="utf-8")
+    digest_map = checksums(root)
+    save(root / "artifacts/checksums.json", digest_map)
+    verified_stats = verify_core(out)
+    validation = {"id": "run:" + sha({"checksums": digest_map, "target": target_revision}), "started_at": now(),
+        "finished_at": now(), "success": True, "protocol": "dataset-contract-and-checksum-validation-v1",
+        "target_main_revision": target_revision, "stats": verified_stats}
+    save(root / "artifacts/validation_run.json", validation)
+    build_run = load(root / "artifacts/run.json")
+    check_id = "evidence:checksums:" + sha(digest_map)
+    qa = load(root / "artifacts/qa.json")
+    qa_id = "evidence:qa:" + sha(qa)
+    dataset_version = "version:dataset:" + sha(digest_map)
+    source_version = "version:source:" + sha({"pdfs": build_run["inputs"]["pdf_sha256"], "catalog": build_run["inputs"]["catalog_sha256"]})
+    ontology = {"schema": "slayer-research-ontology-profile-v1", "objects": [
+            {"id": "object:source:kultura-bez-barier", "type": "Source"}, {"id": "object:dataset:kultura-bez-barier-pl", "type": "Dataset"}],
+        "versions": [{"id": source_version, "object": "object:source:kultura-bez-barier", "content_address": source_version.rsplit(":", 1)[-1]},
+            {"id": dataset_version, "object": "object:dataset:kultura-bez-barier-pl", "content_address": dataset_version.rsplit(":", 1)[-1]}],
+        "protocols": [{"id": "protocol:pdf-text-v1", "procedure": "allowlist, pdfplumber extraction, normalization, PII patterns, exact and seeded near dedup"},
+            {"id": "protocol:contract-v1", "procedure": "schema, checksum, sample, rights-evidence and ontology contract checks"}],
+        "runs": [{"id": build_run["id"], "protocol": "protocol:pdf-text-v1", "success": True,
+            "started_at": build_run["started_at"], "finished_at": build_run["finished_at"]}, validation],
+        "evidence": [{"id": check_id, "observation_type": "checksums", "payload": digest_map, "produced_by": validation["id"]},
+            {"id": qa_id, "observation_type": "qa", "payload": qa, "produced_by": build_run["id"]}],
+        "claims": [{"id": "claim:replayable", "statement": "The retained dataset files replay from the pinned catalogue and PDF snapshot under the published protocol.",
+            "supported_by": [check_id], "falsification_condition": "A published checksum differs or the builder cannot reproduce retained text from the pinned raw PDFs."},
+            {"id": "claim:rights-qualified", "statement": "The official catalogue presents the linked foundation-authored publications as CC BY-SA 3.0; per-PDF embedded licensing is not asserted.",
+            "supported_by": [qa_id], "falsification_condition": "The pinned catalogue lacks that declaration or a selected file is outside its demonstrated scope."}],
+        "actors": [{"id": "actor:piotrsty", "type": "Contributor"}, {"id": "actor:fundacja-kultury-bez-barier", "type": "Organization"},
+            {"id": "actor:codex", "type": "Agent"}],
+        "relations": [{"source": dataset_version, "predicate": "DERIVED_FROM", "target": source_version},
+            {"source": dataset_version, "predicate": "GENERATED_BY", "target": build_run["id"]},
+            {"source": dataset_version, "predicate": "VALIDATED_AGAINST", "target": validation["id"]}],
+        "pending": ["cross-source deduplication", "benchmark contamination check", "maintainer/legal review of catalogue-level license scope", "controlled training ablation"]}
+    save(root / "artifacts/ontology.json", ontology)
+
+
+def verify(out):
+    stats = verify_core(out)
+    root = out / "hf_repo"
+    manifest = load(root / "artifacts/ontology.json")
+    evidence_ids = {item["id"] for item in manifest["evidence"]}
+    assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence_ids for item in manifest["claims"])
+    assert len(manifest["runs"]) >= 2 and all(item["success"] for item in manifest["runs"])
+    assert any(item["predicate"] == "VALIDATED_AGAINST" for item in manifest["relations"])
+    print(json.dumps({"verified": True, **stats}, ensure_ascii=False, indent=2), flush=True)
+
+
+def hf_token():
+    value = os.environ.get("HF_TOKEN")
+    if not value and os.name == "nt":
+        import winreg
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment") as key:
+            value = winreg.QueryValueEx(key, "HF_TOKEN")[0]
+    if not value or not value.startswith("hf_"):
+        raise ValueError("HF_TOKEN unavailable")
+    return value
+
+
+def all_files(root):
+    return [path for path in sorted(root.rglob("*")) if path.is_file() and "__pycache__" not in path.parts and ".pytest_cache" not in path.parts]
+
+
+def assemble_pr(out, base, source_commit):
+    root = out / "hf_repo"
+    pr = out / "dynaword_pr"
+    data = pr / "data" / SOURCE
+    data.mkdir(parents=True, exist_ok=True)
+    (pr / "src").mkdir(exist_ok=True)
+    (pr / "artifacts").mkdir(exist_ok=True)
+    shutil.copy2(root / "data/train-00000-of-00001.parquet", data / f"{SOURCE}.parquet")
+    for name in ("attribution.jsonl", "decisions.jsonl", "sample.jsonl", "stats.json", "qa.json"):
+        shutil.copy2(root / "artifacts" / name, data / f"{SOURCE}.{name}")
+    shutil.copy2(root / "NOTICE.md", data / "NOTICE.md")
+    shutil.copy2(root / "README.md", data / f"{SOURCE}.md")
+    shutil.copy2(root / "artifacts/ontology.json", pr / f"artifacts/{SOURCE}_ontology_manifest.json")
+    shutil.copy2(Path(__file__), pr / "src/build_kultura_bez_barier_pl.py")
+    shutil.copy2(Path(__file__).with_name("test_kultura_bez_barier_contribution.py"), pr / "src/test_kultura_bez_barier_contribution.py")
+    (pr / "src/sources.py").write_text(registry(base), encoding="utf-8")
+    stats = load(root / "artifacts/stats.json")
+    description = f"""## Add Polish cultural-accessibility guides\n\nAdds `{SOURCE}`: **{stats['kept']} records, {stats['pages']} extracted pages and {stats['tokens']:,} measured `cl100k_base` proxy tokens** from the official Fundacja Kultury bez Barier publication catalogue.\n\nSource dataset: https://huggingface.co/datasets/{OWN_REPO}/tree/{source_commit}\n\n### Data sample\n\n- [{stats['sample_count']} complete deterministic sample records](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/sample.jsonl)\n- [Per-record attribution, URLs and rights evidence](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/attribution.jsonl)\n- [Selection decisions](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/decisions.jsonl)\n\n### Rights and method\n\nThe official catalogue describes these linked foundation-authored publications as CC BY-SA 3.0. The contribution preserves the catalogue HTML, raw PDFs, URLs, hashes, attribution and modification notice. This is catalogue-level evidence; it does not assert that every PDF embeds a separate license notice. Text was extracted with pdfplumber, normalized, checked for limited PII patterns, and exact/near-deduplicated within source.\n\n### Slayer ontology and remaining gates\n\nThe manifest separates content-addressed source/dataset Versions, processing and validation Protocols, executed Runs, Evidence, falsifiable Claims, Actors and typed lineage. Cross-source DynaWord deduplication, benchmark-overlap testing, legal interpretation of the catalogue-level scope and controlled training ablations remain pending. PDF extraction may flatten tables and omit visual meaning. This PR proposes a source, not a merged or stable release.\n"""
+    (out / "pr_description.md").write_text(description, encoding="utf-8")
+    return pr
+
+
+def publish(out):
+    from huggingface_hub import CommitOperationAdd, HfApi
+    api = HfApi(token=hf_token())
+    if api.whoami()["name"].casefold() != "piotrsty":
+        raise ValueError("unexpected HF account")
+    target = api.dataset_info(TARGET)
+    registry_url = f"https://huggingface.co/datasets/{TARGET}/resolve/{target.sha}/src/sources.py"
+    base = http_get(registry_url).content.decode("utf-8")
+    discussions = list(api.get_repo_discussions(TARGET, repo_type="dataset"))
+    if SOURCE in base or any("kultura bez barier" in item.title.casefold() for item in discussions):
+        raise ValueError("source registration or proposal already exists")
+    prepare(out, target.sha)
+    verify(out)
+    root = out / "hf_repo"
+    receipt_path = out / "publication.json"
+    receipt = load(receipt_path) if receipt_path.exists() else {}
+    if not receipt:
+        if api.repo_exists(OWN_REPO, repo_type="dataset"):
+            raise ValueError("own HF repository already exists without this run receipt")
+        api.create_repo(OWN_REPO, repo_type="dataset", private=True)
+        receipt = {"source_repo": OWN_REPO, "target_main_revision": target.sha, "created_at": now()}
+        save(receipt_path, receipt)
+    if receipt["target_main_revision"] != target.sha:
+        raise ValueError("target main changed since publication started; inspect before continuing")
+    if not receipt.get("source_commit"):
+        source_commit = api.create_commit(OWN_REPO, repo_type="dataset", commit_message="Add validated Kultura bez Barier Polish publications",
+            operations=[CommitOperationAdd(path_in_repo=path.relative_to(root).as_posix(), path_or_fileobj=str(path)) for path in all_files(root)])
+        receipt["source_commit"] = source_commit.oid
+        save(receipt_path, receipt)
+    source_revision = receipt["source_commit"]
+    if not any(item.name == "v1.0.0" for item in api.list_repo_refs(OWN_REPO, repo_type="dataset").tags):
+        api.create_tag(OWN_REPO, repo_type="dataset", tag="v1.0.0", revision=source_revision)
+    api.update_repo_settings(OWN_REPO, repo_type="dataset", private=False)
+    pr = assemble_pr(out, base, source_revision)
+    subprocess.run([sys.executable, "-m", "pytest", "-q", str(pr / "src/test_kultura_bez_barier_contribution.py")], check=True)
+    if not receipt.get("pr_url"):
+        result = api.create_commit(TARGET, repo_type="dataset", parent_commit=target.sha, create_pr=True,
+            commit_message="Add CC BY-SA 3.0 Polish cultural-accessibility guides",
+            commit_description=(out / "pr_description.md").read_text(encoding="utf-8"),
+            operations=[CommitOperationAdd(path_in_repo=path.relative_to(pr).as_posix(), path_or_fileobj=str(path)) for path in all_files(pr)])
+        receipt.update(tag="v1.0.0", pr_url=result.pr_url, pr_commit=result.oid, published_at=now())
+        save(receipt_path, receipt)
+    print(json.dumps(receipt, ensure_ascii=False, indent=2), flush=True)
+
+
+def audit(out):
+    from huggingface_hub import HfApi, hf_hub_download
+    api = HfApi(token=False)
+    receipt = load(out / "publication.json")
+    info = api.dataset_info(OWN_REPO)
+    if info.private or info.sha != receipt["source_commit"]:
+        raise ValueError("source repo visibility or revision mismatch")
+    if not any(item.name == receipt["tag"] and item.target_commit == info.sha for item in api.list_repo_refs(OWN_REPO, repo_type="dataset").tags):
+        raise ValueError("release tag mismatch")
+    number = int(receipt["pr_url"].rsplit("/", 1)[-1])
+    discussion = api.get_discussion_details(TARGET, number, repo_type="dataset")
+    pr_info = api.dataset_info(TARGET, revision=f"refs/pr/{number}")
+    if not discussion.is_pull_request or pr_info.sha != receipt["pr_commit"]:
+        raise ValueError("PR identity mismatch")
+    checked = []
+    for repo, revision, root in ((OWN_REPO, info.sha, out / "hf_repo"), (TARGET, pr_info.sha, out / "dynaword_pr")):
+        for path in all_files(root):
+            name = path.relative_to(root).as_posix()
+            remote = Path(hf_hub_download(repo, name, repo_type="dataset", revision=revision, token=False,
+                                          cache_dir=str(out / "remote_cache")))
+            if sha(remote.read_bytes()) != sha(path.read_bytes()):
+                raise ValueError("remote mismatch: " + name)
+            checked.append({"repo": repo, "revision": revision, "path": name, "sha256": sha(remote.read_bytes())})
+    result = {"observed_at": now(), "source_revision": info.sha, "pr_revision": pr_info.sha,
+        "pr_status": discussion.status, "target_main_revision": api.dataset_info(TARGET).sha, "verified_files": checked}
+    save(out / "publication_audit.json", result)
+    shutil.rmtree(out / "remote_cache", ignore_errors=True)
+    print(json.dumps({**result, "verified_files": len(checked)}, ensure_ascii=False, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("command", choices=["acquire", "build", "verify", "publish", "audit"])
+    arguments = parser.parse_args()
+    globals()[arguments.command](arguments.output)

src/test_kultura_bez_barier_contribution.py

@@ -0,0 +1,64 @@
+"""Contract checks run from the prepared DynaWord contribution tree."""
+import hashlib
+import json
+from pathlib import Path
+import re
+
+import pyarrow.parquet as pq
+
+SOURCE = "kultura_bez_barier_pl"
+LICENSE = "CC-BY-SA-3.0"
+FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+MANIFEST = ROOT / "artifacts" / f"{SOURCE}_ontology_manifest.json"
+
+
+def digest(payload):
+    return hashlib.sha256(payload).hexdigest()
+
+
+def rows(path):
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+
+
+def test_dataset_contract_and_samples():
+    table = pq.read_table(DATA / f"{SOURCE}.parquet")
+    data = table.to_pylist()
+    stats = json.loads((DATA / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+    attribution = rows(DATA / f"{SOURCE}.attribution.jsonl")
+    decisions = rows(DATA / f"{SOURCE}.decisions.jsonl")
+    sample = rows(DATA / f"{SOURCE}.sample.jsonl")
+    assert table.column_names == FIELDS
+    assert len(data) == stats["kept"] == len(attribution)
+    assert len(decisions) == stats["discovered"]
+    assert sum(bool(item["selected"]) for item in decisions) == stats["kept"]
+    assert sum(item["token_count"] for item in data) == stats["tokens"]
+    assert {item["id"] for item in data} == {item["id"] for item in attribution}
+    assert all(item["source"] == SOURCE and item["license"] == LICENSE and item["author"] for item in data)
+    assert all(not re.search(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", item["text"]) for item in data)
+    by_id = {item["id"]: item for item in data}
+    assert len(sample) == stats["sample_count"] == min(12, len(data))
+    assert all(by_id[item["id"]] == item for item in sample)
+
+
+def test_ontology_is_addressed_and_falsifiable():
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    evidence = {item["id"] for item in manifest["evidence"]}
+    assert all(item["falsification_condition"] for item in manifest["claims"])
+    assert all(set(item["supported_by"]) <= evidence for item in manifest["claims"])
+    assert len(manifest["runs"]) >= 2 and all(item["success"] for item in manifest["runs"])
+    assert any(item["predicate"] == "VALIDATED_AGAINST" for item in manifest["relations"])
+    checks = next(item["payload"] for item in manifest["evidence"] if item["observation_type"] == "checksums")
+    mapping = {
+        "data/train-00000-of-00001.parquet": DATA / f"{SOURCE}.parquet",
+        "artifacts/attribution.jsonl": DATA / f"{SOURCE}.attribution.jsonl",
+        "artifacts/decisions.jsonl": DATA / f"{SOURCE}.decisions.jsonl",
+        "artifacts/sample.jsonl": DATA / f"{SOURCE}.sample.jsonl",
+        "artifacts/stats.json": DATA / f"{SOURCE}.stats.json",
+        "artifacts/qa.json": DATA / f"{SOURCE}.qa.json",
+        "src/build_kultura_bez_barier_pl.py": ROOT / "src/build_kultura_bez_barier_pl.py",
+        "src/test_kultura_bez_barier_contribution.py": ROOT / "src/test_kultura_bez_barier_contribution.py",
+    }
+    for name, path in mapping.items():
+        assert digest(path.read_bytes()) == checks[name]