sejm_api_2011_2022: relabel provenance, drop speeches contained in parliamentary / sejm_api (118,902 -> 32,460)

artifacts/source_findings.md

@@ -1798,3 +1798,52 @@ tokens, the profile pair 8,653).
 
 **Lesson:** an audit count ("3 quotes") is a lead, not a list. Reproduce it from the data before
 writing the filter, and say which drops are confirmed.
+
+## sejm_api_2011_2022 — provenance relabelled, cross-source dedup (2026-10-06)
+
+**Verdict** — held (`release: None`). 118,902 → 32,460 documents, 135,072,403 →
+30,766,807 tokens, 361,275,710 → 81,385,172 characters; parquet sha256
+`8fad4b4eab069fb8a652f9dc6a2e7dbc8f49d1e1b6bfae0decd2b318d160a20a`. Admission waits for
+the NERGAL pass (#60). Registry, card and NOTICE now say "Sejm API data via contributor
+snapshot" and that `source_url` is a day-level listing, not a per-speech URL.
+
+**Reason** — the source overlaps `parliamentary` (0.2.0) and `sejm_api` (0.2.5).
+`src/clean_sejm_api_2011_2022.py` drops a speech when one document of a pinned reference
+Parquet holds at least half of its 5-word shingles (containment >= 0.5; exact, no
+MinHash). 86,442 speeches (73%) are dropped, 86,272 of them dated 2011-2019. By
+reference set, with the maintainer's two #54 outcomes:
+
+| Reference set | Dropped |
+|---|---:|
+| `parliamentary` + `sejm_api` (this build) | 86,442 |
+| `parliamentary`, plenary / committee slice alone | 48,660 / 38,539 |
+| `sejm_api` alone (outcome A, `parliamentary` withdrawn) | 216 |
+| `sejm_api` + `parliamentary` without its committee slice (outcome B) | 48,833 |
+
+Per-speech scores are in `sejm_api_2011_2022.decisions.jsonl`. If #54 changes
+`parliamentary`, re-pin `REFERENCES` and rerun the script on the restored inputs.
+Hand check of 20 pairs at 0.3-0.7: 14 carry the speech's own wording in the reference
+(4 of 10 under 0.5, 10 of 10 from 0.5); the 6 that do not are dated 2020 or later.
+
+### Not established
+
+- Outcome B is the audit's `ppc_classify` heuristic, which is unvalidated: 10 of the 11
+  committee-labelled references in the hand-check sample are plenary sittings.
+- Containment is against single reference documents; the union of several is not scored.
+- No minimum size: 1,236 drops have under 10 shingles and 1,177 have 10-19. Of the 170
+  drops dated 2020 or later, 12 sampled at random were 9 stock phrases or stage
+  directions, 2 report templates and 1 real reuse, so about 100 may be false drops.
+  65 of the 170 have 50 or more shingles; two were read (reuse of earlier text), the
+  rest are unchecked. A minimum-shingles or date guard is the likely fix.
+- Agenda titles without a number ("Oświadczenia.") are not stripped from the snapshot
+  headers before scoring; numbered titles end correctly in 98.7% of 14,090 checked.
+- Whether the snapshot matches the live API (20-row spot check) and whether the
+  www.sejm.gov.pl terms reach API output; the API documents no licence.
+- `src/fetch_sejm_api_2011_2022.py` is unchanged because the ontology manifest pins its
+  hash; rebuilding with it brings back the old wording and the 118,902 rows.
+
+References: polish-dynaword-v2 #57, #54, #60; `rights_audit_2026-10/REVIEW.html`
+`#sejm_api_2011_2022`.
+
+**Lesson** — "contained in a released source" needs a size floor and a date check: a
+containment score of one stock sentence says nothing about reuse.

data/sejm_api_2011_2022/NOTICE.md

@@ -1,5 +1,6 @@
 # Source attribution
 
-Official materials: Kancelaria Sejmu RP, API Sejmu - https://api.sejm.gov.pl/.
+Official materials: Kancelaria Sejmu RP, API Sejmu - https://api.sejm.gov.pl/,
+obtained via the contributor snapshot `PiotrSty/sejm-speeches-corpus@v1.0.1`.
 
-Speech attribution and official source URLs are preserved in the attribution sidecar. Corpus preparation and contribution: Piotr Styła (PiotrSty / PiotrStyla).
+Speech attribution is preserved in `author`; the day-level source URL is in `sejm_api_2011_2022.attribution.jsonl`. Corpus preparation and contribution: Piotr Styła (PiotrSty / PiotrStyla).

data/sejm_api_2011_2022/sejm_api_2011_2022.attribution.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a1c1a309075b2fbc2a42f5313e22e93584434f4260e61d6e92d6cc488b0d9be5
-size 58294585
+oid sha256:5ce9a3c14e4860ac77f9b86c88bb001547d3b75f9793d2452279c680bf4094b4
+size 15892312

data/sejm_api_2011_2022/sejm_api_2011_2022.decisions.jsonl

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

data/sejm_api_2011_2022/sejm_api_2011_2022.md

@@ -11,7 +11,7 @@ from the already merged `sejm_api` 2023-onward artifact.
 - Domain: political/spoken
 - Language: Polish (`pl`)
 - License: `public-domain (official documents)`
-- Created: 2011-11-08 through 2022-12-14
+- Created: 2011-12-14 through 2022-12-14
 - Added: 2026-08-31
 - Contributor: Piotr Styła (`PiotrSty` on Hugging Face; `PiotrStyla` on GitHub)
 
@@ -21,18 +21,58 @@ from the already merged `sejm_api` 2023-onward artifact.
 - Pinned source commit: `124557799608ce4212cf22fa90ca7904618de1b6`
 - Pinned DynaWord base: `a9d134ac79a9fe586fc9c11cb39eb32d69dcd21f`
 - Rebuild: `python src/fetch_sejm_api_2011_2022.py --help`
-- Per-speech official URLs are preserved in `sejm_api_2011_2022.attribution.jsonl`
+- Data route: Sejm API data via contributor snapshot. The text comes from the
+  Hugging Face dataset `PiotrSty/sejm-speeches-corpus@v1.0.1`, not from the live
+  API; SlayerLab did not re-fetch it from api.sejm.gov.pl.
+- Each `source_url` in `sejm_api_2011_2022.attribution.jsonl` is a day-level
+  listing (`https://api.sejm.gov.pl/sejm/term{N}/videos/{date}`), not a per-speech URL.
+- Cross-source dedup: `python src/clean_sejm_api_2011_2022.py`, run on the pre-dedup
+  release files (the inputs and the references are pinned by SHA-256). Every dropped
+  or near-dropped speech is listed in `sejm_api_2011_2022.decisions.jsonl`.
 
 ## Existing-source overlap
 
-This PR intentionally does not claim temporal novelty. The 2011-2019 portion
-overlaps the date range of `parliamentary`, whose released records do not expose
-machine-readable author metadata. The 2015-2022 portion overlaps the registered
-`parlamint_pl` candidate range; at the pinned target commit no
-`data/parlamint_pl/*.parquet` artifact exists. The contribution is submitted as
-a speech-level, fully attributed, immutable-source-backed alternative so the
-maintainers can decide whether to merge it whole, cap it, or select only the
-currently missing years. Exact duplicates within this contribution are removed.
+The rights audit (slayerlabs/polish-dynaword-v2#57) found that this source
+re-publishes text already in `parliamentary` (released in 0.2.0). A speech is now
+dropped when one document of a pinned reference set holds at least half of its
+5-word shingles (containment >= 0.5 over NFKC-casefolded `\w+` tokens, the
+tokenisation of the repo's `near_dedup`, in `src/shingle_containment.py`; the
+sitting/agenda header lines that the snapshot interleaves with the speeches are
+stripped first). The reference set is every Parquet whose registry `release` is
+not `None`: `parliamentary` and `sejm_api`.
+`parlamint_pl` is no longer registered and has no data, so it is not a reference.
+Speeches under five words have no shingles and are kept (271).
+
+Speeches dropped, of 118,902, by reference set (a speech can match several slices):
+
+| Reference set | Dropped |
+|---|---:|
+| `parliamentary` + `sejm_api` (this build) | 86,442 |
+| `parliamentary`, all slices | 86,417 |
+| `parliamentary`, plenary slice alone | 48,660 |
+| `parliamentary`, committee slice alone | 38,539 |
+| `parliamentary`, interpellation question / reply / other alone | 190 / 47 / 143 |
+| `sejm_api` alone (outcome A: `parliamentary` withdrawn) | 216 |
+| `sejm_api` + `parliamentary` without its committee slice (outcome B) | 48,833 |
+
+Almost all overlap is 2011-2019: 86,272 of the 86,442 drops. Kept per year, 2011-2019:
+1, 10, 36, 36, 78, 187, 130, 78, 1,141; 2020-2022 are nearly intact (170 dropped).
+Another 899 speeches score 0.3-0.5 and are kept.
+
+If #54 changes `parliamentary`, the pinned reference set is out of date: re-pin
+`REFERENCES` in `src/clean_sejm_api_2011_2022.py` and rerun it on the restored inputs.
+The slice split is the audit's heuristic classifier (`ppc_classify.py`, unvalidated):
+its "committee" label also catches plenary sittings (10 of 11 committee-labelled
+references in a 20-pair hand check), so outcome B is the number that classifier gives,
+not a count of committee transcripts.
+
+Known limits: containment is measured against single reference documents, not a union;
+agenda titles without a number ("Oświadczenia.") are not stripped from the header text;
+and a threshold of 0.5 with no minimum size also drops short formulaic speeches. In a
+random 12 of the 170 drops dated 2020 or later, 9 were stage directions or stock phrases,
+2 were report templates (0.5-0.58) and 1 was real reuse. In a hand check of 20 pairs
+between 0.3 and 0.7, 14 had the speech's own wording in the reference (4 of 10 between
+0.3 and 0.5, 10 of 10 between 0.5 and 0.7); the 6 that did not are all dated 2020 or later.
 
 ## Statistics
 
@@ -42,10 +82,11 @@ currently missing years. Exact duplicates within this contribution are removed.
 | Rows after 2022-12-31 excluded | 38,812 |
 | Rows before 2011-01-01 excluded | 0 |
 | Exact duplicate texts removed | 0 |
-| Documents published | 118,902 |
-| Characters | 361,275,710 |
-| Tokens (`cl100k_base` proxy) | 135,072,403 |
-| Documents with speaker attribution | 118,902 |
+| Contained in `parliamentary` / `sejm_api` (containment >= 0.5) | 86,442 |
+| Documents published | 32,460 |
+| Characters | 81,385,172 |
+| Tokens (`cl100k_base` proxy) | 30,766,807 |
+| Documents with speaker attribution | 32,460 |
 
 The canonical schema is `id, text, source, added, created, token_count, license, author`.
 
@@ -74,6 +115,9 @@ Which cleaning ran, in order:
    release's QA covers the corpus; the review ask is answered precisely: min
    length + author + exact dedup + date window are the only gates here). **No
    further text rewriting** happens in this build — the projection maps fields.
