Add UZP public-procurement rulings (KIO/SO/SA/SN) (#39)

- Add UZP public-procurement rulings (KIO/SO/SA/SN) (1a1c510a22dce0fd2e8a314c3884870221d3805d)


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

.gitattributes

@@ -60,3 +60,5 @@ data/samorzad_gov_pl/*.jsonl filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 data/sejm_api/sejm_api.attribution.jsonl filter=lfs diff=lfs merge=lfs -text
+data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.attribution.jsonl filter=lfs diff=lfs merge=lfs -text
+data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.decisions.jsonl filter=lfs diff=lfs merge=lfs -text

artifacts/uzp_orzeczenia_pl_ontology_manifest.json

@@ -0,0 +1,134 @@
+{
+  "actors": [
+    {
+      "id": "actor:piotrsty",
+      "type": "Contributor"
+    },
+    {
+      "id": "actor:uzp",
+      "type": "Organization"
+    },
+    {
+      "id": "actor:devin",
+      "type": "Agent"
+    }
+  ],
+  "claims": [
+    {
+      "falsification_condition": "The pinned Parquet, decisions or overlap report do not reproduce these counts.",
+      "id": "claim:uzp-target-retention",
+      "statement": "The proposed DynaWord slice contains 34715 records after excluding 0 signature overlaps.",
+      "supported_by": [
+        "evidence:uzp-target-stats:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0",
+        "evidence:uzp-target-overlap:d70053726c85373e3411cc28da26c3aeffbd25cf9adf7c30a3ecdda3ebeaef10"
+      ]
+    },
+    {
+      "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties.",
+      "id": "claim:uzp-training-value-untested",
+      "statement": "Net text novelty and training benefit remain untested hypotheses.",
+      "supported_by": [
+        "evidence:uzp-target-overlap:d70053726c85373e3411cc28da26c3aeffbd25cf9adf7c30a3ecdda3ebeaef10"
+      ]
+    }
+  ],
+  "evidence": [
+    {
+      "artifact": "data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.stats.json",
+      "content_address": "57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0",
+      "id": "evidence:uzp-target-stats:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0",
+      "observation_type": "target_slice_counts",
+      "produced_by": "run:uzp-orzeczenia-dynaword-integration:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0"
+    },
+    {
+      "artifact": "data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.overlap_audit.json",
+      "content_address": "d70053726c85373e3411cc28da26c3aeffbd25cf9adf7c30a3ecdda3ebeaef10",
+      "id": "evidence:uzp-target-overlap:d70053726c85373e3411cc28da26c3aeffbd25cf9adf7c30a3ecdda3ebeaef10",
+      "observation_type": "metadata_overlap_audit",
+      "produced_by": "run:uzp-orzeczenia-dynaword-integration:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0"
+    }
+  ],
+  "objects": [
+    {
+      "id": "object:dataset:uzp-orzeczenia-pl",
+      "type": "Dataset"
+    },
+    {
+      "id": "object:dataset:uzp-orzeczenia-pl-dynaword-slice",
+      "type": "Dataset"
+    }
+  ],
+  "pending": [
+    "formal legal review of art. 4(2) application",
+    "cross-source text deduplication",
+    "benchmark contamination check",
+    "review of quoted third-party text",
+    "controlled training ablation"
+  ],
+  "protocols": [
+    {
+      "id": "protocol:uzp-orzeczenia-dynaword-integration-v1",
+      "procedure": "exclude source-QA failures and signature overlaps with pinned saos; preserve attribution and pending text-level gates"
+    }
+  ],
+  "relations": [
+    {
+      "predicate": "DERIVED_FROM",
+      "source": "version:dataset:uzp-orzeczenia-pl-dynaword:2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+      "target": "hf:dataset:PiotrSty/uzp-orzeczenia-pl@696485691e9f8cb85d1a34221897250e25359ba0"
+    },
+    {
+      "predicate": "GENERATED_BY",
+      "source": "version:dataset:uzp-orzeczenia-pl-dynaword:2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+      "target": "run:uzp-orzeczenia-dynaword-integration:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0"
+    },
+    {
+      "predicate": "VALIDATED_AGAINST",
+      "source": "version:dataset:uzp-orzeczenia-pl-dynaword:2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+      "target": "hf:dataset:SlayerLab/polish-dynaword@bade8e7cae51bd30e9530c3be38dd0e3eeba1f70"
+    }
+  ],
+  "runs": [
+    {
+      "actor": "actor:devin",
+      "finished_at": "2026-09-19T06:14:52.208957+00:00",
+      "id": "run:uzp-orzeczenia-dynaword-integration:57384373cb2c3883fb240ab0468d309dc62893a01ccd939f25081a931a1c20c0",
+      "protocol": "protocol:uzp-orzeczenia-dynaword-integration-v1",
+      "started_at": "2026-09-19T06:14:52.208957+00:00",
+      "stats": {
+        "added": "2026-09-17",
+        "characters": 1110428704,
+        "enumerated": 35694,
+        "kept": 34715,
+        "license_counts": {
+          "public-domain (official documents)": 34715
+        },
+        "per_kind": {
+          "KIO": 34412,
+          "SA": 3,
+          "SN": 2,
+          "SO": 1277
+        },
+        "sample_count": 12,
+        "source_slice_kept": 34715,
+        "target_overlap_excluded": 0,
+        "target_revision": "bade8e7cae51bd30e9530c3be38dd0e3eeba1f70",
+        "tokens": 422043881
+      },
+      "success": true
+    }
+  ],
+  "schema": "slayer-research-ontology-profile-v1",
+  "versions": [
+    {
+      "content_address": "696485691e9f8cb85d1a34221897250e25359ba0",
+      "id": "hf:dataset:PiotrSty/uzp-orzeczenia-pl@696485691e9f8cb85d1a34221897250e25359ba0",
+      "object": "object:dataset:uzp-orzeczenia-pl"
+    },
+    {
+      "content_address": "2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+      "id": "version:dataset:uzp-orzeczenia-pl-dynaword:2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+      "object": "object:dataset:uzp-orzeczenia-pl-dynaword-slice"
+    }
+  ]
+}

data/uzp_orzeczenia_pl/NOTICE.md

@@ -0,0 +1,7 @@
+# Attribution and legal basis
+
+Source: UZP decision search service, https://orzeczenia.uzp.gov.pl/ (Urzad Zamowien Publicznych / Public Procurement Office).
+
+Records are official rulings (KIO, district courts, administrative courts, Supreme Court) in public procurement matters. Working basis: Polish Copyright Act art. 4(2) excludes official documents from copyright; no per-record license field exists on the service. Formal legal review has not been performed. Consult `artifacts/attribution.jsonl` for per-record provenance (organ, signature, issue date, URLs, checksums).
+
+Preparation: Piotr Styla with Devin (Cognition). Changes: service-PDF text extraction, running-head and page-number removal, Unicode/whitespace normalization, line-wrap repair, limited email/phone/IP/identifier/account pattern redaction, language/quality filtering and within-source deduplication. Names of parties and adjudicators remain as part of the official record. No endorsement by UZP, KIO or the courts is implied.

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.attribution.jsonl

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

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.checksums.json

@@ -0,0 +1,11 @@
+{
+  "NOTICE.md": "7c9174db26e75108686bec4c2f68e07c7a778ccb774add23eb60c19e131e9867",
+  "uzp_orzeczenia_pl.attribution.jsonl": "37e2a74646232784622a504a10f1b05aca0a16a6a9c647c4611d12c3f13726a5",
+  "uzp_orzeczenia_pl.decisions.jsonl": "e80c5cac3c5c2786aeaeeb4babe6adcdf9355262e2657e06de61604f64b3cb60",
+  "uzp_orzeczenia_pl.md": "2c046f70c82f03fd051fb57f6b4028b70d42017d5883f7821f057db6f59bcbbd",
+  "uzp_orzeczenia_pl.overlap_audit.json": "584de6d8816921fb2bc3b312cbaa190ecfb829bbb471d97346db7d2989c4d72c",
+  "uzp_orzeczenia_pl.parquet": "2c7a13f99ee5571aa66a4d576a6b6705a3a896675ffc93d889447ca0ed9aae1a",
+  "uzp_orzeczenia_pl.qa.json": "2cd46cf726277064d051f96df0d99e4a5c7ee391ce53a15cabca9c5d9860219f",
+  "uzp_orzeczenia_pl.sample.jsonl": "d47fd82b7df915bc4957d8335fbc763749ceca796acd7afe4e504d1f37bdfe55",
+  "uzp_orzeczenia_pl.stats.json": "0dbc1b8a1fc7605178a012e1451baf0372eaefd1ad66e19243c73caad3e39e60"
+}

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.decisions.jsonl

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

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.md

@@ -0,0 +1,23 @@
+# UZP Orzeczenia - Polish public-procurement rulings (KIO/SO/SA/SN)
+
+This slice is derived from the deterministic enumeration of the official UZP
+decision search service (https://orzeczenia.uzp.gov.pl/): all rulings of the
+National Appeals Chamber (KIO), district courts (SO), administrative courts (SA)
+and the Supreme Court (SN) in public procurement matters.
+
+- Enumerated documents: 35,694 (per kind: {'KIO': 34412, 'SA': 3, 'SN': 2, 'SO': 1277})
+- Source slice retained after QA: 34715
+- Signature overlaps with `saos` excluded: 0
+- Proposed records: 34715
+- Proposed tokens: 422,043,881 (`cl100k_base` proxy)
+- Characters: 1,110,428,704
+- License label: `public-domain (official documents)` (LicenseRef-Polish-Official-Documents)
+- Immutable source snapshot: https://huggingface.co/datasets/PiotrSty/uzp-orzeczenia-pl/tree/696485691e9f8cb85d1a34221897250e25359ba0
+
+Per-record attribution, landing URLs, PDF URLs and checksums are preserved.
+Rulings are official documents; the working basis is Polish Copyright Act
+art. 4(2) - no formal legal review has been performed. Cross-source text
+deduplication and benchmark checks remain integration gates. pypdf-derived
+text can retain layout artifacts and flattened tables. Names of parties and
+adjudicators remain part of the official record; pattern-based PII checks are
+not comprehensive de-identification.

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.overlap_audit.json

@@ -0,0 +1,12 @@
+{
+  "candidate_records": 35694,
+  "colliding_ids": [],
+  "collisions": [],
+  "method": "case-normalized signature match against SAOS attribution strings",
+  "observed_at": "2026-09-18T04:34:43.880281+00:00",
+  "saos_rows": 0,
+  "signature_collisions": 0,
+  "target": "SlayerLab/polish-dynaword:data/saos",
+  "target_revision": "bade8e7cae51bd30e9530c3be38dd0e3eeba1f70",
+  "text_overlap": "not tested; target-wide text dedup remains an integration gate"
+}

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.parquet

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

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.qa.json

@@ -0,0 +1,14 @@
+{
+  "benchmark_overlap": "pending",
+  "cross_source_text_dedup": "pending target integration",
+  "known_target_signature_overlap_excluded": 0,
+  "limitations": [
+    "pypdf extraction may retain layout artifacts; tables may be flattened",
+    "pattern checks are not comprehensive de-identification; natural-person names of parties and adjudicators remain part of the official record",
+    "official-document status does not cover third-party material quoted inside rulings",
+    "sequential IDs contain gaps; enumeration follows the server-side result list, not the ID range"
+  ],
+  "scope": "DynaWord proposal derived from the UZP procurement-rulings corpus",
+  "source_text_qa_rejected": 979,
+  "within_source_exact_and_near_dedup": true
+}

data/uzp_orzeczenia_pl/uzp_orzeczenia_pl.stats.json

@@ -0,0 +1,20 @@
+{
+  "added": "2026-09-17",
+  "characters": 1110428704,
+  "enumerated": 35694,
+  "kept": 34715,
+  "license_counts": {
+    "public-domain (official documents)": 34715
+  },
+  "per_kind": {
+    "KIO": 34412,
+    "SA": 3,
+    "SN": 2,
+    "SO": 1277
+  },
+  "sample_count": 12,
+  "source_slice_kept": 34715,
+  "target_overlap_excluded": 0,
+  "target_revision": "bade8e7cae51bd30e9530c3be38dd0e3eeba1f70",
+  "tokens": 422043881
+}

src/build_uzp_orzeczenia_pl.py

@@ -0,0 +1,862 @@
+#!/usr/bin/env python3
+"""Build an auditable corpus of UZP public-procurement rulings (KIO/SO/SA/SN).
+
+Source: https://orzeczenia.uzp.gov.pl - the official decision search service of
+the Polish Public Procurement Office (Urzad Zamowien Publicznych). Documents
+are official rulings of the National Appeals Chamber (KIO), district courts
+(SO), administrative courts (SA) and the Supreme Court (SN) in public
+procurement matters. Legal basis: official documents are excluded from
+copyright under Polish Copyright Act art. 4(2) (same basis as the SAOS slice).
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+import gzip
+import hashlib
+import html as html_module
+import io
+import ipaddress
+import json
+from pathlib import Path
+import re
+import time
+
+import requests
+
+
+SOURCE = "uzp_orzeczenia_pl"
+OWN_REPO = "PiotrSty/uzp-orzeczenia-pl"
+TARGET = "SlayerLab/polish-dynaword"
+BASE = "https://orzeczenia.uzp.gov.pl"
+SEARCH_URL = BASE + "/Home/Search"
+RESULTS_URL = BASE + "/Home/GetResults"
+SOURCE_URL = BASE + "/"
+FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+UA = "UzpOrzeczeniaCorpusResearch/0.1 (PiotrSty; open research slice)"
+LICENSE_LABEL = "public-domain (official documents)"
+LICENSE_SPDX = "LicenseRef-Polish-Official-Documents"
+LEGAL_BASIS = ("Polish Copyright Act art. 4(2): official documents are not subject to copyright; "
+               "UZP search service republishes KIO/SO/SA/SN rulings in public procurement matters")
+MIN_TEXT_CHARS = 1_500
+PAGE_SIZE = 10  # fixed server-side; #sp-page-size is not a serialized form field
+KINDS = ("KIO", "SO", "SA", "SN")
+
+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)")
+DETAILS_LINK_RE = re.compile(r'href="/Home/Details/(\d+)"')
+RESULT_COUNTS_RE = re.compile(r'value="([\d,]+)"\s+id="resultCounts"')
+PDF_LINK_RE = re.compile(r'href="(/Home/PdfContent/(\d+)\?Kind=([A-Z]+))"')
+SYGN_RE = re.compile(r"^Sygn\.\s*akt\b", re.I)
+PAGE_NUM_RE = re.compile(r"^\d{1,4}$")
+
+
+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 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 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 iso_date(text):
+    match = re.match(r"(\d{2})-(\d{2})-(\d{4})", (text or "").strip())
+    if match:
+        day, month, year = match.groups()
+        return f"{year}-{month}-{day}"
+    return ""
+
+
+def strip_html(fragment):
+    return html_module.unescape(re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", fragment))).strip()
+
+
+def parse_result_items(page_html):
+    """Parse /Home/GetResults response into per-document records."""
+    records = []
+    for block in re.findall(r'<div class="search-list-item".*?(?=<div class="search-list-item"|$)',
+                          page_html, flags=re.S):
+        link = DETAILS_LINK_RE.search(block)
+        if not link:
+            continue
+        fields = dict()
+        for label, value in re.findall(r"<label>([^<]+)</label>\s*([^<]+)", block):
+            fields[label.strip().rstrip(":")] = strip_html(value)
+        records.append({
+            "doc_id": int(link.group(1)),
+            "organ": fields.get("Organ wydający", ""),
+            "doc_type": fields.get("Rodzaj dokumentu", ""),
+            "signature": fields.get("Sygnatura", ""),
+            "issued": fields.get("Data wydania", ""),
+        })
+    counts = RESULT_COUNTS_RE.search(page_html)
+    totals = [int(value) for value in counts.group(1).split(",")] if counts else []
+    return records, totals
+
+
+def parse_counts(page_html):
+    """Return dict kind -> count from the resultCounts hidden field."""
+    _records, totals = parse_result_items(page_html)
+    kinds = ["ALL", "KIO", "SO", "SA", "SN"]
+    return {kinds[index]: value for index, value in enumerate(totals)} if totals else {}
+
+
+def parse_details(page_html, doc_id):
+    """Parse /Home/Details/{id} metadata page."""
+    pdf = PDF_LINK_RE.search(page_html)
+    body = re.sub(r"<script.*?</script>", " ", page_html, flags=re.S)
+    fields = {}
+    for label, value in re.findall(r"<label>([^<]+)</label>\s*([^<]+)", body):
+        fields[label.strip().rstrip(":")] = strip_html(value)
+    return {
+        "doc_id": doc_id,
+        "organ": fields.get("Organ wydający", ""),
+        "doc_type": fields.get("Rodzaj dokumentu", ""),
+        "issued": fields.get("Data wydania rozstrzygnięcia", ""),
+        "chairman": fields.get("Przewodniczący", ""),
+        "purchaser": fields.get("Zamawiający", ""),
+        "city": fields.get("Miejscowość", ""),
+        "signature": fields.get("Sygnatura akt / Sposób rozstrzygnięcia",
+                                fields.get("Sygnatura akt / Sygnatura KIO / Sposób rozstrzygnięcia", "")),
+        "provisions": fields.get("Kluczowe przepisy ustawy Pzp", ""),
+        "pdf_path_url": BASE + pdf.group(1) if pdf else "",
+        "pdf_kind": pdf.group(3) if pdf else "",
+    }
+
+
+def session():
+    s = requests.Session()
+    s.headers.update({"User-Agent": UA})
+    s.get(SEARCH_URL, timeout=20)
+    return s
+
+
+def post_results(sess, kind, page, attempts=5):
+    data = {"Phrase": "", "Fle": "1", "SCnt": "1", "CountStats": "true",
+            "Kind": kind, "Srt": "", "Pg": str(page)}
+    for attempt in range(attempts):
+        try:
+            r = sess.post(RESULTS_URL, data=data, timeout=30)
+            if r.status_code in (429, 500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+                continue
+            r.raise_for_status()
+            return r.text
+        except requests.RequestException:
+            if attempt == attempts - 1:
+                raise
+            time.sleep(2 ** attempt)
+    raise RuntimeError("unreachable")
+
+
+def request(url, attempts=5, timeout=(15, 90), binary=False, sess=None):
+    client = sess or requests
+    response = None
+    for attempt in range(attempts):
+        response = client.get(url, headers={"User-Agent": UA}, timeout=timeout)
+        if response.status_code not in (429, 500, 502, 503, 504):
+            response.raise_for_status()
+            return response.content if binary else response.content.decode("utf-8", "replace")
+        time.sleep(2 ** attempt)
+    response.raise_for_status()
+
+
+def request_json(url):
+    return json.loads(request(url))
+
+
+def discover(out, workers):
+    """Enumerate every document via the kind-filtered result pages."""
+    seen = {}
+    counts = {}
+    for kind in KINDS:
+        body = post_results(session(), kind, 1)
+        first, totals = parse_result_items(body)
+        all_counts = parse_counts(body)
+        counts[kind] = all_counts.get(kind, len(first))
+        total = counts[kind]
+        pages = max(1, -(-total // PAGE_SIZE)) if total else 1
+        for record in first:
+            record["kind"] = kind
+            seen[record["doc_id"]] = record
+
+        def fetch_page(page):
+            return page, post_results(session(), kind, page)
+
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            futures = {pool.submit(fetch_page, p): p for p in range(2, pages + 1)}
+            for index, future in enumerate(as_completed(futures), 1):
+                _, body = future.result()
+                for record in parse_result_items(body)[0]:
+                    record["kind"] = kind
+                    seen[record["doc_id"]] = record
+                if index % 200 == 0:
+                    print(f"  {kind} {index}/{pages - 1} pages", flush=True)
+        print(f"  {kind}: {pages} pages, total {total}", flush=True)
+    records = sorted(seen.values(), key=lambda record: record["doc_id"])
+    write_lines(out / "source_manifest.jsonl", records)
+    selection = {
+        "observed_at": now(), "search_url": SEARCH_URL,
+        "reported_totals": counts, "enumerated": len(records),
+        "per_kind": dict(Counter(record["kind"] for record in records)),
+        "selected": len(records),
+        "selected_ids": [record["doc_id"] for record in records],
+        "source_manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()),
+    }
+    save(out / "selection.json", selection)
+    print(json.dumps(selection, ensure_ascii=False, indent=2))
+
+
+def acquire(out, workers):
+    selection = load(out / "selection.json")
+    manifest = {record["doc_id"]: record for record in read_lines(out / "source_manifest.jsonl")}
+    (out / "raw_pages").mkdir(parents=True, exist_ok=True)
+    (out / "raw_pdf").mkdir(parents=True, exist_ok=True)
+    (out / "raw_text").mkdir(parents=True, exist_ok=True)
+    results = []
+
+    def fetch(doc_id):
+        record = manifest[doc_id]
+        page_path = out / "raw_pages" / f"{doc_id}.html.gz"
+        pdf_path = out / "raw_pdf" / f"{doc_id}.pdf"
+        text_path = out / "raw_text" / f"{doc_id}.txt"
+        if pdf_path.is_file() and text_path.is_file() and page_path.is_file():
+            return record, digest(pdf_path.read_bytes()), pdf_path.stat().st_size, \
+                digest(text_path.read_bytes()), "cached", json.loads(
+                    gzip.decompress(page_path.read_bytes()).decode("utf-8"))["details"]
+        sess = session()
+        body = request(BASE + f"/Home/Details/{doc_id}", sess=sess)
+        details = parse_details(body, doc_id)
+        if not details["pdf_path_url"]:
+            raise ValueError(f"no PdfContent link on details page: {doc_id}")
+        page_path.write_bytes(gzip.compress(json.dumps(
+            {"doc_id": doc_id, "details": details}, ensure_ascii=False).encode("utf-8")))
+        payload = request(details["pdf_path_url"], binary=True, sess=sess)
+        if not payload.startswith(b"%PDF"):
+            raise ValueError("not a PDF: " + str(doc_id))
+        pdf_path.write_bytes(payload)
+        from pypdf import PdfReader
+        reader = PdfReader(io.BytesIO(payload))
+        text = "\n".join(page.extract_text() or "" for page in reader.pages)
+        text_path.write_text(text, encoding="utf-8")
+        return record, digest(payload), len(payload), digest(text.encode("utf-8")), \
+            str(len(reader.pages)), details
+
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        futures = {pool.submit(fetch, doc_id): doc_id for doc_id in selection["selected_ids"]}
+        for index, future in enumerate(as_completed(futures), 1):
+            doc_id = futures[future]
+            record = manifest[doc_id]
+            try:
+                record, pdf_sha, pdf_bytes, text_sha, pages, details = future.result()
+                results.append({**record, "details": details, "pdf_sha256": pdf_sha,
+                                "pdf_bytes": pdf_bytes, "text_sha256": text_sha, "pdf_pages": pages,
+                                "pdf_path": f"raw_pdf/{doc_id}.pdf", "text_path": f"raw_text/{doc_id}.txt"})
+            except Exception as error:
+                results.append({**record, "error": f"{type(error).__name__}: {error}"})
+            if index % 100 == 0:
+                print(f"  {index}/{len(selection['selected_ids'])}", flush=True)
+    results.sort(key=lambda record: record["doc_id"])
+    acquisition = {
+        "observed_at": now(), "target": selection["selected"],
+        "acquired": sum("pdf_sha256" in record for record in results),
+        "failed": [record["doc_id"] for record in results if "error" in record],
+        "selected": results,
+    }
+    save(out / "acquisition.json", acquisition)
+    print(json.dumps({key: acquisition[key] for key in ("target", "acquired", "failed")},
+                     ensure_ascii=False, indent=2))
+
+
+def normalize(text):
+    import unicodedata
+    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   ]+", " ", line).strip() for line in text.splitlines()]
+    # drop repeated running-head signature lines and bare page numbers
+    seen_sygn = 0
+    kept = []
+    for line in lines:
+        if SYGN_RE.match(line):
+            seen_sygn += 1
+            if seen_sygn > 1:
+                continue
+        if PAGE_NUM_RE.match(line):
+            continue
+        kept.append(line)
+    text = "\n".join(kept)
+    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 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
+
+
+DF_FRACTION = 0.02  # shingles in >2% of docs are boilerplate (KIO formula openings)
+
+
+def shingle_document_frequencies(sketches):
+    df = Counter()
+    for sketch in sketches:
+        df.update(sketch)
+    return df
+
+
+def filter_sketch(sketch, df, max_df):
+    """Drop high document-frequency shingles (boilerplate) from a sketch."""
+    return {h for h in sketch if df[h] <= max_df}
+
+
+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 = ("uzp", "kio", "orzeczenia_uzp", "zamowienia_publiczne")
+    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):
+    """Compare our signatures/ids against the shipped SAOS shard (closest legal corpus)."""
+    import pyarrow.parquet as pq
+    from huggingface_hub import HfApi, HfFileSystem
+
+    revision = HfApi().dataset_info(TARGET).sha
+    remote = f"datasets/{TARGET}@{revision}/data/saos/saos.parquet"
+    try:
+        with HfFileSystem().open(remote, "rb") as handle:
+            table = pq.read_table(handle, columns=["id", "attribution"])
+        saos_rows = table.to_pylist()
+    except Exception as error:
+        saos_rows = []
+        print("saos shard unavailable:", error)
+    saos_sigs = set()
+    for row in saos_rows:
+        attribution = row.get("attribution") or ""
+        for sig in re.findall(r"[IVXLCDM]*\s*[A-Z][a-zA-Z]*\s*\d+/\d+", attribution):
+            saos_sigs.add(sig.strip().casefold())
+    manifest = read_lines(out / "source_manifest.jsonl")
+    results = []
+    for record in manifest:
+        sig = (record.get("signature") or "").strip()
+        if sig and sig.casefold() in saos_sigs:
+            results.append({"doc_id": record["doc_id"], "signature": sig, "kind": record["kind"]})
+    report = {
+        "target": f"{TARGET}:data/saos", "target_revision": revision,
+        "method": "case-normalized signature match against SAOS attribution strings",
+        "saos_rows": len(saos_rows), "candidate_records": len(manifest),
+        "signature_collisions": len(results),
+        "text_overlap": "not tested; target-wide text dedup remains an integration gate",
+        "observed_at": now(),
+        "colliding_ids": [r["doc_id"] for r in results],
+        "collisions": results[:500],
+    }
+    save(out / "overlap_audit.json", report)
+    print(json.dumps({key: report[key] for key in ("target_revision", "saos_rows",
+                                                    "candidate_records", "signature_collisions")},
+                     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
+
+    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"])
+    rows, attribution, decisions = [], [], []
+    exact_seen = {}
+    near = NearDuplicateIndex()
+
+    # pass 1: document frequencies of shingles, to drop boilerplate-heavy
+    # formulas (identical opening lines in ~every KIO ruling) from sketches.
+    df_sketches = []
+    for record in acquisition["selected"]:
+        if "error" in record:
+            continue
+        raw = (out / record["text_path"]).read_text(encoding="utf-8")
+        df_sketches.append((record["doc_id"], shingle_sketch(normalize(raw))))
+    df = shingle_document_frequencies(sketch for _, sketch in df_sketches)
+    max_df = max(1, int(len(df_sketches) * DF_FRACTION))
+    del df_sketches
+    print(f"df pass done: {len(df)} distinct shingles, max_df={max_df}", flush=True)
+    pii = Counter()
+    added = acquisition["observed_at"][:10]
+    for record in acquisition["selected"]:
+        row_id = f"{SOURCE}_{record['doc_id']}"
+        if "error" in record:
+            decisions.append({"id": row_id, "selected": False,
+                              "reason": "acquisition_failed", "error": record["error"]})
+            continue
+        pdf_path = out / record["pdf_path"]
+        text_path = out / record["text_path"]
+        if digest(pdf_path.read_bytes()) != record["pdf_sha256"]:
+            raise ValueError("PDF checksum mismatch: " + str(record["doc_id"]))
+        raw = text_path.read_text(encoding="utf-8")
+        text = normalize(raw)
+        replacement_count = text.count("\ufffd")
+        letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text))
+        language, votes = language_vote(identifier, text)
+        reason = ""
+        if len(text) < MIN_TEXT_CHARS:
+            reason = "too_little_extractable_text"
+        elif letters / max(len(text), 1) < 0.55:
+            reason = "low_letter_ratio"
+        elif replacement_count > 100 or replacement_count / max(len(text), 1) > 0.002:
+            reason = "excessive_replacement_characters"
+        elif language != "pl":
+            reason = "non_polish_text"
+        text = text.replace("\ufffd", "[UNREADABLE_GLYPH]")
+        text, counts = redact_pii(text)
+        pii.update(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 = filter_sketch(shingle_sketch(text), df, max_df)
+            if sketch:
+                duplicate_of, duplicate_score = near.find(sketch)
+                if duplicate_of:
+                    reason = "near_duplicate"
+        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.add(row_id, sketch)
+        details = record.get("details") or {}
+        organ = record.get("organ") or details.get("organ") or "Unknown"
+        created = iso_date(record.get("issued") or details.get("issued", ""))
+        row = {
+            "id": row_id, "text": text, "source": SOURCE, "added": added,
+            "created": created, "token_count": len(encoder.encode_ordinary(text)),
+            "license": LICENSE_LABEL, "author": organ,
+        }
+        rows.append(row)
+        attribution.append({
+            "id": row_id, "doc_id": record["doc_id"], "kind": record["kind"],
+            "organ": organ, "doc_type": record.get("doc_type") or details.get("doc_type", ""),
+            "signature": record.get("signature") or details.get("signature", ""),
+            "issued": record.get("issued") or details.get("issued", ""),
+            "chairman": details.get("chairman", ""), "purchaser": details.get("purchaser", ""),
+            "provisions": details.get("provisions", ""),
+            "landing_url": f"{BASE}/Home/Details/{record['doc_id']}",
+            "pdf_url": details.get("pdf_path_url", ""),
+            "pdf_sha256": record["pdf_sha256"], "pdf_bytes": record["pdf_bytes"],
+            "license": LICENSE_LABEL, "license_spdx": LICENSE_SPDX,
+            "legal_basis": LEGAL_BASIS,
+            "text_sha256": digest(text.encode("utf-8")),
+            "transformations": ["per-document PDF via /Home/PdfContent", "pypdf text extraction",
+                                "repeated signature running-head and page-number removal",
+                                "Unicode/whitespace normalization", "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)
+    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 = {
+        "reported_totals": selection["reported_totals"],
+        "enumerated": selection["enumerated"], "per_kind": selection["per_kind"],
+        "acquired": acquisition["acquired"], "failed": len(acquisition["failed"]),
+        "kept": len(rows), "rejected": len(decisions) - len(rows),
+        "rejection_reasons": dict(Counter(d["reason"] for d in decisions if not d["selected"])),
+        "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)),
+        "sample_count": len(sample), "added": added,
+    }
+    save(root / "artifacts/stats.json", stats)
+    qa = {
+        "scope": "all rulings enumerated via /Home/GetResults on orzeczenia.uzp.gov.pl (KIO/SO/SA/SN in public procurement matters)",
+        "license_gate": "official documents excluded from copyright under Polish Copyright Act art. 4(2); no per-record license field exists",
+        "language_gate": "three-window langid vote (pl/en/de/uk/ru)",
+        "pii_pattern_matches": dict(pii),
+        "exact_dedup": True,
+        "near_dedup": "deterministic prefix-indexed capped 5-word-shingle Jaccard >= 0.90 within source; high document-frequency shingles (>2% of docs, i.e. KIO opening-formula boilerplate) excluded from sketches",
+        "near_dedup_comparisons": near.comparisons,
+        "saos_overlap": overlap or "pending",
+        "cross_source_text_dedup": "pending target integration",
+        "limitations": [
+            "pypdf extraction may retain layout artifacts; tables may be flattened",
+            "pattern checks are not comprehensive de-identification; natural-person names of parties and adjudicators remain part of the official record",
+            "official-document status does not cover third-party material quoted inside rulings",
+            "sequential IDs contain gaps; enumeration follows the server-side result list, not the ID range",
+        ],
+    }
+    save(root / "artifacts/qa.json", qa)
+    protocol_id = "protocol:uzp-orzeczenia-v1"
+    run = {
+        "id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "selection": selection,
+                               "acquisition": digest(acquisition)}),
+        "protocol": protocol_id, "started_at": selection["observed_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({"manifest": selection["source_manifest_sha256"]})
+    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": "source_inventory_and_selection",
+         "artifact": "artifacts/selection.json", "content_address": digest(selection), "produced_by": run["id"]},
+        {"id": acquisition_evidence, "observation_type": "pdf_acquisition_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": "metadata_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:uzp-orzeczenia", "type": "Source"},
+                    {"id": "object:dataset:uzp-orzeczenia-pl", "type": "Dataset"}],
+        "versions": [{"id": source_version, "object": "object:source:uzp-orzeczenia",
+                      "content_address": source_version.rsplit(":", 1)[-1]},
+                     {"id": dataset_version, "object": "object:dataset:uzp-orzeczenia-pl",
+                      "content_address": dataset_version.rsplit(":", 1)[-1]}],
+        "protocols": [{"id": protocol_id,
+                       "procedure": "enumerate /Home/GetResults per kind; fetch /Home/Details metadata and /Home/PdfContent PDF; pypdf extraction; running-head/page-number removal; normalization; PII patterns; exact and near dedup"}],
+        "runs": [run], "evidence": evidence,
+        "claims": [
+            {"id": "claim:enumeration-complete",
+             "statement": f"The result-list enumeration observed {selection['enumerated']} documents across kinds {selection['per_kind']} matching server-reported totals {selection['reported_totals']}.",
+             "supported_by": [selection_evidence],
+             "falsification_condition": "The preserved manifest does not reproduce the counts or the server totals differ."},
+            {"id": "claim:official-documents",
+             "statement": "Retained records are official rulings of KIO, district courts, administrative courts and the Supreme Court in public procurement matters, excluded from copyright under Polish Copyright Act art. 4(2).",
+             "supported_by": [selection_evidence, qa_evidence],
+             "falsification_condition": "A retained record is shown to be a non-official or non-ruling document."},
+            {"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: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:uzp", "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": ["formal legal review of art. 4(2) application", "cross-source text deduplication",
+                    "benchmark contamination check", "third-party quoted material review",
+                    "controlled training ablation"],
+    }
+    save(root / "artifacts/ontology.json", ontology)
+    card = f"""---
+license: other
+language:
+- pl
+task_categories:
+- text-generation
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-00000-of-00001.parquet
+---
+
+# UZP Orzeczenia - Polish public-procurement rulings (KIO/SO/SA/SN)
+
+Polish-language rulings from the official decision search service of the Public
+Procurement Office (https://orzeczenia.uzp.gov.pl/): the National Appeals Chamber
+(KIO), district courts (SO), administrative courts (SA) and the Supreme Court
+(SN) in public procurement matters.
+
+- Enumerated documents: {stats['enumerated']:,} (per kind: {stats['per_kind']})
+- Acquired PDFs: {stats['acquired']:,} (failed: {stats['failed']})
+- Retained after text QA and within-source deduplication: {stats['kept']:,}
+- Characters: {stats['characters']:,}
+- Tokens: {stats['tokens']:,} (`cl100k_base` proxy)
+- License label: `{LICENSE_LABEL}`
+
+## Provenance and rights
+
+Rulings are official documents excluded from copyright under Polish Copyright
+Act art. 4(2) (LicenseRef-Polish-Official-Documents). No Creative Commons grant
+is asserted. Each row links to its `/Home/Details` landing URL, PDF URL and
+checksum; `artifacts/attribution.jsonl` carries organ, document type,
+signature, issue date, chairman, purchaser and key provisions per record.
+
+## Processing and limitations
+
+Text was extracted from the service PDFs with pypdf, then normalized:
+repeated signature running-heads and page numbers removed, Unicode/whitespace
+normalization, line-wrap repair, and limited email/phone/IP/identifier/account
+pattern redaction. Language is checked independently across three text windows;
+exact and deterministic near deduplication run within the source.
+
+Pattern checks are not comprehensive de-identification: names of parties,
+adjudicators and quoted natural persons remain part of the official record.
+PDF-derived text may retain layout artifacts and flattened tables.
+
+## 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 legal basis\n\n"
+        "Source: UZP decision search service, https://orzeczenia.uzp.gov.pl/ "
+        "(Urzad Zamowien Publicznych / Public Procurement Office).\n\n"
+        "Records are official rulings (KIO, district courts, administrative courts, Supreme Court) in public "
+        "procurement matters. Working basis: Polish Copyright Act art. 4(2) excludes official documents from "
+        "copyright; no per-record license field exists on the service. Formal legal review has not been performed. "
+        "Consult `artifacts/attribution.jsonl` for per-record provenance (organ, signature, issue date, URLs, checksums).\n\n"
+        "Preparation: Piotr Styla with Devin (Cognition). Changes: service-PDF text extraction, running-head and "
+        "page-number removal, Unicode/whitespace normalization, line-wrap repair, limited email/phone/IP/"
+        "identifier/account pattern redaction, language/quality filtering and within-source deduplication. "
+        "Names of parties and adjudicators remain as part of the official record. No endorsement by UZP, KIO "
+        "or the courts is implied.\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(stats, ensure_ascii=False, indent=2))
+
+
+def verify(out):
+    import pyarrow.parquet as pq
+    import tiktoken
+
+    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)
+    encoder = tiktoken.get_encoding("cl100k_base")
+    assert sum(row["token_count"] for row in rows) == stats["tokens"]
+    for row in rows:
+        assert len(encoder.encode_ordinary(row["text"])) == row["token_count"]
+    assert all(row["source"] == SOURCE and row["license"] == LICENSE_LABEL for row in rows)
+    assert all(EMAIL_RE.search(row["text"]) is None for row in rows)
+    assert all(len(row["text"]) >= MIN_TEXT_CHARS 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)
+    # reconstruct every retained text from the extracted source
+    for att in attribution:
+        doc_id = att["doc_id"]
+        raw = (out / "raw_text" / f"{doc_id}.txt").read_text(encoding="utf-8")
+        text = normalize(raw).replace("\ufffd", "[UNREADABLE_GLYPH]")
+        text, _ = redact_pii(text)
+        assert text == by_id[att["id"]]["text"], f"text mismatch: {doc_id}"
+        assert digest(text.encode("utf-8")) == att["text_sha256"]
+    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"]
+    # residual PII pattern scan
+    residual = {
+        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": IPV6_RE}.items()
+    }
+    report = {"verified": True, "residual_patterns": residual, **stats}
+    save(out / "validation_report.json", report)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+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, args.workers)
+    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/sources.py

@@ -15,6 +15,21 @@ intermediate aggregator, upstream license/attribution is preserved per source.
 # Large cultural/academic sources require per-record rights metadata and should
 # be rebuilt from direct upstream/export scripts rather than blind SpeakLeash pulls.
 SOURCES = {
+    "uzp_orzeczenia_pl": {
+        "added": "2026-09-17",
+        "release": None,
+        "file_key": "uzp_orzeczenia_pl",
+        "pretty": "UZP Orzeczenia - KIO/SO/SA/SN public-procurement rulings",
+        "license": "public-domain (official documents)",
+        "license_spdx": "LicenseRef-Polish-Official-Documents",
+        "traceable": "Every retained ruling links to its /Home/Details landing URL, PDF URL and sha256; organ, document type, signature, issue date, chairman, purchaser and key provisions are kept per record.",
+        "upstream": "https://orzeczenia.uzp.gov.pl/",
+        "provenance": "Enumerated deterministically via the service's kind-filtered /Home/GetResults pagination matching server-reported totals; per-document /Home/Details metadata and /Home/PdfContent PDFs fetched, extracted with pypdf, normalized, PII patterns redacted, language/quality filtered and within-source deduplicated. Polish Copyright Act art. 4(2): official documents are not subject to copyright; UZP search service republishes KIO/SO/SA/SN rulings in public procurement matters.",
+        "domain": "legal/judicial",
+        "created": "2009-2026",
+        "is_ocr": False,
+        "custom_datasheet": True,
+    },
     'rock_pollub_pl': {'file_key': 'rock_pollub_pl',
      'pretty': 'ROCK Politechnika Lubelska - Polish academic books',
      'license': 'CC-BY-SA-4.0',

src/test_build_uzp_orzeczenia_pl.py

@@ -0,0 +1,146 @@
+import importlib.util
+from pathlib import Path
+
+
+SCRIPT = Path(__file__).with_name("build_uzp_orzeczenia_pl.py")
+SPEC = importlib.util.spec_from_file_location("build_uzp_orzeczenia_pl", SCRIPT)
+MODULE = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(MODULE)
+
+
+def results_page(ids, counts="35694,34412,1277,3,2"):
+    items = "".join(
+        f'<div class="search-list-item">'
+        f'<label>Organ wydający:</label> Krajowa Izba Odwoławcza'
+        f'<p><label>Rodzaj dokumentu:</label> wyrok</p>'
+        f'<p><label>Sygnatura:</label> KIO {i}/26</p>'
+        f'<p><label>Data wydania:</label> 07-08-2026</p>'
+        f'<a class="link-details"  href="/Home/Details/{i}">Wyświetl szczegóły</a>'
+        f'</div>'
+        for i in ids)
+    return f'<input type="hidden" value="{counts}" id="resultCounts" />' + items
+
+
+def details_page(doc_id=36097, kind="KIO", signature="KIO 3640/26"):
+    return (
+        f'<html><body><label>Organ wydający</label> Krajowa Izba Odwoławcza'
+        f'<label>Rodzaj dokumentu</label> postanowienie'
+        f'<label>Data wydania rozstrzygnięcia</label> 07-08-2026'
+        f'<label>Przewodniczący</label> Jan Kowalski'
+        f'<label>Zamawiający</label> Szpital Miejski'
+        f'<label>Miejscowość</label> Warszawa'
+        f'<label>Sygnatura akt / Sposób rozstrzygnięcia</label> {signature} / umorzenie'
+        f'<label>Kluczowe przepisy ustawy Pzp</label> art. 568 pkt 2'
+        f'<a href="/Home/PdfContent/{doc_id}?Kind={kind}">Pobierz treść PDF</a>'
+        f'</body></html>')
+
+
+def test_parse_result_items_extracts_records_and_totals():
+    records, totals = MODULE.parse_result_items(results_page([36097, 36096, 36095]))
+    assert [r["doc_id"] for r in records] == [36097, 36096, 36095]
+    assert records[0]["organ"].startswith("Krajowa Izba")
+    assert records[0]["doc_type"] == "wyrok"
+    assert records[0]["signature"] == "KIO 36097/26"
+    assert records[0]["issued"] == "07-08-2026"
+    assert totals == [35694, 34412, 1277, 3, 2]
+
+
+def test_parse_counts_maps_kinds():
+    counts = MODULE.parse_counts(results_page([1]))
+    assert counts == {"ALL": 35694, "KIO": 34412, "SO": 1277, "SA": 3, "SN": 2}
+
+
+def test_parse_details_extracts_metadata_and_pdf_link():
+    details = MODULE.parse_details(details_page(), 36097)
+    assert details["doc_id"] == 36097
+    assert details["organ"] == "Krajowa Izba Odwoławcza"
+    assert details["chairman"] == "Jan Kowalski"
+    assert details["purchaser"] == "Szpital Miejski"
+    assert details["signature"] == "KIO 3640/26 / umorzenie"
+    assert details["pdf_path_url"] == "https://orzeczenia.uzp.gov.pl/Home/PdfContent/36097?Kind=KIO"
+    assert details["pdf_kind"] == "KIO"
+
+
+def test_parse_details_so_kind():
+    details = MODULE.parse_details(details_page(9036, "SO", "X Ga 286/13"), 9036)
+    assert details["pdf_path_url"].endswith("?Kind=SO")
+    assert details["pdf_kind"] == "SO"
+
+
+def test_iso_date_dd_mm_yyyy():
+    assert MODULE.iso_date("07-08-2026") == "2026-08-07"
+    assert MODULE.iso_date("03-10-2013") == "2013-10-03"
+    assert MODULE.iso_date("") == ""
+
+
+def test_normalize_drops_repeated_signature_and_page_numbers():
+    raw = "Sygn. akt KIO 1/26\nPierwszy akapit\n3\nSygn. akt KIO 1/26\nDrugi akapit"
+    out = MODULE.normalize(raw)
+    assert out.count("Sygn. akt") == 1
+    assert "\n3\n" not in "\n" + out + "\n"
+    assert "Pierwszy akapit" in out and "Drugi akapit" in out
+
+
+def test_normalize_repairs_line_wraps():
+    raw = "To jest dłu-\ngi wyraz\noraz kolejna\nlinia tekstu."
+    out = MODULE.normalize(raw)
+    assert "długi wyraz" in out
+    assert "oraz kolejna linia tekstu." in out
+
+
+def test_redact_pii_masks_patterns():
+    text = "Kontakt: jan@example.com tel. 601 234 567 PESEL 44051401458 " \
+           "rachunek 12 3456 7890 1234 5678 9012 3456 IP 10.0.0.1"
+    out, counts = MODULE.redact_pii(text)
+    assert "[REDACTED:EMAIL]" in out
+    assert "[REDACTED:PHONE]" in out
+    assert "[REDACTED:ID]" in out
+    assert "[REDACTED:ACCOUNT]" in out
+    assert "[REDACTED:IP]" in out
+    assert "jan@example.com" not in out
+    assert counts["email"] == 1 and counts["national_identifier"] == 1
+
+
+def test_redact_pii_compressed_ipv6():
+    out, counts = MODULE.redact_pii("adres ::1 oraz 2001:db8::ff00:42:8329 w tekście")
+    assert "[REDACTED:IP]" in out
+    assert counts["ipv6"] >= 1
+
+
+def test_filter_sketch_drops_boilerplate_shingles():
+    boiler = MODULE.shingle_sketch("Krajowa Izba Odwoławcza w składzie Przewodniczący")
+    own_a = MODULE.shingle_sketch("sygnatura sprawa alfa unikalna treść alfa")
+    own_b = MODULE.shingle_sketch("sygnatura sprawa beta unikalna treść beta")
+    df = MODULE.shingle_document_frequencies([boiler | own_a, boiler | own_b])
+    max_df = 1  # boiler appears in both docs -> df=2 > max_df
+    filtered = MODULE.filter_sketch(boiler | own_a, df, max_df)
+    assert filtered <= own_a
+    assert filtered == own_a
+
+
+def test_near_duplicate_index_matches_exhaustive():
+    base = " ".join(f"słowo{i}" for i in range(300))
+    near = MODULE.NearDuplicateIndex()
+    near.add("doc_a", MODULE.shingle_sketch(base))
+    hit, score = near.find(MODULE.shingle_sketch(base + " dodatkowy koniec"))
+    assert hit == "doc_a" and score >= 0.90
+    distinct = " ".join(f"inne{i}" for i in range(300))
+    assert near.find(MODULE.shingle_sketch(distinct)) == (None, 0.0)
+    # regression: index must agree with exhaustive pairwise comparison
+    sketches = {f"d{i}": MODULE.shingle_sketch(" ".join(f"x{i}w{j}" for j in range(200)))
+                for i in range(30)}
+    sketches["dup"] = MODULE.shingle_sketch(" ".join(f"x0w{j}" for j in range(200)))
+    index = MODULE.NearDuplicateIndex()
+    added = {}
+    for rid, sk in sketches.items():
+        other, score = index.find(sk)
+        expected = None
+        for oid, osk in added.items():
+            inter = len(sk & osk)
+            s = inter / max(len(sk) + len(osk) - inter, 1)
+            if s >= 0.90:
+                expected = oid
+                break
+        assert (other is not None) == (expected is not None), rid
+        index.add(rid, sk)
+        added[rid] = sk

src/uzp_orzeczenia_requirements.txt

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