Add plwiki talk pages (ns 1+5) - conversational Polish (#36)

- Add plwiki talk pages (ns 1+5) - conversational Polish (d3c7b3995a44abb8b801e25f33ce64ecc2755838)
- Address review: samples, scrubber + PII spot check, inclusion argument, text overlap (c95ab8895f20b4ac47365c27c31b729d54b05800)


Co-authored-by: Piotr Styla <PiotrSty@users.noreply.huggingface.co>

artifacts/plwiki_talk_ontology_manifest.json

@@ -0,0 +1,128 @@
+{
+  "actors": [
+    {
+      "id": "actor:piotrsty",
+      "type": "Contributor"
+    },
+    {
+      "id": "actor:wikimedia",
+      "type": "Organization"
+    },
+    {
+      "id": "actor:devin",
+      "type": "Agent"
+    }
+  ],
+  "claims": [
+    {
+      "falsification_condition": "The pinned Parquet or decisions do not reproduce this count.",
+      "id": "claim:plw-talk-target-retention",
+      "statement": "The proposed DynaWord slice contains 43054 records.",
+      "supported_by": [
+        "evidence:plw-talk-target-stats:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4"
+      ]
+    },
+    {
+      "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties.",
+      "id": "claim:plw-talk-training-value-untested",
+      "statement": "Net text novelty and training benefit remain untested hypotheses; quoted-fragment overlap vs wikipedia is untested.",
+      "supported_by": [
+        "evidence:plw-talk-target-overlap:af980dd0047c9251573be63a6dcb28bc51a6eafa77d614d19e1be25b447cefca"
+      ]
+    }
+  ],
+  "evidence": [
+    {
+      "artifact": "data/plwiki_talk/plwiki_talk.stats.json",
+      "content_address": "d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4",
+      "id": "evidence:plw-talk-target-stats:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4",
+      "observation_type": "target_slice_counts",
+      "produced_by": "run:plwiki-talk-dynaword-integration:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4"
+    },
+    {
+      "artifact": "data/plwiki_talk/plwiki_talk.overlap_audit.json",
+      "content_address": "af980dd0047c9251573be63a6dcb28bc51a6eafa77d614d19e1be25b447cefca",
+      "id": "evidence:plw-talk-target-overlap:af980dd0047c9251573be63a6dcb28bc51a6eafa77d614d19e1be25b447cefca",
+      "observation_type": "namespace_overlap_audit",
+      "produced_by": "run:plwiki-talk-dynaword-integration:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4"
+    }
+  ],
+  "objects": [
+    {
+      "id": "object:dataset:plwiki-talk",
+      "type": "Dataset"
+    },
+    {
+      "id": "object:dataset:plwiki-talk-dynaword-slice",
+      "type": "Dataset"
+    }
+  ],
+  "pending": [
+    "quoted-fragment dedup vs wikipedia shard",
+    "cross-source text deduplication",
+    "benchmark contamination check",
+    "abuse/vandalism screening",
+    "controlled training ablation"
+  ],
+  "protocols": [
+    {
+      "id": "protocol:plwiki-talk-dynaword-integration-v1",
+      "procedure": "carry over the source slice verbatim; namespace disjointness already audited vs wikipedia shard"
+    }
+  ],
+  "relations": [
+    {
+      "predicate": "DERIVED_FROM",
+      "source": "version:dataset:plwiki-talk-dynaword:32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+      "target": "hf:dataset:PiotrSty/plwiki-talk-pages@20c74a6da0cbaef5d2a644d0accf7e90262ea24c"
+    },
+    {
+      "predicate": "GENERATED_BY",
+      "source": "version:dataset:plwiki-talk-dynaword:32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+      "target": "run:plwiki-talk-dynaword-integration:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4"
+    },
+    {
+      "predicate": "VALIDATED_AGAINST",
+      "source": "version:dataset:plwiki-talk-dynaword:32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+      "target": "hf:dataset:SlayerLab/polish-dynaword@fe44303ea2db290c7a195264226477f724973357"
+    }
+  ],
+  "runs": [
+    {
+      "actor": "actor:devin",
+      "finished_at": "2026-09-11T18:35:14.234988+00:00",
+      "id": "run:plwiki-talk-dynaword-integration:d2af18f1b2618d8ac166cc110976992e97052b28e2647c2143063aaf2ff5e1b4",
+      "protocol": "protocol:plwiki-talk-dynaword-integration-v1",
+      "started_at": "2026-09-11T18:35:14.234988+00:00",
+      "stats": {
+        "added": "2026-09-11",
+        "boilerplate_lines_removed": 1,
+        "characters": 144604697,
+        "dump_date": "20260901",
+        "kept": 43054,
+        "license_counts": {
+          "CC-BY-SA-4.0": 43054
+        },
+        "sample_count": 12,
+        "source_slice_kept": 43054,
+        "talk_pages": 544591,
+        "target_revision": "fe44303ea2db290c7a195264226477f724973357",
+        "tokens": 55568733
+      },
+      "success": true
+    }
+  ],
+  "schema": "slayer-research-ontology-profile-v1",
+  "versions": [
+    {
+      "content_address": "20c74a6da0cbaef5d2a644d0accf7e90262ea24c",
+      "id": "hf:dataset:PiotrSty/plwiki-talk-pages@20c74a6da0cbaef5d2a644d0accf7e90262ea24c",
+      "object": "object:dataset:plwiki-talk"
+    },
+    {
+      "content_address": "32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+      "id": "version:dataset:plwiki-talk-dynaword:32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+      "object": "object:dataset:plwiki-talk-dynaword-slice"
+    }
+  ]
+}

artifacts/source_findings.md

@@ -720,3 +720,33 @@ maintainer sign-off on the catalogue-level scope reading.
 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.
+
+---
+
+## plwiki_talk — Polish Wikipedia talk pages (ns 1+5)
+
+**Investigated** — 2026-09-11 (review round 2026-09-28).
+
+**Verdict** — `added` (proposed with `release: None`). 43,054 pages / 55.6M
+`cl100k_base` tokens of **user-generated** editorial discussion — article talk
+(ns 1, 41,828 pages) and project talk (ns 5, 1,226 pages). Exact namespace
+complement to `wikipedia` (ns 0) and `plwiki_user_talk` (ns 3).
+
+**Enumeration** — the same pinned `plwiki-20260901-pages-meta-current` dump as
+the ns-3 slice (7 sha1-verified shards); 544,591 non-redirect talk pages
+enumerated, 43,054 retained after QA/dedup (500,652 dropped as <500 chars).
+
+**License evidence** — Wikimedia Terms of Use section 7 (CC BY-SA 4.0):
+<https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use/pl&oldid=584706>.
+Per-record canonical URL + page history is the attribution trail.
+
+**Blockers** — none to merge with `release: None`. Before release: NERGAL pass
+(user-generated talk; a 60-record residual spot check found only a DOI false
+positive and public signatures, but free text can hide more), and text-level
+cross-shard dedup per the measured overlap with `plwiki_user_talk` / `wikipedia`
+(review thread).
+
+**Lesson** — namespace partitioning prevents page-level duplication but not
+text-level repetition: talk pages quote article text and share templated notices
+across namespaces. Measure overlap at text level before claiming novelty — the
+ID-only audit said "0 collisions" and proved nothing.

data/plwiki_talk/NOTICE.md

@@ -0,0 +1,7 @@
+# Attribution and license notice
+
+Source: Polish Wikipedia talk pages, https://pl.wikipedia.org/ - Wikimedia Foundation.
+
+Text is available under the Creative Commons Attribution-ShareAlike 4.0 License (https://creativecommons.org/licenses/by-sa/4.0/). Attribution is provided via the per-record canonical page URL in `artifacts/attribution.jsonl`; each page's revision history lists its contributors.
+
+Preparation: Piotr Styla with Devin. Changes: namespace filtering (1 and 5), wikitext stripping, cross-document boilerplate removal, Unicode and whitespace normalization, limited email/labelled-phone/IP/labelled-national-ID/account-candidate redaction, language/quality filtering and within-source deduplication. No endorsement by the Wikimedia Foundation or page contributors is implied.

data/plwiki_talk/plwiki_talk.attribution.jsonl

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

data/plwiki_talk/plwiki_talk.checksums.json

@@ -0,0 +1,11 @@
+{
+  "NOTICE.md": "6152672b3c0246d5a394341342ebaf4d8438cefde9a42f8e89d7ea60d620a99a",
+  "plwiki_talk.attribution.jsonl": "234a3eaa9183fee2bb65b9b958c21de0232ffd5bf21b690967d074cae0f46c42",
+  "plwiki_talk.decisions.jsonl": "465b292a05a8b55c4f07d255fda0ba5cda90ed5b2b666c541848b50f8cd48cac",
+  "plwiki_talk.md": "7276c0bb52ca4c310435cdeca9f0d0db0db637a3dd4d82acc227e09a38bd621b",
+  "plwiki_talk.overlap_audit.json": "5ef4592279700c06e3f74b99a46b1ddd80a0c732ba44c17caba130b18f9d39c0",
+  "plwiki_talk.parquet": "32e8100276998f8a1c9a531968ec554cc1372e3797c4f3b21532dc45f4629a59",
+  "plwiki_talk.qa.json": "a4b7fac7b749edccb265cfe93f850027342cca43665ca50ea2ab99347aa26e40",
+  "plwiki_talk.sample.jsonl": "1c8b44bee9c23d490dfdfc4f9c6cc1975d9cc4f56997537bd08456049eb34cdd",
+  "plwiki_talk.stats.json": "65838c75bdc7681d564554b012adf1a1121c43c671ff128e5fa2953817a2c031"
+}

data/plwiki_talk/plwiki_talk.decisions.jsonl

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

data/plwiki_talk/plwiki_talk.md

@@ -0,0 +1,99 @@
+# Polish Wikipedia talk pages (namespaces 1+5) - CC BY-SA 4.0
+
+This slice is rebuilt deterministically from the pinned official Wikimedia dump
+`plwiki-20260901-pages-meta-current` (7 sha1-verified shards;
+https://dumps.wikimedia.org/plwiki/20260901/). Scope is namespaces 1
+(article talk) and 5 (project talk); mainspace (ns=0) is covered by the existing
+`wikipedia` shard and user-talk (ns=3) is excluded by scope decision (not
+measured). This is conversational written Polish - editorial disputes,
+coordination, questions and answers - a register otherwise nearly absent from
+the corpus.
+
+- Non-redirect talk pages enumerated: 544,591
+- Source slice retained after QA/dedup: 43,054
+- Proposed records: 43,054
+- Proposed tokens: 55,568,733 (`cl100k_base` proxy)
+- Characters: 144,604,697
+- License: CC BY-SA 4.0 per record (Wikimedia Terms of Use section 7: https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use/pl&oldid=584706)
+- Immutable source snapshot: https://huggingface.co/datasets/PiotrSty/plwiki-talk-pages/tree/20c74a6da0cbaef5d2a644d0accf7e90262ea24c
+
+Per-record page id, title, namespace, last-revision timestamp and canonical URL
+are preserved; page history is the contributor-attribution trail. Wikitext is
+stripped with mwparserfromhell; lines occurring in >=1% of documents are removed
+as cross-document boilerplate; emails, labelled phones, IP literals, labelled
+national identifiers and 26-digit account candidates are redacted (pattern
+redaction is not complete anonymization); exact and near deduplication applied
+within source. The user-talk namespace (ns=3) is excluded by scope decision;
+its quality was not measured.
+
+## What the texts are (user-generated)
+
+These are **user-generated** wiki talk pages: discussion between volunteer
+editors about article content (ns=1, article talk) and about the project itself
+(ns=5, "Dyskusja Wikipedii" - policies, classifications, deletion debates).
+Genre: editorial discussion - source requests, wording and naming disputes,
+style fixes, merge/delete debates, project-wide consultations. Register:
+informal written Polish with typos, wiki jargon ("WP:OR", "SDU"), signed
+comments (`user name + timestamp`). Not OCR'd, not machine-translated. Record
+model: one whole talk page; comments are not split.
+
+Time span: per-record `created` is the dump last-revision date (2003-02-13 –
+2026-09-01 across 43,054 records); the talk activity itself spans the whole
+life of plwiki (ns split: 41,828 article-talk pages, 1,226 project-talk pages).
+
+## Scrubber and residual-PII spot check
+
+Scrubber that ran: **pattern redaction in `src/build_plwiki_talk_pl.py`** -
+e-mail, labelled phone (`telefon`/`tel.`/`phone`), IPv4, parsed IPv6 (incl.
+compressed notation), labelled PESEL/NIP/REGON, 26-digit account candidates ->
+`[REDACTED:*]`. This is **not**
+[SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL); these are
+user-generated talk pages, so the shard must be re-run through NERGAL before it
+is admitted to a release.
+
+Residual-PII spot check (deterministic sample of 60 records, seed 20260928):
+25 `[REDACTED:IP]` placeholders remain as evidence of the applied redaction
+(including unregistered editors' signatures); the single long-digit-run hit is
+an academic DOI citation (`10.1017/9781108668675.006`) - not PII; all other
+residual classes (26-digit runs, IBAN-like, unlabelled IPs, e-mail-like incl.
+obfuscated "at"/"malpa" forms, `ul.`/`al.`/`os.` street cues, GG/ICQ/Skype,
+PESEL mentions) have 0 hits. Manual reading of 8 sampled records found only
+public wiki attribution and editorial discussion - no private personal data.
+Residual risk low but non-zero (60 of 43,054 records, 0.14%), which is why the
+NERGAL pass stays a release gate.
+
+## Inclusion argument
+
+What this adds that `wikipedia` does not: the editorial process around the
+articles - talk pages where editors argue about sources, wording, naming,
+merges and deletions. That is conversational, multi-voice, disagreement-laden
+Polish; the `wikipedia` shard holds only the finished encyclopedic prose. The
+namespace partition is exact: `wikipedia` = ns 0, this slice = ns 1+5,
+`plwiki_user_talk` (PR #40) = ns 3 - no page is in two slices, and the text
+overlap numbers below quantify what still repeats across them.
+
+## Text overlap with the wikipedia / plwiki_user_talk shards (review audit)
+
+Measured post-build by normalized exact-line and exact-paragraph containment
+(64-bit blake2b; lines >= 30 chars, paragraphs >= 100 chars; exact-verbatim
+only):
+
+- vs `wikipedia` (ns 0): 418 of 567,171 talk lines match (75,163 chars =
+  **0.053%** of this slice's line chars); 1 paragraph (271 chars). Verbatim
+  article quoting in talk pages is negligible at this unit size.
+- vs `plwiki_user_talk` (ns 3): 5,556 lines match (1,207,378 chars = **0.85%**);
+  1,111 paragraphs (547,695 chars = **0.39%**); 1,965 of 43,054 records (4.6%)
+  contain at least one matched line. The matched lines are almost all
+  page-unique (4,941 of 5,138 distinct matched lines occur on exactly one talk
+  page) - genuine thread fragments mirrored between article talk and user talk,
+  not template duplication.
+
+Integration gate: cross-shard verbatim dedup at integration would move ~0.9% of
+chars; no other treatment needed. Method and numbers are in the review thread
+(`overlap_check_pr36.py`, `overlap_pr36.json`).
+
+Limitations: talk pages are informal (typos, edit disputes, occasional vandalism);
+comments may quote article text (measured at review: 0.053% of chars match the
+`wikipedia` shard verbatim at line level; 0.85% matches `plwiki_user_talk`, almost
+all page-unique thread fragments);
+Record model is a whole talk page; comments are not split.

data/plwiki_talk/plwiki_talk.overlap_audit.json

@@ -0,0 +1,11 @@
+{
+  "candidate_records": 544591,
+  "collision_count": 0,
+  "id_collisions": [],
+  "method": "Literal dataset-record ID comparison only. Source-specific ID prefixes make zero collisions uninformative about page identity or text overlap. No target namespace or text audit was performed.",
+  "observed_at": "2026-09-11T08:19:24.301215+00:00",
+  "target": "SlayerLab/polish-dynaword:data/wikipedia",
+  "target_revision": "fe44303ea2db290c7a195264226477f724973357",
+  "target_rows": 1171897,
+  "text_overlap": "not tested; quoted-article passages and target-wide text dedup remain integration gates"
+}

data/plwiki_talk/plwiki_talk.parquet

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

data/plwiki_talk/plwiki_talk.qa.json

@@ -0,0 +1,18 @@
+{
+  "benchmark_overlap": "pending",
+  "cross_source_text_dedup": "pending target integration",
+  "id_collisions_vs_wikipedia_shard": 0,
+  "license_terms_url": "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use/pl&oldid=584706",
+  "limitations": [
+    "talk pages contain informal text with typos, edit disputes and occasional abuse/vandalism",
+    "user-talk namespace (ns=3) excluded by scope decision; its quality was not measured",
+    "comments may quote article text; quoted passages are not disjoint from the wikipedia shard",
+    "record model is a whole talk page; individual comments are not split",
+    "pattern checks are not comprehensive de-identification"
+  ],
+  "overlap_method": "Literal dataset-record ID comparison only. Source-specific ID prefixes make zero collisions uninformative about page identity or text overlap. No target namespace or text audit was performed.",
+  "pii_policy": "IPv6 parsed including compressed notation; labelled PESEL/NIP/REGON and 26-digit account candidates masked conservatively without checksum validation; not complete anonymization",
+  "scope": "DynaWord proposal: Polish Wikipedia talk pages (ns 1+5); namespace complement to the wikipedia shard (ns=0)",
+  "source_text_qa_rejected": 501537,
+  "within_source_exact_and_near_dedup": true
+}

data/plwiki_talk/plwiki_talk.stats.json

@@ -0,0 +1,15 @@
+{
+  "added": "2026-09-11",
+  "boilerplate_lines_removed": 1,
+  "characters": 144604697,
+  "dump_date": "20260901",
+  "kept": 43054,
+  "license_counts": {
+    "CC-BY-SA-4.0": 43054
+  },
+  "sample_count": 12,
+  "source_slice_kept": 43054,
+  "talk_pages": 544591,
+  "target_revision": "fe44303ea2db290c7a195264226477f724973357",
+  "tokens": 55568733
+}

src/build_plwiki_talk_pl.py

@@ -0,0 +1,840 @@
+#!/usr/bin/env python3
+"""Build an auditable slice of Polish Wikipedia talk pages (ns 1+5, CC BY-SA 4.0)."""
+from __future__ import annotations
+
+import argparse
+import bz2
+from collections import Counter
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timezone
+from difflib import SequenceMatcher
+import gzip
+import hashlib
+import ipaddress
+import json
+from pathlib import Path
+import re
+import time
+import unicodedata
+from xml.etree.ElementTree import iterparse
+from urllib.parse import quote
+
+import requests
+
+
+SOURCE = "plwiki_talk"
+OWN_REPO = "PiotrSty/plwiki-talk-pages"
+TARGET = "SlayerLab/polish-dynaword"
+DUMP_DATE = "20260901"
+DUMP_BASE = f"https://dumps.wikimedia.org/plwiki/{DUMP_DATE}"
+DUMPSTATUS_URL = DUMP_BASE + "/dumpstatus.json"
+INDEX_URL = "https://dumps.wikimedia.org/plwiki/"
+SOURCE_URL = "https://pl.wikipedia.org/"
+FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+UA = {"User-Agent": "polish-dynaword/0.2 (+research; openly-licensed corpus)"}
+LICENSE_SPDX = "CC-BY-SA-4.0"
+LICENSE_TERMS_URL = "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use/pl&oldid=584706"
+TALK_NS = {"1", "5"}
+MIN_TEXT_CHARS = 500
+BOILERPLATE_MIN_DOC_FREQ = 0.01
+EMAIL_RE = re.compile(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b")
+PHONE_RE = re.compile(r"(?i)(?:\btelefon|\btel\.|\bphone)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b")
+IPV4_RE = re.compile(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b")
+IPV6_RE = re.compile(r"(?i)\b(?:[0-9a-f]{1,4}:){3,}[0-9a-f]{1,4}\b")
+
+
+IPV6_CANDIDATE_RE = re.compile(r"(?<![\w:])(?:[0-9a-fA-F]{0,4}:){2,}[0-9a-fA-F:.]*(?![\w:])")
+NATIONAL_ID_RE = re.compile(r"(?i)\b(PESEL|NIP|REGON)\s*[:=]?\s*\d(?:[ -]?\d){8,13}\b")
+BANK_ACCOUNT_RE = re.compile(r"(?<!\d)(?:PL\s*)?\d{2}(?:[ -]?\d){24}(?!\d)")
+
+
+def is_ipv6(value):
+    try:
+        return ipaddress.ip_address(value.rstrip(".")).version == 6
+    except ValueError:
+        return False
+
+
+def redact_pii(text):
+    counts = Counter()
+
+    def replace_ipv6(match):
+        value = match.group().rstrip(".")
+        if not is_ipv6(value):
+            return match.group()
+        counts["ipv6"] += 1
+        return "[REDACTED:IP]" + match.group()[len(value):]
+
+    text = IPV6_CANDIDATE_RE.sub(replace_ipv6, text)
+    for name, pattern, replacement in (
+        ("email", EMAIL_RE, "[REDACTED:EMAIL]"),
+        ("labelled_phone", PHONE_RE, "[REDACTED:PHONE]"),
+        ("ipv4", IPV4_RE, "[REDACTED:IP]"),
+        ("ipv6_legacy_pattern", IPV6_RE, "[REDACTED:IP]"),
+        ("national_identifier", NATIONAL_ID_RE, lambda match: match.group(1) + " [REDACTED:ID]"),
+        ("account_candidate", BANK_ACCOUNT_RE, "[REDACTED:ACCOUNT]"),
+    ):
+        text, count = pattern.subn(replacement, text)
+        counts[name] += count
+    return text, counts
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def digest(value):
+    if not isinstance(value, bytes):
+        value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(value).hexdigest()
+
+
+def sha1_file(path):
+    h = hashlib.sha1()
+    with path.open("rb") as handle:
+        while chunk := handle.read(1 << 22):
+            h.update(chunk)
+    return h.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 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").split("\n") if line]
+
+
+def load(path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def request(url, attempts=5, timeout=(15, 90)):
+    response = None
+    for attempt in range(attempts):
+        response = requests.get(url, headers=UA, timeout=timeout)
+        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 request_json(url):
+    return request(url).json()
+
+
+def _local(tag):
+    return tag.rsplit("}", 1)[-1]
+
+
+def strip_wikitext(wikitext):
+    import mwparserfromhell
+    try:
+        return mwparserfromhell.parse(wikitext).strip_code(normalize=True, collapse=True).strip()
+    except Exception:
+        return ""
+
+
+def _strip_batch(items):
+    return [strip_wikitext(wikitext) for _, _, _, _, wikitext in items]
+
+
+def discover(out):
+    status = request_json(DUMPSTATUS_URL)
+    jobs = status.get("jobs", {})
+    files = []
+    for job in jobs.values():
+        if job.get("status") != "done":
+            continue
+        for name, meta in (job.get("files") or {}).items():
+            if re.fullmatch(r"plwiki-\d+-pages-meta-current\d+\.xml-p\d+p\d+\.bz2", name):
+                files.append({"name": name, "url": f"{DUMP_BASE}/{name}",
+                              "size": meta.get("size"), "sha1": meta.get("sha1")})
+    files.sort(key=lambda item: item["name"])
+    if not files:
+        raise ValueError("no meta-current shards found")
+    selection = {
+        "observed_at": now(), "dump_date": DUMP_DATE, "dump_base": DUMP_BASE,
+        "dumpstatus_url": DUMPSTATUS_URL, "files": files,
+        "total_bytes": sum(item["size"] for item in files),
+        "talk_namespaces": sorted(TALK_NS), "min_text_chars": MIN_TEXT_CHARS,
+        "license": "CC BY-SA 4.0 (Wikimedia dump terms, same basis as the shipped wikipedia shard)",
+        "files_sha256": digest(files),
+    }
+    save(out / "selection.json", selection)
+    print(json.dumps({k: selection[k] for k in ("dump_date", "total_bytes")}, indent=2))
+    print("files:", len(files))
+
+
+def parse_shard(path):
+    records = []
+    with bz2.open(path, "rb") as fh:
+        title = ns = pageid = timestamp = text = None
+        redirect = False
+        for ev, el in iterparse(fh, events=("end",)):
+            tag = _local(el.tag)
+            if tag == "title":
+                title = el.text
+            elif tag == "ns":
+                ns = el.text
+            elif tag == "id" and pageid is None:
+                pageid = el.text
+            elif tag == "timestamp":
+                timestamp = el.text
+            elif tag == "redirect":
+                redirect = True
+            elif tag == "text":
+                text = el.text
+            elif tag == "page":
+                if ns in TALK_NS and not redirect and text:
+                    records.append((pageid, ns, title, timestamp, text))
+                title = ns = pageid = timestamp = text = None
+                redirect = False
+                el.clear()
+    return records
+
+
+def acquire(out, workers):
+    selection = load(out / "selection.json")
+    dump_dir = out / "raw_dump"
+    dump_dir.mkdir(parents=True, exist_ok=True)
+    extracted_dir = out / "extracted"
+    extracted_dir.mkdir(exist_ok=True)
+    manifest = []
+    for item in selection["files"]:
+        dst = dump_dir / item["name"]
+        if not dst.exists() or dst.stat().st_size != item["size"]:
+            print(f"  pobieram {item['name']} ({item['size']/1e6:.0f} MB)", flush=True)
+            for attempt in range(8):
+                have = dst.stat().st_size if dst.exists() else 0
+                headers = dict(UA)
+                if have:
+                    headers["Range"] = f"bytes={have}-"
+                try:
+                    with requests.get(item["url"], headers=headers, stream=True, timeout=(15, 300)) as r:
+                        r.raise_for_status()
+                        if have and r.status_code != 206:
+                            have = 0
+                        with dst.open("ab" if have else "wb") as f:
+                            for chunk in r.iter_content(1 << 22):
+                                f.write(chunk)
+                    break
+                except requests.RequestException as error:
+                    print(f"  retry {item['name']}: {type(error).__name__}", flush=True)
+                    time.sleep(min(2 ** attempt, 60))
+            else:
+                raise RuntimeError(f"download failed: {item['name']}")
+        sha = sha1_file(dst)
+        if item["sha1"] and sha != item["sha1"]:
+            raise ValueError(f"sha1 mismatch {item['name']}: {sha} != {item['sha1']}")
+        print(f"  {item['name']} sha1 OK", flush=True)
+
+        out_path = extracted_dir / (item["name"] + ".jsonl.gz")
+        if not out_path.exists():
+            records = parse_shard(dst)
+            batches = [records[i:i + 2000] for i in range(0, len(records), 2000)]
+            with ProcessPoolExecutor(max_workers=workers) as pool:
+                texts = [text for batch in pool.map(_strip_batch, batches) for text in batch]
+            with gzip.open(out_path, "wt", encoding="utf-8") as f:
+                for (pageid, ns, title, timestamp, wikitext), text in zip(records, texts):
+                    f.write(json.dumps({"pageid": pageid, "ns": ns, "title": title,
+                                        "timestamp": timestamp, "wikitext_chars": len(wikitext),
+                                        "text": text}, ensure_ascii=False) + "\n")
+        shard_records = 0
+        kept_chars = 0
+        with gzip.open(out_path, "rt", encoding="utf-8") as f:
+            for line in f:
+                row = json.loads(line)
+                shard_records += 1
+                kept_chars += len(row["text"])
+                manifest.append({"pageid": row["pageid"], "ns": row["ns"], "title": row["title"],
+                                 "timestamp": row["timestamp"],
+                                 "url": page_url(row["title"])})
+        print(f"  {item['name']}: {shard_records} stron dyskusji", flush=True)
+    write_lines(out / "source_manifest.jsonl", manifest)
+    acquisition = {
+        "observed_at": now(), "dump_date": selection["dump_date"],
+        "files": selection["files"], "talk_pages": len(manifest),
+        "manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()),
+    }
+    save(out / "acquisition.json", acquisition)
+    print(json.dumps(acquisition, ensure_ascii=False, indent=2))
+
+
+def strip_boilerplate(texts_index):
+    counts = Counter()
+    for lines in texts_index:
+        counts.update(set(re.sub(r"\s+", " ", line).strip() for line in lines if line.strip()))
+    n = len(texts_index)
+    return {line for line, count in counts.items()
+            if count / n >= BOILERPLATE_MIN_DOC_FREQ and len(line) < 160}
+
+
+def normalize(text):
+    text = unicodedata.normalize("NFKC", text or "").replace("­", "").replace("​", "")
+    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()]
+    lines = [line for line in lines if not re.fullmatch(r"\d{1,4}", line)]
+    text = "\n".join(lines)
+    text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text)
+    text = re.sub(r"(?<![.!?:;\n])\n(?!\n)(?=[a-ząćęłńóśźż])", " ", text)
+    return re.sub(r"\n{3,}", "\n\n", text).strip()
+
+
+def page_url(title):
+    return SOURCE_URL + "wiki/" + quote((title or "").replace(" ", "_"), safe="/:")
+
+
+def normalize_title(text):
+    text = unicodedata.normalize("NFKD", text or "").casefold()
+    text = "".join(character for character in text if not unicodedata.combining(character))
+    return " ".join(re.findall(r"\w+", text))
+
+
+def shingle_sketch(text, limit=5_000):
+    words = re.findall(r"\w+", text.casefold())
+    hashes = set()
+    for index in range(max(0, len(words) - 4)):
+        value = " ".join(words[index:index + 5]).encode("utf-8")
+        hashes.add(int.from_bytes(hashlib.blake2b(value, digest_size=8).digest(), "big"))
+    if len(hashes) > limit:
+        return set(sorted(hashes)[:limit])
+    return hashes
+
+
+class NearDuplicateIndex:
+    def __init__(self):
+        self.postings = {}
+        self.records = []
+        self.comparisons = 0
+
+    @staticmethod
+    def prefix(sketch):
+        return sorted(sketch)[:len(sketch) - (9 * len(sketch) + 9) // 10 + 1]
+
+    def find(self, sketch):
+        candidates = set()
+        for value in self.prefix(sketch):
+            candidates.update(self.postings.get(value, ()))
+        for position in sorted(candidates):
+            row_id, other = self.records[position]
+            if 10 * min(len(sketch), len(other)) < 9 * max(len(sketch), len(other)):
+                continue
+            self.comparisons += 1
+            intersection = len(sketch & other)
+            score = intersection / max(len(sketch) + len(other) - intersection, 1)
+            if score >= 0.90:
+                return row_id, score
+        return None, 0.0
+
+    def add(self, row_id, sketch):
+        position = len(self.records)
+        self.records.append((row_id, sketch))
+        for value in self.prefix(sketch):
+            self.postings.setdefault(value, []).append(position)
+
+
+def language_vote(identifier, text):
+    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
+    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
+    votes = [classified[chunk] for chunk in chunks if chunk in classified]
+    languages = Counter(language for language, _ in votes)
+    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
+
+
+def audit_target(out):
+    info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
+    revision = info["sha"]
+    tree = request_json(f"https://huggingface.co/api/datasets/{TARGET}/tree/{revision}?recursive=true&expand=false")
+    discussions = request_json(f"https://huggingface.co/api/datasets/{TARGET}/discussions?status=open&p=0")
+    paths = sorted(item.get("path", "") for item in tree)
+    open_rows = [{"num": item.get("num"), "title": item.get("title"), "status": item.get("status"),
+                  "author": item.get("author", {}).get("name")} for item in discussions.get("discussions", [])]
+    terms = ("plwiki_talk", "wikipedia_talk", "talk", "dyskusja")
+    matches = [path for path in paths if any(term in path.casefold() for term in terms)]
+    discussion_matches = [row for row in open_rows if any(term in (row.get("title") or "").casefold()
+                                                          for term in terms)]
+    report = {
+        "target": TARGET, "revision": revision, "last_modified": info.get("lastModified"),
+        "tree_paths": len(paths), "source_path_matches": matches, "open_discussions": open_rows,
+        "matching_open_discussions": discussion_matches, "source_absent": not matches and not discussion_matches,
+        "observed_at": now(),
+    }
+    save(out / "target_audit.json", report)
+    print(json.dumps({"revision": revision, "source_absent": report["source_absent"],
+                      "tree_matches": matches, "discussion_matches": discussion_matches}, ensure_ascii=False, indent=2))
+
+
+def audit_overlap(out):
+    import pyarrow.parquet as pq
+    from huggingface_hub import HfApi, HfFileSystem
+
+    acquisition = load(out / "acquisition.json")
+    revision = HfApi().dataset_info(TARGET).sha
+    remote = f"datasets/{TARGET}@{revision}/data/wikipedia/wikipedia.parquet"
+    with HfFileSystem().open(remote, "rb") as handle:
+        table = pq.read_table(handle, columns=["id"])
+    target_ids = set(table.column("id").to_pylist())
+    candidate_ids = {f"{SOURCE}_{row['pageid']}" for row in read_lines(out / "source_manifest.jsonl")}
+    collisions = sorted(candidate_ids & target_ids)
+    report = {
+        "target": f"{TARGET}:data/wikipedia", "target_revision": revision,
+        "method": "Literal dataset-record ID comparison only. Source-specific ID prefixes make zero collisions "
+                  "uninformative about page identity or text overlap. No target namespace or text audit was performed.",
+        "target_rows": table.num_rows, "candidate_records": len(candidate_ids),
+        "id_collisions": collisions[:50], "collision_count": len(collisions),
+        "text_overlap": "not tested; quoted-article passages and target-wide text dedup remain integration gates",
+        "observed_at": now(),
+    }
+    save(out / "overlap_audit.json", report)
+    print(json.dumps({key: report[key] for key in ("target_revision", "target_rows", "candidate_records",
+                                                    "collision_count")}, ensure_ascii=False, indent=2))
+
+
+def build(out):
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    import tiktoken
+    from langid.langid import LanguageIdentifier, model
+
+    build_started_at = now()
+    acquisition = load(out / "acquisition.json")
+    selection = load(out / "selection.json")
+    encoder = tiktoken.get_encoding("cl100k_base")
+    identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
+    identifier.set_languages(["pl", "en", "de", "uk", "ru"])
+
+    candidates = []
+    for shard in sorted((out / "extracted").glob("*.jsonl.gz")):
+        with gzip.open(shard, "rt", encoding="utf-8") as f:
+            for line in f:
+                row = json.loads(line)
+                row["text"] = normalize(row["text"])
+                candidates.append(row)
+    boilerplate = strip_boilerplate([row["text"].splitlines() for row in candidates])
+    print(f"boilerplate lines: {len(boilerplate)}", flush=True)
+
+    rows, attribution, decisions, exact_seen = [], [], [], {}
+    near_index = NearDuplicateIndex()
+    pii = Counter()
+    added = acquisition["observed_at"][:10]
+    started = last_progress = time.monotonic()
+    for processed, record in enumerate(candidates, 1):
+        current = time.monotonic()
+        if current - last_progress >= 10 or processed == len(candidates):
+            print(f"  processed={processed - 1}/{len(candidates)} kept={len(rows)} "
+                  f"rate={(processed - 1) / max(current - started, 0.001):.1f}/s "
+                  f"near_comparisons={near_index.comparisons}", flush=True)
+            last_progress = current
+        text = "\n".join(line for line in record["text"].splitlines()
+                         if re.sub(r"\s+", " ", line).strip() not in boilerplate)
+        text = re.sub(r"\n{3,}", "\n\n", text).strip()
+        replacement_count = text.count("\ufffd")
+        letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text))
+        language, votes = "not_checked", []
+        reason = ""
+        if len(text) < MIN_TEXT_CHARS:
+            reason = "too_little_text"
+        elif letters / max(len(text), 1) < 0.5:
+            reason = "low_letter_ratio"
+        elif replacement_count > 100 or replacement_count / max(len(text), 1) > 0.002:
+            reason = "excessive_replacement_characters"
+        if not reason:
+            language, votes = language_vote(identifier, text)
+            if language != "pl":
+                reason = "non_polish_text"
+        text = text.replace("\ufffd", "[UNREADABLE_GLYPH]")
+        text, pii_counts = redact_pii(text)
+        pii.update(pii_counts)
+        if not reason and len(text) < MIN_TEXT_CHARS:
+            reason = "too_little_text_after_redaction"
+        exact_key = digest(" ".join(text.casefold().split()).encode("utf-8"))
+        duplicate_of, duplicate_score = None, 0.0
+        if not reason and exact_key in exact_seen:
+            reason, duplicate_of, duplicate_score = "normalized_duplicate", exact_seen[exact_key], 1.0
+        if not reason:
+            sketch = shingle_sketch(text)
+            duplicate_of, duplicate_score = near_index.find(sketch)
+            if duplicate_of is not None:
+                reason = "near_duplicate"
+        row_id = f"{SOURCE}_{record['pageid']}"
+        decision = {
+            "id": row_id, "selected": not bool(reason), "reason": reason or "include",
+            "characters": len(text), "letter_ratio": letters / max(len(text), 1),
+            "replacement_characters": replacement_count, "language": language,
+            "language_votes": [{"language": lang, "confidence": float(score)} for lang, score in votes],
+        }
+        if duplicate_of:
+            decision.update({"duplicate_of": duplicate_of, "jaccard": duplicate_score})
+        decisions.append(decision)
+        if reason:
+            continue
+        exact_seen[exact_key] = row_id
+        near_index.add(row_id, sketch)
+        row = {
+            "id": row_id, "text": text, "source": SOURCE, "added": added,
+            "created": (record["timestamp"] or "")[:10] or "unknown",
+            "token_count": len(encoder.encode_ordinary(text)),
+            "license": LICENSE_SPDX, "author": "plwiki contributors",
+        }
+        rows.append(row)
+        attribution.append({
+            "id": row_id, "pageid": record["pageid"], "ns": record["ns"], "title": record["title"],
+            "url": page_url(record["title"]),
+            "last_revision_at": record["timestamp"], "wikitext_chars": record["wikitext_chars"],
+            "license": LICENSE_SPDX,
+            "license_evidence": LICENSE_TERMS_URL + " (section 7, text licensing and attribution by page URL)",
+            "dump": {"date": selection["dump_date"], "files": [f["name"] for f in selection["files"]]},
+            "text_sha256": digest(text.encode("utf-8")),
+            "transformations": ["official pages-meta-current dump", "mwparserfromhell wikitext strip",
+                                "cross-document boilerplate-line removal",
+                                "Unicode/whitespace normalization", "page-number-only removal",
+                                "line-wrap repair", "email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction"],
+        })
+
+    root = out / "hf_repo"
+    (root / "data").mkdir(parents=True, exist_ok=True)
+    (root / "artifacts").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)
+    write_lines(root / "artifacts/source_manifest.jsonl", read_lines(out / "source_manifest.jsonl"))
+    sample = sorted(rows, key=lambda row: digest(("sample:" + row["id"]).encode("utf-8")))[:12]
+    write_lines(root / "artifacts/sample.jsonl", sample)
+    save(root / "artifacts/selection.json", selection)
+    save(root / "artifacts/acquisition.json", acquisition)
+    save(root / "artifacts/boilerplate_lines.json", sorted(boilerplate))
+    overlap = load(out / "overlap_audit.json") if (out / "overlap_audit.json").exists() else None
+    target_audit = load(out / "target_audit.json") if (out / "target_audit.json").exists() else None
+    if overlap:
+        save(root / "artifacts/overlap_audit.json", overlap)
+    if target_audit:
+        save(root / "artifacts/target_audit.json", target_audit)
+    stats = {
+        "dump_date": selection["dump_date"], "dump_files": len(selection["files"]),
+        "talk_pages": acquisition["talk_pages"],
+        "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),
+        "license_counts": dict(Counter(row["license"] for row in rows)),
+        "boilerplate_lines_removed": len(boilerplate),
+        "sample_count": len(sample), "added": added,
+    }
+    qa = {
+        "scope": "Polish Wikipedia article-talk (ns=1) and project-talk (ns=5) pages from the pinned pages-meta-current dump",
+        "license_terms_url": LICENSE_TERMS_URL,
+        "license_gate": "Wikimedia Terms of Use section 7: CC BY-SA 4.0 and page-URL attribution; third-party notices still require review",
+        "rejection_counts": dict(Counter(item["reason"] for item in decisions if not item["selected"])),
+        "minimum_final_text_characters": MIN_TEXT_CHARS,
+        "created_field_semantics": "Last revision date from the dump, not the page creation date",
+        "language_gate": "independent three-window langid vote",
+        "pii_pattern_matches": dict(pii), "exact_dedup": True,
+        "pii_policy": "IPv6 parsed including compressed notation; labelled PESEL/NIP/REGON and 26-digit account candidates masked conservatively without checksum validation; counts cover all candidates before rejection",
+        "pii_limitations": "Unlabelled national identifiers, free-form phone numbers, names and personal disclosures may remain; this is not complete anonymization",
+        "near_dedup": "deterministic capped 5-word-shingle hash Jaccard >= 0.90 within source",
+        "boilerplate": f"lines occurring in >= {BOILERPLATE_MIN_DOC_FREQ:.0%} of documents removed ({len(boilerplate)} patterns)",
+        "wikipedia_shard_overlap": overlap or "pending", "cross_source_text_dedup": "pending target integration",
+        "benchmark_overlap": "pending", "limitations": [
+            "talk pages contain informal text with typos, edit disputes and occasional abuse/vandalism",
+            "user-talk namespace (ns=3) excluded by scope decision; its quality was not measured",
+            "comments may quote article text; quoted passages are not disjoint from the wikipedia shard",
+            "record model is a whole talk page; individual comments are not split",
+            "pattern checks are not comprehensive de-identification",
+        ],
+    }
+    save(root / "artifacts/stats.json", stats)
+    save(root / "artifacts/qa.json", qa)
+    protocol_id = "protocol:plwiki-talk-v1"
+    run = {
+        "id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "selection": selection,
+                                  "acquisition": digest(acquisition)}),
+        "protocol": protocol_id, "started_at": build_started_at, "finished_at": now(),
+        "success": True, "actor": "actor:devin", "stats": stats,
+    }
+    save(root / "artifacts/run.json", run)
+    excluded = {"README.md", "NOTICE.md", "artifacts/checksums.json", "artifacts/ontology.json"}
+    checks = {path.relative_to(root).as_posix(): digest(path.read_bytes()) for path in sorted(root.rglob("*"))
+              if path.is_file()
+              and path.relative_to(root).as_posix() not in excluded
+              and not path.relative_to(root).as_posix().startswith("src/")}
+    save(root / "artifacts/checksums.json", checks)
+    source_version = "version:source:" + digest(selection["files"])
+    dataset_version = "version:dataset:" + digest(checks)
+    selection_evidence = "evidence:selection:" + digest(selection)
+    acquisition_evidence = "evidence:acquisition:" + digest(acquisition)
+    qa_evidence = "evidence:qa:" + digest(qa)
+    evidence = [
+        {"id": selection_evidence, "observation_type": "dump_inventory_and_pinning",
+         "artifact": "artifacts/selection.json", "content_address": digest(selection), "produced_by": run["id"]},
+        {"id": acquisition_evidence, "observation_type": "dump_download_sha1_and_extraction",
+         "artifact": "artifacts/acquisition.json", "content_address": digest(acquisition), "produced_by": run["id"]},
+        {"id": qa_evidence, "observation_type": "source_qa", "artifact": "artifacts/qa.json",
+         "content_address": digest(qa), "produced_by": run["id"]},
+    ]
+    overlap_evidence = None
+    if overlap:
+        overlap_evidence = "evidence:overlap:" + digest(overlap)
+        evidence.append({"id": overlap_evidence, "observation_type": "namespace_overlap_audit",
+                         "artifact": "artifacts/overlap_audit.json", "content_address": digest(overlap),
+                         "produced_by": run["id"]})
+    target_evidence = None
+    if target_audit:
+        target_evidence = "evidence:target:" + digest(target_audit)
+        evidence.append({"id": target_evidence, "observation_type": "target_registry_audit",
+                         "artifact": "artifacts/target_audit.json", "content_address": digest(target_audit),
+                         "produced_by": run["id"]})
+    ontology = {
+        "schema": "slayer-research-ontology-profile-v1",
+        "objects": [{"id": "object:source:plwiki-dump-" + selection["dump_date"], "type": "Source"},
+                    {"id": "object:dataset:plwiki-talk", "type": "Dataset"}],
+        "versions": [{"id": source_version, "object": "object:source:plwiki-dump-" + selection["dump_date"],
+                      "content_address": source_version.rsplit(":", 1)[-1]},
+                     {"id": dataset_version, "object": "object:dataset:plwiki-talk",
+                      "content_address": dataset_version.rsplit(":", 1)[-1]}],
+        "protocols": [{"id": protocol_id, "procedure": "pinned dump; sha1-verified shards; namespaces 1+5; wikitext strip; boilerplate removal; normalization; PII patterns; exact and near dedup"}],
+        "runs": [run], "evidence": evidence,
+        "claims": [
+            {"id": "claim:talk-pages-observed",
+             "statement": f"The pinned dump {selection['dump_date']} yielded {acquisition['talk_pages']} non-redirect talk pages in namespaces 1 and 5.",
+             "supported_by": [selection_evidence, acquisition_evidence],
+             "falsification_condition": "The pinned dump shards do not reproduce the count."},
+            {"id": "claim:slice-retention",
+             "statement": f"The slice retained {stats['kept']} records after text QA and within-source deduplication.",
+             "supported_by": [acquisition_evidence, qa_evidence],
+             "falsification_condition": "The decisions, Parquet rows, or checksums do not reproduce the retention count."},
+            {"id": "claim:source-absence-at-audit",
+             "statement": "Talk-namespace Wikipedia content was not registered as a source in the pinned DynaWord data tree or open pull-request list at audit time.",
+             "supported_by": [target_evidence] if target_evidence else [qa_evidence],
+             "falsification_condition": "The pinned target evidence contains a matching source or proposal."},
+            {"id": "claim:training-value-untested",
+             "statement": "Net corpus novelty and training benefit remain untested hypotheses.",
+             "supported_by": [qa_evidence] + ([overlap_evidence] if overlap_evidence else []),
+             "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties."},
+        ],
+        "actors": [{"id": "actor:piotrsty", "type": "Contributor"},
+                   {"id": "actor:wikimedia", "type": "Organization"}, {"id": "actor:devin", "type": "Agent"}],
+        "relations": [{"source": dataset_version, "predicate": "DERIVED_FROM", "target": source_version},
+                      {"source": dataset_version, "predicate": "GENERATED_BY", "target": run["id"]}] +
+                     ([{"source": dataset_version, "predicate": "VALIDATED_AGAINST",
+                        "target": f"hf:dataset:{TARGET}@{target_audit['revision']}"}] if target_audit else []),
+        "pending": ["quoted-article-fragment dedup vs wikipedia shard", "cross-source text deduplication",
+                    "benchmark contamination check", "abuse/vandalism content screening",
+                    "controlled training ablation"],
+    }
+    save(root / "artifacts/ontology.json", ontology)
+    card = f"""---
+license: cc-by-sa-4.0
+language:
+- pl
+task_categories:
+- text-generation
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-00000-of-00001.parquet
+---
+
+# Polish Wikipedia talk pages (plwiki, namespaces 1+5)
+
+Article-talk and project-talk pages from the pinned `plwiki-{selection['dump_date']}-pages-meta-current`
+dump (https://dumps.wikimedia.org/plwiki/{selection['dump_date']}/).
+The source selects namespaces 1 and 5; zero collisions of source-prefixed record
+IDs do not establish disjointness from the target `wikipedia` shard. Target-wide
+text deduplication remains pending. This is conversational written Polish:
+editorial disputes, coordination, questions and answers.
+
+- Dump files: {stats['dump_files']} shards, sha1-verified against dumpstatus.json
+- Non-redirect talk pages (ns 1+5): {stats['talk_pages']:,}
+- Retained after text QA and within-source deduplication: {stats['kept']:,}
+- Characters: {stats['characters']:,}
+- Tokens: {stats['tokens']:,} (`cl100k_base` proxy)
+- License: CC BY-SA 4.0 per record; authorship via per-page history link
+
+## Provenance and rights
+
+Each record keeps its page id, title, namespace, last-revision timestamp and
+canonical URL (history is the attribution trail, per [Wikimedia Terms of Use,
+section 7]({LICENSE_TERMS_URL})). That section grants CC BY-SA 4.0 rights to
+contributor text and allows attribution via the source-page URL. Additional
+third-party attribution notices must be preserved and remain a review item.
+The user-talk namespace (ns=3) is excluded by scope decision; its quality was
+not measured. The `created` field is the last revision date, not page creation.
+
+## Processing and limitations
+
+Wikitext is stripped with mwparserfromhell; lines occurring in at least
+{BOILERPLATE_MIN_DOC_FREQ:.0%} of documents are removed as
+cross-document boilerplate (see `artifacts/boilerplate_lines.json`). Unicode and
+whitespace normalization, email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction, three-window langid
+vote, exact and near deduplication within source. The final text must contain at
+least {MIN_TEXT_CHARS} characters after redaction. Rejection counts:
+
+```json
+{json.dumps(qa['rejection_counts'], ensure_ascii=False, indent=2)}
+```
+
+PII filtering masks parsed IPv6 addresses (including compressed forms), labelled
+PESEL/NIP/REGON and 26-digit account candidates as well as the existing patterns.
+The account filter is conservative and may mask non-account numbers; unlabelled
+identifiers, free-form phone numbers, names and personal disclosures may remain.
+This is not complete anonymization.
+
+Talk pages are informal: they contain typos, edit disputes, quoted article
+fragments and occasional vandalism or abuse. Quoted article text is not disjoint
+from the shipped `wikipedia` shard; text-level dedup against it remains a target
+integration gate. The record model is a whole talk page; comments are not split.
+
+## Review artifacts
+
+See `artifacts/sample.jsonl`, `attribution.jsonl`, `decisions.jsonl`,
+`source_manifest.jsonl`, `overlap_audit.json`, `stats.json`, `qa.json`,
+`checksums.json`, `run.json` and `ontology.json`.
+"""
+    (root / "README.md").write_text(card, encoding="utf-8")
+    (root / "NOTICE.md").write_text(
+        "# Attribution and license notice\n\n"
+        "Source: Polish Wikipedia talk pages, https://pl.wikipedia.org/ - Wikimedia Foundation.\n\n"
+        "Text is available under the Creative Commons Attribution-ShareAlike 4.0 License "
+        "(https://creativecommons.org/licenses/by-sa/4.0/). Attribution is provided via the per-record "
+        "canonical page URL in `artifacts/attribution.jsonl`; each page's revision history lists its "
+        "contributors.\n\n"
+        "Preparation: Piotr Styla with Devin. Changes: namespace filtering (1 and 5), wikitext "
+        "stripping, cross-document boilerplate removal, Unicode and whitespace normalization, limited "
+        "email/labelled-phone/IP/labelled-national-ID/account-candidate redaction, language/quality filtering and within-source deduplication. No "
+        "endorsement by the Wikimedia Foundation or page contributors is implied.\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(stats, ensure_ascii=False, indent=2))
+
+
+def verify(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")
+    decisions = read_lines(root / "artifacts/decisions.jsonl")
+    attribution = read_lines(root / "artifacts/attribution.jsonl")
+    sample = read_lines(root / "artifacts/sample.jsonl")
+    assert table.column_names == FIELDS
+    assert len(rows) == stats["kept"] == len(attribution)
+    assert sum(item["selected"] for item in decisions) == len(rows)
+    assert sum(row["token_count"] for row in rows) == stats["tokens"]
+    assert all(row["source"] == SOURCE and row["license"] == LICENSE_SPDX for row in rows)
+    assert all(EMAIL_RE.search(row["text"]) is None for row in rows)
+    by_id = {row["id"]: row for row in rows}
+    assert len(sample) == stats["sample_count"] and all(by_id[row["id"]] == row for row in sample)
+    ontology = load(root / "artifacts/ontology.json")
+    evidence = {item["id"] for item in ontology["evidence"]}
+    assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence for item in ontology["claims"])
+    checks = load(root / "artifacts/checksums.json")
+    assert all((root / path).is_file() and digest((root / path).read_bytes()) == checksum for path, checksum in checks.items())
+    for item in ontology["evidence"]:
+        artifact = root / item["artifact"]
+        assert artifact.is_file() and digest(load(artifact)) == item["content_address"]
+    import tiktoken
+
+    encoder = tiktoken.get_encoding("cl100k_base")
+    assert len(by_id) == len(rows)
+    assert set(by_id) == {item["id"] for item in attribution}
+    assert set(by_id) == {item["id"] for item in decisions if item["selected"]}
+    assert len(decisions) == stats["talk_pages"]
+    assert len(decisions) - len(rows) == stats["rejected"]
+    assert sum(len(row["text"]) for row in rows) == stats["characters"]
+    short_ids = [row["id"] for row in rows if len(row["text"]) < MIN_TEXT_CHARS]
+    assert all(row["token_count"] > 0 for row in rows)
+    assert all(len(row["created"]) == 10 and row["author"] for row in rows)
+    assert all(item["ns"] in TALK_NS and item["url"] == page_url(item["title"])
+               and item["text_sha256"] == digest(by_id[item["id"]]["text"].encode("utf-8"))
+               for item in attribution)
+    assert all(len(encoder.encode_ordinary(row["text"])) == row["token_count"] for row in rows)
+    boilerplate = set(load(root / "artifacts/boilerplate_lines.json"))
+    review_ids = {row["id"] for row in sorted(sample, key=lambda item: len(item["text"]))[:3]}
+    comparisons = []
+    reconstructed = set()
+    for shard in sorted((out / "extracted").glob("*.jsonl.gz")):
+        with gzip.open(shard, "rt", encoding="utf-8") as handle:
+            for line in handle:
+                original = json.loads(line)
+                row_id = f"{SOURCE}_{original['pageid']}"
+                if row_id not in by_id:
+                    continue
+                text = normalize(original["text"])
+                text = "\n".join(line for line in text.splitlines()
+                                 if re.sub(r"\s+", " ", line).strip() not in boilerplate)
+                text = re.sub(r"\n{3,}", "\n\n", text).strip().replace("\ufffd", "[UNREADABLE_GLYPH]")
+                text, _ = redact_pii(text)
+                before = redact_pii(original["text"])[0] if row_id in review_ids else ""
+                assert text == by_id[row_id]["text"], row_id
+                assert row_id not in reconstructed
+                reconstructed.add(row_id)
+                if row_id in review_ids:
+                    comparisons.append({"id": row_id, "title": original["title"],
+                                        "before_normalization_pii_patterns_redacted": before,
+                                        "after": text})
+    assert reconstructed == set(by_id)
+    write_lines(out / "validation_samples.jsonl", comparisons)
+    lengths = sorted(len(row["text"]) for row in rows)
+    rejection_counts = dict(Counter(item["reason"] for item in decisions if not item["selected"]))
+    residuals = {name: sum(bool(pattern.search(row["text"])) for row in rows)
+                 for name, pattern in {"email": EMAIL_RE, "labelled_phone": PHONE_RE,
+                                       "ipv4": IPV4_RE, "ipv6_current_pattern": IPV6_RE}.items()}
+    privacy_review = {
+        "compressed_ipv6_documents": sum(any(is_ipv6(match.group()) for match in IPV6_CANDIDATE_RE.finditer(row["text"])) for row in rows),
+        "labelled_national_identifier_candidates": sum(bool(NATIONAL_ID_RE.search(row["text"])) for row in rows),
+        "bank_account_candidates": sum(bool(BANK_ACCOUNT_RE.search(row["text"])) for row in rows),
+    }
+    report = {
+        "observed_at": now(), "verified": not short_ids and not any(residuals.values()) and not any(privacy_review.values()), "stats": stats,
+        "additional_privacy_review_document_counts": privacy_review,
+        "below_minimum_length_ids": short_ids,
+        "rejection_counts": rejection_counts,
+        "retained_namespaces": dict(Counter(item["ns"] for item in attribution)),
+        "length_quantiles": {str(q): lengths[int((len(lengths) - 1) * q)] for q in (0, 0.5, 0.9, 0.99, 1)},
+        "residual_pattern_document_counts": residuals,
+        "all_token_counts_recomputed": True,
+        "texts_reconstructed_from_extracted_source": len(reconstructed),
+        "before_after_samples": len(comparisons),
+        "publication_ready": False,
+        "pending": ["license evidence and attribution review", "PII coverage review",
+                    "target overlap audit methodology review", "manual text quality review"],
+    }
+    save(out / "validation_report.json", report)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    assert report["verified"], "Validation failures: see validation_report.json"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("command", choices=["discover", "acquire", "audit_target", "audit_overlap",
+                                            "build", "verify"])
+    args = parser.parse_args()
+    if args.command == "discover":
+        discover(args.output)
+    elif args.command == "acquire":
+        acquire(args.output, args.workers)
+    elif args.command == "audit_target":
+        audit_target(args.output)
+    elif args.command == "audit_overlap":
+        audit_overlap(args.output)
+    elif args.command == "build":
+        build(args.output)
+    else:
+        verify(args.output)
+
+
+if __name__ == "__main__":
+    main()
+

src/plwiki_talk_requirements.txt

@@ -0,0 +1,7 @@
+requests==2.32.5
+pyarrow==23.0.1
+tiktoken==0.12.0
+langid==1.1.6
+mwparserfromhell==0.7.2
+huggingface_hub>=1.0,<2
+pytest>=8,<10

src/sources.py

@@ -65,6 +65,21 @@ SOURCES = {
      'created': '2023-2026',
      'is_ocr': False,
      'custom_datasheet': True},
+    "plwiki_talk": {
+        "added": "2026-09-11",
+        "release": None,
+        "file_key": "plwiki_talk",
+        "pretty": "Polish Wikipedia talk pages (ns 1+5)",
+        "license": "CC BY-SA 4.0",
+        "license_spdx": "CC-BY-SA-4.0",
+        "traceable": "Records come from the pinned official Wikimedia pages-meta-current dump (sha1-verified shards). Per-record page id, title, namespace, last-revision timestamp and canonical URL are preserved; page history carries contributor attribution per Wikimedia Terms of Use section 7.",
+        "upstream": "https://pl.wikipedia.org/",
+        "provenance": "Rebuilt deterministically from the Wikimedia XML dump. Scope is namespaces 1 and 5 only; mainspace (ns=0) is covered by the existing wikipedia shard and user-talk (ns=3) is excluded by scope decision (not measured). Wikitext stripped with mwparserfromhell, cross-document boilerplate lines removed, normalized, PII patterns redacted (email, labelled phone, IPv4, parsed IPv6 including compressed notation, labelled PESEL/NIP/REGON, 26-digit account candidates), language/quality filtered and within-source deduplicated. Pattern redaction is not complete anonymization.",
+        "domain": "conversational/community-moderation",
+        "created": "2002-2026",
+        "is_ocr": False,
+        "custom_datasheet": True,
+    },
     "wikipedia": {
         "added": "2026-07-02",
         "release": "0.2.0",

src/test_build_plwiki_talk_pl.py

@@ -0,0 +1,179 @@
+import importlib.util
+from pathlib import Path
+
+
+SCRIPT = Path(__file__).with_name("build_plwiki_talk_pl.py")
+SPEC = importlib.util.spec_from_file_location("build_plwiki_talk_pl", SCRIPT)
+MODULE = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(MODULE)
+
+
+def test_talk_namespaces_exclude_user_talk_and_mainspace():
+    assert MODULE.TALK_NS == {"1", "5"}
+    assert "0" not in MODULE.TALK_NS and "3" not in MODULE.TALK_NS
+
+
+def test_normalize_repairs_hyphenation_and_page_numbers():
+    assert MODULE.normalize("Pierw-\nszy akapit.\n12\n\ndrugi wiersz") == "Pierwszy akapit.\n\ndrugi wiersz"
+
+
+def test_title_normalization_is_case_and_diacritic_insensitive():
+    assert MODULE.normalize_title("Dyskusja:Łódź (woj.)") == "dyskusja łodz woj"
+
+
+def test_boilerplate_lines_removed_only_when_frequent():
+    docs = [["Baner wikiprojektu", f"Prawdziwa dyskusja {i}."] for i in range(150)]
+    lines = MODULE.strip_boilerplate(docs)
+    assert "Baner wikiprojektu" in lines
+    assert "Prawdziwa dyskusja 0." not in lines
+
+
+def test_boilerplate_long_lines_never_dropped():
+    docs = [["x" * 200] * 1 for _ in range(150)]
+    assert MODULE.strip_boilerplate(docs) == set()
+
+
+def test_ip_redaction_patterns():
+    text = "Podpisano przez 83.4.55.1 dnia 2 maja"
+    assert MODULE.IPV4_RE.search(text)
+    assert not MODULE.IPV4_RE.search("wersja 1.2 wydana")
+
+
+def test_redaction_covers_compressed_ipv6_and_labelled_identifiers():
+    text = "Adres [2001:db8::1], ::ffff:192.0.2.1. PESEL: 00000000000 NIP 000-000-00-00 REGON: 000000000 Rachunek PL00 " + "0000 " * 6
+    cleaned, counts = MODULE.redact_pii(text)
+    assert "2001:db8" not in cleaned and "192.0.2.1" not in cleaned
+    assert cleaned.count("[REDACTED:IP]") == 2
+    assert cleaned.count("[REDACTED:ID]") == 3
+    assert "[REDACTED:ACCOUNT]" in cleaned
+    assert counts["ipv6"] == 2 and counts["national_identifier"] == 3
+    assert MODULE.redact_pii(cleaned)[0] == cleaned
+
+
+def test_redaction_preserves_time_and_version_numbers():
+    text = "Wersja 1.2.3, godzina 12:30:45. Adres 2001:db8::2."
+    cleaned, _ = MODULE.redact_pii(text)
+    assert cleaned == "Wersja 1.2.3, godzina 12:30:45. Adres [REDACTED:IP]."
+
+
+def test_attribution_url_quotes_fragments_and_polish_characters():
+    from urllib.parse import unquote, urlsplit
+
+    url = MODULE.page_url("Dyskusja:Łódź/C#")
+    assert url.isascii()
+    assert not urlsplit(url).fragment
+    assert unquote(urlsplit(url).path) == "/wiki/Dyskusja:Łódź/C#"
+
+
+def test_text_bound_and_license():
+    assert MODULE.MIN_TEXT_CHARS == 500
+    assert MODULE.LICENSE_SPDX == "CC-BY-SA-4.0"
+    assert MODULE.DUMP_DATE.startswith("20")
+
+
+def test_indexed_dedup_matches_exhaustive_comparison():
+    import random
+
+    rng = random.Random(42)
+    sketches = [set(), {1}, {1}, set(range(10)), set(range(9)), set(range(8))]
+    for _ in range(200):
+        base = set(rng.sample(range(10000), rng.randint(10, 200)))
+        sketches.extend([base, base | {10001}, set(sorted(base)[1:]), base | set(range(20))])
+    index = MODULE.NearDuplicateIndex()
+    retained = []
+    for sketch in sketches:
+        expected = (None, 0.0)
+        for row_id, other in retained:
+            score = len(sketch & other) / max(len(sketch | other), 1)
+            if score >= 0.90:
+                expected = (row_id, score)
+                break
+        assert index.find(sketch) == expected
+        if expected[0] is None:
+            row_id = str(len(retained))
+            retained.append((row_id, sketch))
+            index.add(row_id, sketch)
+
+
+def test_index_avoids_comparing_disjoint_sketches():
+    index = MODULE.NearDuplicateIndex()
+    for i in range(1000):
+        sketch = set(range(i * 100, (i + 1) * 100))
+        assert index.find(sketch) == (None, 0.0)
+        index.add(str(i), sketch)
+    assert index.comparisons == 0
+    assert index.find(set(range(90000, 90100))) == ("900", 1.0)
+    assert index.comparisons == 1
+
+
+def test_language_vote_reuses_identical_windows_without_changing_votes():
+    class Identifier:
+        def __init__(self):
+            self.calls = 0
+
+        def classify(self, text):
+            self.calls += 1
+            return "pl", 0.99
+
+    identifier = Identifier()
+    language, votes = MODULE.language_vote(identifier, "Przykładowy polski tekst.")
+    assert language == "pl" and votes == [("pl", 0.99)] * 3
+    assert identifier.calls == 1
+
+
+def write_test_source(tmp_path, texts):
+    import gzip
+    import json
+
+    MODULE.save(tmp_path / "selection.json", {"dump_date": "20260901", "files": [], "observed_at": "2026-09-11T00:00:00Z"})
+    MODULE.save(tmp_path / "acquisition.json", {"talk_pages": len(texts), "observed_at": "2026-09-11T00:00:00Z"})
+    records = [{"pageid": str(index), "ns": "1", "title": f"Dyskusja:Test {index}", "timestamp": "2026-09-01",
+                "wikitext_chars": len(text), "text": text} for index, text in enumerate(texts, 1)]
+    MODULE.write_lines(tmp_path / "source_manifest.jsonl", records)
+    (tmp_path / "extracted").mkdir()
+    with gzip.open(tmp_path / "extracted/test.jsonl.gz", "wt", encoding="utf-8") as handle:
+        for record in records:
+            handle.write(json.dumps(record) + "\n")
+
+
+def test_build_rechecks_length_after_redaction(tmp_path, monkeypatch):
+    text = ("To jest przykładowa wypowiedź po polsku. " * 20)[:470] + " " + "kontakt" * 8 + "@example.org"
+    write_test_source(tmp_path, [text])
+    monkeypatch.setattr(MODULE, "language_vote", lambda identifier, text: ("pl", [("pl", 1.0)]))
+    MODULE.build(tmp_path)
+    decision = MODULE.read_lines(tmp_path / "hf_repo/artifacts/decisions.jsonl")[0]
+    assert not decision["selected"]
+    assert decision["reason"] == "too_little_text_after_redaction"
+
+
+def test_build_verify_roundtrip_and_tamper_detection(tmp_path, monkeypatch):
+    import pytest
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    text = "To jest przykładowa wypowiedź po polsku dotycząca edycji encyklopedii. " * 15
+    write_test_source(tmp_path, [text, text, "Krótki tekst."])
+    monkeypatch.setattr(MODULE, "language_vote", lambda identifier, text: ("pl", [("pl", 1.0)]))
+    MODULE.build(tmp_path)
+    MODULE.verify(tmp_path)
+    report = MODULE.load(tmp_path / "validation_report.json")
+    assert report["verified"]
+    assert report["texts_reconstructed_from_extracted_source"] == 1
+    assert report["rejection_counts"] == {"normalized_duplicate": 1, "too_little_text": 1}
+    assert report["before_after_samples"] == 1
+    assert not report["publication_ready"]
+    path = tmp_path / "hf_repo/data/train-00000-of-00001.parquet"
+    table = pq.read_table(path)
+    rows = table.to_pylist()
+    rows[0]["token_count"] += 1
+    pq.write_table(pa.Table.from_pylist(rows, schema=table.schema), path)
+    with pytest.raises(AssertionError):
+        MODULE.verify(tmp_path)
+
+
+def test_shard_filename_pattern_is_strict():
+    import re
+    pat = re.compile(r"plwiki-\d+-pages-meta-current\d+\.xml-p\d+p\d+\.bz2")
+    assert pat.fullmatch("plwiki-20260901-pages-meta-current1.xml-p1p187037.bz2")
+    assert not pat.fullmatch("plwiki-20260901-pages-articles.xml.bz2")
+    assert not pat.fullmatch("plwiki-20260901-pages-meta-current.xml.bz2")