+3. **Cross-source dedup** (`src/clean_sejm_api_2011_2022.py`, run on the output of
+   step 2): drops the 86,442 speeches contained (5-shingle containment >= 0.5) in a
+   `parliamentary` or `sejm_api` document; see "Existing-source overlap".
 
 Before/after at the text level is therefore a deliberate no-op (the pinned
 release preserves post-normalization text and a documented protocol; the raw

data/sejm_api_2011_2022/sejm_api_2011_2022.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:606d49ab55180341bffe5270e9c88797a95ff9f8441bf2de095d36f9d7a756c1
-size 128109040
+oid sha256:8fad4b4eab069fb8a652f9dc6a2e7dbc8f49d1e1b6bfae0decd2b318d160a20a
+size 29096259

data/sejm_api_2011_2022/sejm_api_2011_2022.stats.json

@@ -1,43 +1,100 @@
 {
   "added": "2026-08-31",
-  "authors_with_value": 118902,
+  "authors_with_value": 32460,
   "by_source_split": {
-    "train": 116546,
-    "validation": 2356
+    "train": 31822,
+    "validation": 638
   },
   "by_term": {
-    "7": 42114,
-    "8": 44750,
-    "9": 32038
+    "7": 118,
+    "8": 479,
+    "9": 31863
   },
   "by_year": {
-    "2011": 871,
-    "2012": 10732,
-    "2013": 11816,
-    "2014": 10480,
-    "2015": 10670,
-    "2016": 13763,
-    "2017": 12314,
-    "2018": 10206,
-    "2019": 7117,
-    "2020": 7667,
-    "2021": 10072,
-    "2022": 13194
+    "2011": 1,
+    "2012": 10,
+    "2013": 36,
+    "2014": 36,
+    "2015": 78,
+    "2016": 187,
+    "2017": 130,
+    "2018": 78,
+    "2019": 1141,
+    "2020": 7632,
+    "2021": 9997,
+    "2022": 13134
   },
-  "chars": 361275710,
+  "chars": 81385172,
   "created_max": "2022-12-14",
-  "created_min": "2011-11-08",
+  "created_min": "2011-12-14",
   "drop_after_end": 38812,
   "drop_before_start": 0,
   "drop_dup": 0,
-  "kept": 118902,
+  "kept": 32460,
   "license": "public-domain (official documents)",
   "licenses": {
-    "public-domain (official documents)": 118902
+    "public-domain (official documents)": 32460
   },
   "read": 157714,
   "source_revision": "124557799608ce4212cf22fa90ca7904618de1b6",
   "stats_recomputed_from_parquet": true,
   "target_base_revision": "a9d134ac79a9fe586fc9c11cb39eb32d69dcd21f",
-  "tokens": 135072403
+  "tokens": 30766807,
+  "drop_cross_source_dup": 86442,
+  "cross_source_dedup": {
+    "drop_at": 0.5,
+    "report_at": 0.3,
+    "shingle_words": 5,
+    "input_sha256": {
+      "sejm_api_2011_2022.parquet": "606d49ab55180341bffe5270e9c88797a95ff9f8441bf2de095d36f9d7a756c1",
+      "sejm_api_2011_2022.attribution.jsonl": "a1c1a309075b2fbc2a42f5313e22e93584434f4260e61d6e92d6cc488b0d9be5",
+      "sejm_api_2011_2022.stats.json": "398dbaff87ec8f1d8702fce347db65ae8a3e4cf69a90594a6c7998cc4441c356"
+    },
+    "reference_sha256": {
+      "parliamentary": "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8",
+      "sejm_api": "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161"
+    },
+    "no_shingles": 271,
+    "dropped_by_best_group": {
+      "parliamentary:committee": 38083,
+      "parliamentary:interp_question": 2,
+      "parliamentary:other": 52,
+      "parliamentary:plenary": 48270,
+      "sejm_api": 35
+    },
+    "dropped_by_year": {
+      "2011": 870,
+      "2012": 10722,
+      "2013": 11780,
+      "2014": 10444,
+      "2015": 10592,
+      "2016": 13576,
+      "2017": 12184,
+      "2018": 10128,
+      "2019": 5976,
+      "2020": 35,
+      "2021": 75,
+      "2022": 60
+    },
+    "dropped_by_shingles": {
+      "<10": 1236,
+      "10-19": 1177,
+      "20-49": 3153,
+      "50-199": 35360,
+      ">=200": 45516
+    },
+    "kept_partial": 899,
+    "outcomes": {
+      "all_references": 86442,
+      "sejm_api_only": 216,
+      "parliamentary_all": 86417,
+      "parliamentary_without_committee_plus_sejm_api": 48833,
+      "only_parliamentary_committee": 38539,
+      "only_parliamentary_interp_question": 190,
+      "only_parliamentary_interp_reply": 47,
+      "only_parliamentary_other": 143,
+      "only_parliamentary_plenary": 48660,
+      "only_sejm_api": 216
+    }
+  }
 }

src/clean_sejm_api_2011_2022.py

@@ -0,0 +1,349 @@
+#!/usr/bin/env python3
+"""Drop sejm_api_2011_2022 speeches already contained in a pinned reference set (slayerlabs/polish-dynaword-v2#57).
+
+The rights audit found that sejm_api_2011_2022 overlaps `parliamentary` (2011-2019) and the
+since-removed `parlamint_pl`. A speech is dropped when one document of the reference set holds at
+least DROP_AT of its shingles:
+
+  containment(speech, ref) = |S(speech) & S(ref)| / |S(speech)|
+
+S() is the set of 5-word shingles over NFKC-casefolded \\w+ tokens (the tokenisation of the repo's
+near_dedup, src/shingle_containment.py) of body(text), the speech without its sitting/agenda header.
+Containment is one-directional because a reference document can be a whole sitting while a speech
+is a few paragraphs. It is measured against single reference documents, not a union of them.
+
+The reference set is REFERENCES: every Parquet whose registry `release` is not None, each pinned by
+SHA-256. If slayerlabs/polish-dynaword-v2#54 changes `parliamentary` (withdraw it, or filter out its
+committee slice), re-pin REFERENCES and rerun this script on the restored input; nothing here
+follows the registry silently.
+
+Exact search: the speeches are indexed, the references are streamed. A speech is found when a
+reference shares at least one of its rarest (1 - REPORT_AT) * n + 1 shingles (prefix filter,
+exact by pigeonhole), and every such candidate is then scored on its full shingle sets. No
+MinHash/LSH, so there is no sampling error. Speeches scoring from REPORT_AT up are written to
+sejm_api_2011_2022.decisions.jsonl with the best score against each reference group, so the
+effect of each #54 outcome can be read without rerunning. Speeches under five words have no
+shingles and are never dropped.
+
+The inputs are the pre-dedup release files, pinned by SHA-256. Restore them before a rerun:
+  git checkout 3bab9f9 -- data/sejm_api_2011_2022/sejm_api_2011_2022.{parquet,attribution.jsonl,stats.json}
+  python3 src/clean_sejm_api_2011_2022.py
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import multiprocessing
+import os
+import re
+import tempfile
+from collections import Counter
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+from shingle_containment import shingles
+from sources import SOURCES
+
+SOURCE = "sejm_api_2011_2022"
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+# Pre-dedup release files (main at 3bab9f9); the ontology manifest records the same three.
+INPUT_SHA256 = {
+    f"{SOURCE}.parquet": "606d49ab55180341bffe5270e9c88797a95ff9f8441bf2de095d36f9d7a756c1",
+    f"{SOURCE}.attribution.jsonl": "a1c1a309075b2fbc2a42f5313e22e93584434f4260e61d6e92d6cc488b0d9be5",
+    f"{SOURCE}.stats.json": "398dbaff87ec8f1d8702fce347db65ae8a3e4cf69a90594a6c7998cc4441c356",
+}
+# Reference source -> (Parquet, SHA-256). Only sources with a registry release (checked in build()).
+# `parlamint_pl` left the registry in Hub PR 54 and never had data, so it cannot be pinned.
+REFERENCES = {
+    "parliamentary": (ROOT / "data/parliamentary/parliamentary.parquet",
+                      "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8"),
+    "sejm_api": (ROOT / "data/sejm_api/sejm_api.parquet",
+                 "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161"),
+}
+DECISIONS = f"{SOURCE}.decisions.jsonl"
+DROP_AT = 0.5
+REPORT_AT = 0.3
+ROW_GROUP_SIZE = 1024  # the layout of the released file
+SIZE_BUCKETS = (("<10", 0, 10), ("10-19", 10, 20), ("20-49", 20, 50), ("50-199", 50, 200), (">=200", 200, 10**9))
+
+_R = lambda pattern: re.compile(pattern, re.I)  # noqa: E731
+# The audit's heuristic split of `parliamentary` (artifacts/rights_audit_2026-10/official/ppc_classify.py,
+# unvalidated, v2#54). It only labels the report; the drop decision never uses it.
+PPC_COMMITTEE = _R(r'(Otwieram|Rozpoczynam|Witam)[^.\n]{0,160}(posiedzenie|posiedzeniu|Komisji)|posiedzenie (Komisji|Podkomisji)|^\(Początek posiedzenia|Posiedzeniu przewodniczy')
+PPC_PLENARY = _R(r'^\((Wznowienie|Początek|Ciąg dalszy|Przerwa)[^)]*\)\s*\n?\(?(Posiedzeniu przewodnicz|Na posiedzeniu przewodnicz)|Wysoka Izbo|Wysoki Sejmie|Wysoki Senacie')
+PPC_REPLY = _R(r'SPS-0\d\d|W odpowiedzi na (interpelacj|zapytani)|Odpowiadając na (interpelacj|zapytani)|odpowiedzi na (interpelacj|zapytani)|w związku z (interpelacj|zapytani)')
+PPC_QUESTION = _R(r'^(Szanown|Szanowni|Wielce Szanown|Panie Marszałku|Pani Marszałek|Panie Ministrze|Pani Minister|Panie Premierze|Pani Premier)|zwracam się (do Pana|do Pani)|interpelacj')
+
+
+# The Sejm API snapshot interleaves its speeches with metadata headers, "Przebieg posiedzenia <speaker>:
+# <term> kadencja, <n> posiedzenie, <d> dzien - <role> <speaker> ... (dd-mm-yyyy) <k> punkt porzadku
+# dziennego: <title>". Every speech of that speaker on that agenda item carries the same one, and the
+# PPC text has none, so left in they would make short speeches look contained in each other.
+# A title ends at its "(druk nr N)." citation, else at its first full stop; numbered items ("9. ...")
+# that follow belong to it. On the 14,090 mid-text headers whose title is known from another speech
+# this ends the title exactly 98.7% of the time (short 0.9%, long 0.4%).
+_SENTENCE = r"(?:.{0,800}?\(druki? nr [^)]{0,80}\)\.|.*?\.)(?=\s|\Z)"
+HEADER = re.compile(r"Przebieg posiedzenia .{0,500}?\(\d{2}-\d{2}-\d{4}\)"
+                    r"(?: \d[\d., i]{0,40} punkt porządku dziennego: " + _SENTENCE + r"(?:\s\d+\. " + _SENTENCE + r")*)?")
+
+
+def body(text: str) -> str:
+    """The speech without its sitting/agenda metadata headers."""
+    return HEADER.sub(" ", text) if "Przebieg posiedzenia " in text else text
+
+
+def ppc_slice(text: str) -> str:
+    head = text[:2500]
+    if PPC_COMMITTEE.search(head) and not PPC_REPLY.search(head):
+        return "committee"
+    if PPC_PLENARY.search(text[:4000]) and not PPC_REPLY.search(head):
+        return "plenary"
+    if PPC_REPLY.search(head):
+        return "interp_reply"
+    return "interp_question" if PPC_QUESTION.search(head) else "other"
+
+
+def group_of(source: str, text: str) -> str:
+    """Reference group a document is reported under: `parliamentary:<slice>` or the source key."""
+    return f"parliamentary:{ppc_slice(text)}" if source == "parliamentary" else source
+
+
+def min_shared(sizes: np.ndarray, at: float) -> np.ndarray:
+    """Fewest shared shingles that reach containment `at` (the epsilon guards 0.3 * 10 = 3.0000000000000004)."""
+    return np.ceil(at * sizes - 1e-9).astype(np.int64)
+
+
+def check_pin(path: Path, expected: str, restore: str) -> None:
+    with path.open("rb") as stream:
+        if hashlib.file_digest(stream, "sha256").hexdigest() != expected:
+            raise SystemExit(f"{path} does not match the pinned SHA-256; {restore}")
+
+
+# --- exact containment search -------------------------------------------------------------------
+
+_INDEX: dict[str, np.ndarray] = {}  # per-process, memory-mapped from the work directory
+
+
+def _load_index(work: str) -> None:
+    _INDEX.update({name: np.load(Path(work) / f"{name}.npy", mmap_mode="r")
+                   for name in ("prefix_hash", "prefix_doc", "flat", "offsets", "need")})
+
+
+def _shingle_chunk(texts: list[str]) -> list[np.ndarray]:
+    return [shingles(body(text)) for text in texts]
+
+
+def prefix_index(offsets: np.ndarray, flat: np.ndarray, need: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Sorted (hash, doc) pairs of each speech's rarest n - need + 1 shingles.
+
+    A reference sharing >= `need` of a speech's n shingles misses at most need - 1 of them, so it
+    must hold one of the n - need + 1 chosen; rarity (the count among speeches) only keeps the
+    posting lists short.
+    """
+    unique, counts = np.unique(flat, return_counts=True)
+    rarity = counts[np.searchsorted(unique, flat)]
+    hashes, docs = [], []
+    for doc in range(len(offsets) - 1):
+        lo, hi = offsets[doc], offsets[doc + 1]
+        if lo == hi:
+            continue
+        chosen = np.lexsort((flat[lo:hi], rarity[lo:hi]))[: hi - lo - need[doc] + 1]
+        hashes.append(flat[lo:hi][chosen])
+        docs.append(np.full(len(chosen), doc, np.int32))
+    hashes, docs = np.concatenate(hashes), np.concatenate(docs)
+    order = np.argsort(hashes, kind="stable")
+    return hashes[order], docs[order]
+
+
+def _keep_best(best: dict, key: tuple[int, str], shared: int, ref_id: str) -> None:
+    """Most shared shingles wins; a tie goes to the smaller reference id, so the result is order-independent."""
+    if key not in best or shared > best[key][0] or (shared == best[key][0] and ref_id < best[key][1]):
+        best[key] = (shared, ref_id)
+
+
+def _scan_row_group(task: tuple[str, str, int]) -> dict[tuple[int, str], tuple[int, str]]:
+    """Best (shared shingles, reference id) per (speech, group) over one row group of a reference."""
+    path, source, row_group = task
+    table = pq.ParquetFile(path).read_row_group(row_group, columns=["id", "text"])
+    prefix_hash, prefix_doc = _INDEX["prefix_hash"], _INDEX["prefix_doc"]
+    flat, offsets, need = _INDEX["flat"], _INDEX["offsets"], _INDEX["need"]
+    best: dict[tuple[int, str], tuple[int, str]] = {}
+    for ref_id, text in zip(table.column("id").to_pylist(), table.column("text").to_pylist(), strict=True):
+        ref = shingles(body(text))
+        lo = np.searchsorted(prefix_hash, ref, "left")
+        lens = np.searchsorted(prefix_hash, ref, "right") - lo
+        hits = int(lens.sum())
+        if not hits:
+            continue
+        group = group_of(source, text)
+        for doc in np.unique(prefix_doc[np.repeat(lo - np.cumsum(lens) + lens, lens) + np.arange(hits)]):
+            speech = flat[offsets[doc]:offsets[doc + 1]]
+            at = np.minimum(np.searchsorted(ref, speech), len(ref) - 1)
+            shared = int((ref[at] == speech).sum())
+            if shared >= need[doc]:
+                _keep_best(best, (int(doc), group), shared, ref_id)
+    return best
+
+
+def _map(fn, tasks: list, workers: int, work: str) -> list:
+    if workers == 1:
+        _load_index(work) if work else None
+        return [fn(task) for task in tasks]
+    context = multiprocessing.get_context("spawn")
+    with ProcessPoolExecutor(workers, mp_context=context, initializer=_load_index if work else None,
+                             initargs=(work,) if work else ()) as pool:
+        return list(pool.map(fn, tasks))
+
+
+def find_contained(texts: list[str], references: dict[str, Path], work: Path, workers: int,
+                   at: float = REPORT_AT) -> tuple[np.ndarray, dict[tuple[int, str], tuple[int, str]]]:
+    """Shingle-set sizes of `texts`, and for every (text, reference group) pair scoring >= `at`
+    the best (shared shingles, reference id). `references` maps a source key to its Parquet."""
+    chunks = [texts[i:i + 2048] for i in range(0, len(texts), 2048)]
+    sets = [s for chunk in _map(_shingle_chunk, chunks, workers, "") for s in chunk]
+    sizes = np.array([len(s) for s in sets], np.int64)
+    offsets = np.concatenate([[0], np.cumsum(sizes)]).astype(np.int64)
+    flat = np.concatenate(sets) if sets else np.empty(0, np.uint64)
+    need = min_shared(sizes, at)
+    prefix_hash, prefix_doc = prefix_index(offsets, flat, need)
+    for name, array in (("prefix_hash", prefix_hash), ("prefix_doc", prefix_doc), ("flat", flat),
+                        ("offsets", offsets), ("need", need)):
+        np.save(work / f"{name}.npy", array)
+    del sets, flat, prefix_hash, prefix_doc
+    tasks = [(str(path), source, row_group) for source, path in references.items()
+             for row_group in range(pq.ParquetFile(path).num_row_groups)]
+    merged: dict[tuple[int, str], tuple[int, str]] = {}
+    for part in _map(_scan_row_group, tasks, workers, str(work)):
+        for key, (shared, ref_id) in part.items():
+            _keep_best(merged, key, shared, ref_id)
+    return sizes, merged
+
+
+# --- build ---------------------------------------------------------------------------------------
+
+def score_table(sizes: np.ndarray, best: dict[tuple[int, str], tuple[int, str]], groups: list[str]) -> np.ndarray:
+    """(speeches x groups) containment matrix; 0 where a group scored below REPORT_AT."""
+    scores = np.zeros((len(sizes), len(groups)))
+    for (doc, group), (shared, _) in best.items():
+        scores[doc, groups.index(group)] = shared / sizes[doc]
+    return scores
+
+
+def outcomes(scores: np.ndarray, groups: list[str]) -> dict[str, int]:
+    """Speeches dropped (best score >= DROP_AT) for each reference set the maintainers may end up with."""
+    def dropped(wanted):
+        cols = [i for i, g in enumerate(groups) if wanted(g)]
+        return int((scores[:, cols].max(axis=1) >= DROP_AT).sum()) if cols else 0
+    return {
+        "all_references": dropped(lambda g: True),
+        "sejm_api_only": dropped(lambda g: g == "sejm_api"),
+        "parliamentary_all": dropped(lambda g: g.startswith("parliamentary:")),
+        "parliamentary_without_committee_plus_sejm_api": dropped(lambda g: g != "parliamentary:committee"),
+        **{f"only_{g.replace(':', '_')}": dropped(lambda x, g=g: x == g) for g in groups},
+    }
+
+
+def build(input_dir: Path, references: dict[str, tuple[Path, str]], out_dir: Path, workers: int,
+          check_registry: bool = True) -> dict:
+    for name, sha in INPUT_SHA256.items():
+        check_pin(input_dir / name, sha, f"restore it with `git checkout 3bab9f9 -- data/{SOURCE}/{name}`")
+    for source, (path, sha) in references.items():
+        check_pin(path, sha, f"it is not the pinned {source} Parquet; re-pin REFERENCES (see the docstring)")
+        if check_registry and SOURCES[source]["release"] is None:
+            raise SystemExit(f"{source} has no release in src/sources.py; it cannot be a reference")
+    table = pq.read_table(input_dir / f"{SOURCE}.parquet")
+    with tempfile.TemporaryDirectory() as work:
+        sizes, best = find_contained(table.column("text").to_pylist(), {s: p for s, (p, _) in references.items()},
+                                     Path(work), workers)
+    groups = sorted({group for _, group in best})
+    scores = score_table(sizes, best, groups)
+    top = scores.max(axis=1) if groups else np.zeros(len(sizes))
+    drop = top >= DROP_AT
+    kept = table.filter(pa.array(~drop))
+
+    ids, created = table.column("id").to_pylist(), table.column("created").to_pylist()
+    decisions = []
+    for doc in np.flatnonzero(top >= REPORT_AT):
+        group = groups[int(scores[doc].argmax())]
+        decisions.append({
+            "id": ids[doc], "created": created[doc], "action": "drop" if drop[doc] else "keep_partial",
+            "containment": round(float(top[doc]), 4), "ref_group": group, "ref_id": best[(int(doc), group)][1],
+            "shingles": int(sizes[doc]), "shared": best[(int(doc), group)][0],
+            "by_group": {g: round(float(scores[doc, i]), 4) for i, g in enumerate(groups) if scores[doc, i]}})
+    decisions.sort(key=lambda d: (-d["containment"], d["id"]))
+
+    kept_ids = set(kept.column("id").to_pylist())
+    sidecar_lines = []
+    with (input_dir / f"{SOURCE}.attribution.jsonl").open(encoding="utf-8") as stream:
+        for line in stream:
+            if json.loads(line)["id"] in kept_ids:
+                sidecar_lines.append(line)
+    if len(sidecar_lines) != kept.num_rows:
+        raise SystemExit("the attribution sidecar does not match the Parquet ids")
+    sidecar = [json.loads(line) for line in sidecar_lines]
+
+    stats = json.loads((input_dir / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+    if (pc.sum(pc.utf8_length(table.column("text"))).as_py(), pc.sum(table.column("token_count")).as_py(),
+            table.num_rows) != (stats["chars"], stats["tokens"], stats["kept"]):
+        raise SystemExit("the input stats.json does not describe the input Parquet")
+    kept_created = kept.column("created").to_pylist()
+    stats.update(
+        kept=kept.num_rows,
+        drop_cross_source_dup=int(drop.sum()),
+        chars=pc.sum(pc.utf8_length(kept.column("text"))).as_py(),
+        tokens=pc.sum(kept.column("token_count")).as_py(),
+        licenses=dict(sorted(Counter(kept.column("license").to_pylist()).items())),
+        authors_with_value=sum(map(bool, kept.column("author").to_pylist())),
+        created_min=min(kept_created), created_max=max(kept_created),
+        by_year=dict(sorted(Counter(c[:4] for c in kept_created).items())),
+        by_term=dict(sorted(Counter(row["term"] for row in sidecar).items())),
+        by_source_split=dict(sorted(Counter(row["source_split"] for row in sidecar).items())),
+        cross_source_dedup={
+            "drop_at": DROP_AT, "report_at": REPORT_AT, "shingle_words": 5,
+            "input_sha256": INPUT_SHA256,
+            "reference_sha256": {source: sha for source, (_, sha) in references.items()},
+            "no_shingles": int((sizes == 0).sum()),
+            "dropped_by_best_group": dict(sorted(Counter(d["ref_group"] for d in decisions if d["action"] == "drop").items())),
+            "dropped_by_year": dict(sorted(Counter(d["created"][:4] for d in decisions if d["action"] == "drop").items())),
+            "dropped_by_shingles": {label: sum(d["action"] == "drop" and lo <= d["shingles"] < hi for d in decisions)
+                                    for label, lo, hi in SIZE_BUCKETS},
+            "kept_partial": sum(d["action"] == "keep_partial" for d in decisions),
+            "outcomes": outcomes(scores, groups) if groups else {},
+        },
+    )
+    drops = ("drop_after_end", "drop_before_start", "drop_dup", "drop_cross_source_dup")
+    if stats["read"] - sum(stats[k] for k in drops) != stats["kept"]:
+        raise SystemExit("stats drop counts do not add up to the kept rows")
+
+    staged = {
+        out_dir / f"{SOURCE}.parquet.tmp": lambda p: pq.write_table(kept, p, compression="zstd", row_group_size=ROW_GROUP_SIZE),
+        out_dir / f"{SOURCE}.attribution.jsonl.tmp": lambda p: p.write_text("".join(sidecar_lines), encoding="utf-8"),
+        out_dir / f"{DECISIONS}.tmp": lambda p: p.write_text(
+            "".join(json.dumps(d, ensure_ascii=False) + "\n" for d in decisions), encoding="utf-8"),
+        out_dir / f"{SOURCE}.stats.json.tmp": lambda p: p.write_text(
+            json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"),
+    }
+    for path, write in staged.items():
+        write(path)
+    for path in staged:
+        os.replace(path, path.with_suffix(""))
+    return stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--data", type=Path, default=DATA, help="directory holding the (restored) input files; outputs are written there")
+    parser.add_argument("--workers", type=int, default=os.cpu_count() or 1)
+    args = parser.parse_args()
+    print(json.dumps(build(args.data, REFERENCES, args.data, args.workers), indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

src/sources.py

@@ -241,17 +241,24 @@ SOURCES = {
         "license_spdx": "LicenseRef-Polish-Official-Documents",
         "traceable": "Official parliamentary materials excluded from copyright under "
                      "Polish Copyright Act art. 4(2); reusable under the Polish Open Data "
-                     "Act arts. 2(12), 5, 6, 14(1), 15, 17. 100% speech-level official "
-                     "Sejm API URLs preserved in the attribution sidecar.",
+                     "Act arts. 2(12), 5, 6, 14(1), 15, 17. Every row has a day-level api.sejm.gov.pl "
+                     "/videos/ listing URL (not a per-speech URL) in the attribution sidecar.",
         "upstream": "https://api.sejm.gov.pl/",
-        "provenance": "Converted from the immutable PiotrSty/sejm-speeches-corpus@1245577 "
-                      "release (upstream protocol: heuristic PII redaction of e-mail/PESEL/"
-                      "phone, <50-word filter, exact dedup). This build applies the date "
-                      "window 2011-01-01..2022-12-31, >=200 chars + author, exact dedup. "
-                      "NERGAL not run - re-run through SlayerLab/NERGAL before release. "
-                      "Shared helpers factored into src/sejm_api_common.py.",
+        "provenance": "Sejm API data via contributor snapshot: text from the "
+                      "PiotrSty/sejm-speeches-corpus@1245577 Hugging Face release, not fetched "
+                      "from the live API by SlayerLab (upstream protocol: heuristic PII "
+                      "redaction of e-mail/PESEL/phone, <50-word filter, exact dedup). Speaker "
+                      "attribution preserved; source_url is a day-level api.sejm.gov.pl "
+                      "/videos/ listing, not a per-speech URL. This build applies the date "
+                      "window 2011-01-01..2022-12-31, >=200 chars + author, exact dedup, then "
+                      "src/clean_sejm_api_2011_2022.py drops speeches whose 5-shingle "
+                      "containment in one document of the pinned parliamentary / sejm_api "
+                      "Parquets is >= 0.5 (118,902 -> 32,460 docs; re-pin and rerun if "
+                      "polish-dynaword-v2#54 changes parliamentary). NERGAL not run - re-run "
+                      "through SlayerLab/NERGAL before release. Shared helpers factored into "
+                      "src/sejm_api_common.py.",
         "domain": "political/spoken",
-        "created": "2011-11-08, 2022-12-14",
+        "created": "2011-12-14, 2022-12-14",
         "is_ocr": False,
         "custom_datasheet": True,
     },

src/test_sejm_api_2011_2022_contract.py

@@ -4,13 +4,21 @@ import hashlib
 import json
 import pathlib
 import re
+import sys
 
+import pyarrow as pa
 import pyarrow.parquet as pq
+import pytest
 
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
+
+import clean_sejm_api_2011_2022 as clean
+from sources import SOURCES
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 DATA = ROOT / "data" / "sejm_api_2011_2022"
 MANIFEST = ROOT / "artifacts" / "sejm_api_2011_2022_ontology_manifest.json"
+DAY_LEVEL_URL = re.compile(r"https://api\.sejm\.gov\.pl/sejm/term\d+/videos/\d{4}-\d{2}-\d{2}")
 
 
 def sha256_file(path):
@@ -129,10 +137,209 @@ def test_manifest_artifact_checksums():
         item["payload"] for item in manifest["evidence"]
         if item["observation_type"] == "artifact_checksums"
     )
-    paths = {
-        "parquet_sha256": DATA / "sejm_api_2011_2022.parquet",
-        "attribution_sha256": DATA / "sejm_api_2011_2022.attribution.jsonl",
-        "stats_sha256": DATA / "sejm_api_2011_2022.stats.json",
-        "legal_evidence_sha256": DATA / "sejm_api_2011_2022.license-evidence.json",
-    }
-    assert {name: sha256_file(path) for name, path in paths.items()} == checksums
+    # The manifest describes the pre-dedup build that src/fetch_sejm_api_2011_2022.py wrote; the
+    # shipped files are those three after src/clean_sejm_api_2011_2022.py, which pins them.
+    pinned = clean.INPUT_SHA256
+    assert checksums["parquet_sha256"] == pinned["sejm_api_2011_2022.parquet"]
+    assert checksums["attribution_sha256"] == pinned["sejm_api_2011_2022.attribution.jsonl"]
+    assert checksums["stats_sha256"] == pinned["sejm_api_2011_2022.stats.json"]
+    assert checksums["legal_evidence_sha256"] == sha256_file(DATA / "sejm_api_2011_2022.license-evidence.json")
+
+
+# --- wording (v2#57) ---------------------------------------------------------------------------
+
+def test_registry_and_card_state_the_contributor_snapshot():
+    card = (DATA / "sejm_api_2011_2022.md").read_text(encoding="utf-8")
+    entry = SOURCES["sejm_api_2011_2022"]
+    for text in (entry["provenance"], entry["traceable"], card):
+        assert "speech-level" not in text
+        assert "Direct official" not in text
+    for text in (entry["provenance"], card):
+        assert "contributor snapshot" in text
+        assert "day-level" in text
+    assert entry["release"] is None  # admission waits for the NERGAL pass (v2#60)
+
+
+def test_every_source_url_is_a_day_level_listing():
+    with (DATA / "sejm_api_2011_2022.attribution.jsonl").open(encoding="utf-8") as stream:
+        urls = [json.loads(line)["source_url"] for line in stream]
+    assert urls
+    assert [url for url in urls if not DAY_LEVEL_URL.fullmatch(url)] == []
+
+
+# --- cross-source dedup (v2#57) ------------------------------------------------------------------
+
+def test_reference_pins_match_the_files_and_the_registry():
+    assert set(clean.REFERENCES) == {"parliamentary", "sejm_api"}
+    for source, (path, sha) in clean.REFERENCES.items():
+        clean.check_pin(path, sha, "")
+        assert SOURCES[source]["release"] is not None, f"{source} is not released, so it is not a reference"
+
+
+def test_shipped_files_follow_from_the_pinned_inputs():
+    stats = json.loads((DATA / "sejm_api_2011_2022.stats.json").read_text(encoding="utf-8"))
+    dedup = stats["cross_source_dedup"]
+    assert dedup["input_sha256"] == clean.INPUT_SHA256
+    assert dedup["reference_sha256"] == {source: sha for source, (_, sha) in clean.REFERENCES.items()}
+    assert (dedup["drop_at"], dedup["report_at"], dedup["shingle_words"]) == (clean.DROP_AT, clean.REPORT_AT, 5)
+    assert stats["read"] - sum(stats[k] for k in ("drop_after_end", "drop_before_start", "drop_dup", "drop_cross_source_dup")) == stats["kept"]
+    assert sum(dedup["dropped_by_best_group"].values()) == stats["drop_cross_source_dup"]
+    assert sum(dedup["dropped_by_year"].values()) == stats["drop_cross_source_dup"]
+    assert sum(dedup["dropped_by_shingles"].values()) == stats["drop_cross_source_dup"]
+    assert dedup["outcomes"]["all_references"] == stats["drop_cross_source_dup"]
+
+    table = pq.read_table(DATA / "sejm_api_2011_2022.parquet", columns=["id"])
+    kept_ids = set(table.column("id").to_pylist())
+    assert len(kept_ids) == stats["kept"]
+    decisions = [json.loads(line) for line in (DATA / clean.DECISIONS).open(encoding="utf-8")]
+    dropped = {d["id"] for d in decisions if d["action"] == "drop"}
+    partial = {d["id"] for d in decisions if d["action"] == "keep_partial"}
+    assert len(dropped) == stats["drop_cross_source_dup"] and not dropped & kept_ids
+    assert partial <= kept_ids and len(partial) == dedup["kept_partial"]
+    assert all(d["containment"] >= clean.DROP_AT for d in decisions if d["action"] == "drop")
+    assert all(clean.REPORT_AT <= d["containment"] < clean.DROP_AT for d in decisions if d["action"] == "keep_partial")
+    with (DATA / "sejm_api_2011_2022.attribution.jsonl").open(encoding="utf-8") as stream:
+        assert {json.loads(line)["id"] for line in stream} == kept_ids
+
+
+def test_pin_check_fails_closed_and_writes_nothing(tmp_path, monkeypatch):
+    (tmp_path / "x").write_bytes(b"x")
+    with pytest.raises(SystemExit, match="pinned SHA-256"):
+        clean.check_pin(tmp_path / "x", "0" * 64, "restore it")
+    for name in clean.INPUT_SHA256:  # inputs that are not the pinned release files
+        (tmp_path / name).write_bytes(b"not the release")
+    before = sorted(p.name for p in tmp_path.iterdir())
+    with pytest.raises(SystemExit, match="pinned SHA-256"):
+        clean.build(tmp_path, clean.REFERENCES, tmp_path, workers=1)
+    assert sorted(p.name for p in tmp_path.iterdir()) == before
+
+    # a reference that is not the pinned file stops the build as well, before any search
+    (tmp_path / "p").write_bytes(b"a")
+    monkeypatch.setattr(clean, "INPUT_SHA256", {name: hashlib.sha256(b"not the release").hexdigest() for name in clean.INPUT_SHA256})
+    with pytest.raises(SystemExit, match="not the pinned parliamentary"):
+        clean.build(tmp_path, {"parliamentary": (tmp_path / "p", "0" * 64)}, tmp_path, workers=1)
+
+
+WORDS = lambda tag, count: " ".join(f"{tag}{i}" for i in range(count))  # noqa: E731
+
+
+def _write_refs(tmp_path):
+    parliamentary, sejm_api = tmp_path / "parliamentary.parquet", tmp_path / "sejm_api.parquet"
+    pq.write_table(pa.table({"id": ["ref_p1", "ref_p2"], "text": [WORDS("w", 40), WORDS("z", 40)]}), parliamentary)
+    pq.write_table(pa.table({"id": ["ref_s1"], "text": [WORDS("s", 40)]}), sejm_api)
+    return {"parliamentary": parliamentary, "sejm_api": sejm_api}
+
+
+def test_synthetic_containment_boundaries_and_groups(tmp_path):
+    texts = [
+        WORDS("w", 20),                               # 0: all of it is in ref_p1 -> 1.0
+        WORDS("w", 8) + " " + WORDS("a", 6),          # 1: 4 of 10 shingles -> 0.4, reported, kept
+        WORDS("w", 8) + " " + WORDS("b", 4),          # 2: 4 of 8 shingles -> exactly 0.5, dropped
+        WORDS("q", 30),                               # 3: unrelated
+        "w0 w1 w2 w3",                                # 4: under five words, no shingles
+        WORDS("w", 20) + " " + WORDS("s", 20),        # 5: ref_p1 holds 16 of 36, ref_s1 holds 16 of 36
+        WORDS("s", 30),                               # 6: only in the sejm_api reference
+    ]
+    sizes, best = clean.find_contained(texts, _write_refs(tmp_path), tmp_path, workers=1)
+    assert sizes.tolist() == [16, 10, 8, 26, 0, 36, 26]
+    assert best[(0, "parliamentary:other")] == (16, "ref_p1")
+    assert best[(1, "parliamentary:other")] == (4, "ref_p1")
+    assert best[(2, "parliamentary:other")] == (4, "ref_p1")
+    assert best[(5, "parliamentary:other")] == (16, "ref_p1")
+    assert best[(5, "sejm_api")] == (16, "ref_s1")
+    assert best[(6, "sejm_api")] == (26, "ref_s1")
+    assert not {doc for doc, _ in best} & {3, 4}
+    groups = sorted({group for _, group in best})
+    scores = clean.score_table(sizes, best, groups)
+    assert scores[2].max() == 0.5 and scores[1].max() == 0.4
+    assert clean.outcomes(scores, groups)["all_references"] == 3  # docs 0, 2 and 6; doc 5 holds 16/36 = 0.44 per group
+    assert clean.outcomes(scores, groups)["sejm_api_only"] == 1   # doc 6
+
+
+def test_search_agrees_with_brute_force_and_ties_go_to_the_smaller_id(tmp_path):
+    from shingle_containment import shingles
+    refs = {"parliamentary": tmp_path / "parliamentary.parquet"}
+    ref_texts = {"ref_b": WORDS("w", 25), "ref_a": WORDS("w", 25), "ref_c": WORDS("w", 12) + " " + WORDS("k", 20)}
+    pq.write_table(pa.table({"id": list(ref_texts), "text": list(ref_texts.values())}), refs["parliamentary"],
+                   row_group_size=1)
+    texts = [WORDS("w", n) + " " + WORDS(f"n{n}_", m) for n, m in ((25, 0), (14, 6), (10, 10), (6, 12))]
+    sizes, best = clean.find_contained(texts, refs, tmp_path, workers=1)
+    for doc, text in enumerate(texts):
+        mine = set(shingles(text).tolist())
+        expected = {rid: len(mine & set(shingles(r).tolist())) for rid, r in ref_texts.items()}
+        top = max(expected.values())
+        if top >= clean.min_shared(sizes[doc:doc + 1], clean.REPORT_AT)[0]:
+            assert best[(doc, "parliamentary:other")] == (top, min(r for r, n in expected.items() if n == top))
+        else:
+            assert (doc, "parliamentary:other") not in best
+
+
+def test_header_stripping_keeps_headers_from_inflating_containment():
+    header = ("Przebieg posiedzenia Poseł Jan Kowalski: 9 kadencja, 3 posiedzenie, 1 dzień - Poseł Jan Kowalski "
+              "(12-01-2020) 5 punkt porządku dziennego: Sprawozdanie o projekcie ustawy (druk nr 12).")
+    speech = "Panie Marszałku Wysoka Izbo to jest jedno krótkie wystąpienie"
+    assert clean.body(f"{speech} {header}").split() == speech.split()
+    assert clean.body(f"{header} {speech}").split() == speech.split()
+    assert clean.body(speech) == speech
+    # a numbered item list belongs to the title; the speech after it does not
+    listed = ("Przebieg posiedzenia Poseł A: 9 kadencja (01-02-2021) 8. i 9. punkt porządku dziennego: "
+              "Sprawozdanie pierwsze (druk nr 1). 9. Sprawozdanie drugie (druk nr 2). Dobrze.   Panie marszałku, dziękuję.")
+    assert clean.body(listed).split() == "Dobrze. Panie marszałku, dziękuję.".split()
+    # two 12-word speeches that differ only in their (identical) header must not look alike
+    assert clean.body(f"{WORDS('a', 12)} {header}") != clean.body(f"{WORDS('b', 12)} {header}")
+
+
+def test_slice_labels_follow_the_audit_heuristic():
+    # Patterns copied verbatim from the audit's ppc_classify.py (unvalidated, v2#54); labels only, never a drop rule.
+    assert clean.ppc_slice("(Wznowienie posiedzenia o godz. 9)\n(Na posiedzeniu przewodniczą marszałek Sejmu)") == "plenary"
+    assert clean.ppc_slice("Otwieram posiedzenie Komisji Kultury") == "committee"
+    assert clean.ppc_slice("W odpowiedzi na interpelację nr 5") == "interp_reply"
+    assert clean.ppc_slice("Szanowny Panie Ministrze, zwracam się") == "interp_question"
+    assert clean.ppc_slice(WORDS("w", 10)) == "other"
+    assert clean.group_of("parliamentary", WORDS("w", 10)) == "parliamentary:other"
+    assert clean.group_of("sejm_api", "Otwieram posiedzenie Komisji") == "sejm_api"
+
+
+def _synthetic_release(directory, ids_texts):
+    """Pre-dedup release files for the given (id, text) pairs, and the SHA-256 pins that describe them."""
+    rows = [{"id": i, "text": t, "source": clean.SOURCE, "added": "2026-08-31", "created": f"2020-01-{n + 1:02d}",
+             "token_count": len(t.split()), "license": "public-domain (official documents)", "author": "Jan Kowalski"}
+            for n, (i, t) in enumerate(ids_texts)]
+    pq.write_table(pa.Table.from_pylist(rows), directory / f"{clean.SOURCE}.parquet", row_group_size=2)
+    (directory / f"{clean.SOURCE}.attribution.jsonl").write_text(
+        "".join(json.dumps({"id": r["id"], "term": 9, "source_split": "train", "source_url": "u"}) + "\n" for r in rows),
+        encoding="utf-8")
+    stats = {"read": len(rows) + 3, "drop_after_end": 3, "drop_before_start": 0, "drop_dup": 0, "kept": len(rows),
+             "chars": sum(len(r["text"]) for r in rows), "tokens": sum(r["token_count"] for r in rows)}
+    (directory / f"{clean.SOURCE}.stats.json").write_text(json.dumps(stats), encoding="utf-8")
+    return {name: hashlib.sha256((directory / name).read_bytes()).hexdigest() for name in clean.INPUT_SHA256}
+
+
+def test_synthetic_build_filters_every_output_consistently(tmp_path, monkeypatch):
+    (tmp_path / "refs").mkdir()
+    refs = _write_refs(tmp_path / "refs")
+    release = [("keep", WORDS("q", 30)), ("dup", WORDS("w", 20)), ("edge", WORDS("w", 8) + " " + WORDS("b", 4)),
+               ("part", WORDS("w", 8) + " " + WORDS("a", 6)), ("tiny", "w0 w1")]
+    monkeypatch.setattr(clean, "INPUT_SHA256", _synthetic_release(tmp_path, release))
+    references = {s: (p, hashlib.sha256(p.read_bytes()).hexdigest()) for s, p in refs.items()}
+    stats = clean.build(tmp_path, references, tmp_path, workers=1, check_registry=False)
+
+    assert pq.read_table(tmp_path / f"{clean.SOURCE}.parquet").column("id").to_pylist() == ["keep", "part", "tiny"]
+    assert [json.loads(line)["id"] for line in (tmp_path / f"{clean.SOURCE}.attribution.jsonl").open()] == ["keep", "part", "tiny"]
+    decisions = [json.loads(line) for line in (tmp_path / clean.DECISIONS).open()]
+    assert [(d["id"], d["action"], d["containment"], d["ref_id"]) for d in decisions] == [
+        ("dup", "drop", 1.0, "ref_p1"), ("edge", "drop", 0.5, "ref_p1"), ("part", "keep_partial", 0.4, "ref_p1")]
+    assert (stats["kept"], stats["drop_cross_source_dup"], stats["read"]) == (3, 2, 8)
+    assert stats["chars"] == sum(len(t) for i, t in release if i in ("keep", "part", "tiny"))
+    assert stats["cross_source_dedup"]["no_shingles"] == 1 and stats["cross_source_dedup"]["kept_partial"] == 1
+    assert stats["cross_source_dedup"]["outcomes"]["all_references"] == 2
+    assert not list(tmp_path.glob("*.tmp"))
+
+
+def test_build_refuses_an_unreleased_reference(tmp_path, monkeypatch):
+    (tmp_path / "refs").mkdir()
+    refs = _write_refs(tmp_path / "refs")
+    monkeypatch.setattr(clean, "INPUT_SHA256", _synthetic_release(tmp_path, [("a", WORDS("q", 30))]))
+    references = {"sejm_api_2011_2022": (refs["sejm_api"], hashlib.sha256(refs["sejm_api"].read_bytes()).hexdigest())}
+    with pytest.raises(SystemExit, match="no release"):
+        clean.build(tmp_path, references, tmp_path, workers=1)