sejm_api_2011_2022: cut the "Przebieg posiedzenia" trailers before the cross-source dedup (v0.2.6, v2#57)

Hub PR 76 stripped the headers only from the shingled text; the published rows kept them,
with any appended statement inside its parent. clean_sejm_api_2011_2022.py now runs
sejm_api_common.split_release_rows (as clean_sejm_api.py does) on the pinned pre-dedup
inputs before the containment search, re-pins the sejm_api reference to its post-cut
Parquet, and drops the local header stripper. 105,920 rows cut, 15,648 statements split
out, 7,563 rows under 200 chars and 20 new duplicates dropped; 93,861 contained.
32,460 -> 33,106 documents, 30,766,807 -> 26,112,679 tokens.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

artifacts/source_findings.md

@@ -2253,3 +2253,27 @@ existing `sejm_api` registry entry that meets the contract instead of failing.
 
 **Lesson** — check a scraped snapshot for navigation text glued to the record: a trailer
 in 90% of rows hid in plain sight because each row still began with the right speech.
+
+## sejm_api_2011_2022 — trailers cut before the cross-source dedup (2026-10-06)
+
+**Finding** (slayerlabs/polish-dynaword-v2#57) — the same "Przebieg posiedzenia" trailers
+as in `sejm_api` (section above) are in 105,920 of the 118,902 pre-dedup speeches:
+97,723,744 characters. Hub PR 76 only stripped them from the shingled text when it scored
+containment; the published rows kept them.
+
+**Fix** — `src/clean_sejm_api_2011_2022.py` now runs `sejm_api_common.split_release_rows`
+on the pinned pre-dedup inputs before the containment search, so the published rows lose
+their trailers and each appended statement is scored and published on its own (15,648
+split rows; 5,374 cut speeches and 2,189 split rows under 200 characters and 20 new exact
+duplicates dropped; 126,967 rows enter the search). The `sejm_api` reference is re-pinned
+to its own post-cut Parquet (`ba2daa20…`). Header stripping in the shingler is gone: after
+the cut no header is left in the inputs or the references. 118,902 → 33,106 documents
+(Hub PR 76: 32,460), 135,072,403 → 26,112,679 tokens (30,766,807), 93,861 rows contained
+(86,442), 93,784 of them dated 2011-2019. Of the 32,460 rows Hub PR 76 kept, 1,882 fall
+under 200 characters once their trailer is cut (504 of them dated 2011-2019), 4 now reach
+0.5 and 5 drop below it; 2,527 split rows are added, 180 of them from a speech that is
+itself dropped. Kept 2011-2019 rows go from 1,697 to 1,281. Parquet sha256
+`622228ca4c287f91792b7da3fb97c098610c1cf890f1bdc08922dc3aca3742db`.
+
+**Not established** — the card's hand checks (12 of the post-2019 drops, 20 pairs at
+0.3-0.7) were made on the Hub PR 76 build and were not repeated.

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:5ce9a3c14e4860ac77f9b86c88bb001547d3b75f9793d2452279c680bf4094b4
-size 15892312
+oid sha256:bb45cbd376de47a0244a661ac9eddf8a06a56ac37d048d5bcb00555c61dba72c
+size 16449002

data/sejm_api_2011_2022/sejm_api_2011_2022.decisions.jsonl

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

data/sejm_api_2011_2022/sejm_api_2011_2022.md

@@ -26,9 +26,28 @@ from the already merged `sejm_api` 2023-onward artifact.
   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`.
+- Trailer cut and 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 row is listed in `sejm_api_2011_2022.decisions.jsonl`.
+
+## Trailer cut
+
+The rights audit (slayerlabs/polish-dynaword-v2#57) found that the snapshot
+appends to 105,920 of the 118,902 speeches a "Przebieg posiedzenia" header of a
+later statement of the same sitting day, and sometimes that statement's text.
+`src/clean_sejm_api_2011_2022.py` cuts every trailer (97,723,744 characters) with
+the code `src/clean_sejm_api.py` uses for `sejm_api` (`sejm_api_common.split_release_rows`).
+An appended statement with text becomes a row of its own (15,648 rows), credited to
+the speaker the header names ("Przebieg posiedzenia Jan Kowalski: …"), without the
+office in its label. Its date and term are those of the row it was cut from. A split row's id
+hashes its date, term, speaker and text like every other row; its sidecar line
+carries `split_from` (the id of the row it was cut from in the pre-dedup input of
+Hub PR 18) and `has_events: null`, since the snapshot's events flag describes the
+whole parent row. Rows that fall under the fetch's 200-character minimum after the
+cut (5,374 cut speeches and 2,189 split rows) and 20 texts that became exact
+duplicates are dropped. The cut runs before the containment search, so a speech is
+scored on its own words and an appended statement on its own; 2,527 split rows are
+published, 180 of them cut from a speech that is itself dropped as contained.
 
 ## Existing-source overlap
 
@@ -37,27 +56,28 @@ re-publishes text already in `parliamentary` (released in 0.2.0). A speech is no
 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`.
+trailers are cut first, see "Trailer cut"). The reference set is every Parquet whose
+registry `release` is not `None`: `parliamentary` and `sejm_api` (after its own
+trailer cut).
 `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).
+Rows under five words have no shingles and are kept (none in this build).
 
-Speeches dropped, of 118,902, by reference set (a speech can match several slices):
+Rows dropped, of 126,967 after the trailer cut, by reference set (a row 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.
+| `parliamentary` + `sejm_api` (this build) | 93,861 |
+| `parliamentary`, all slices | 93,844 |
+| `parliamentary`, plenary slice alone | 53,904 |
+| `parliamentary`, committee slice alone | 40,429 |
+| `parliamentary`, interpellation question / reply / other alone | 244 / 17 / 107 |
+| `sejm_api` alone (outcome A: `parliamentary` withdrawn) | 45 |
+| `sejm_api` + `parliamentary` without its committee slice (outcome B) | 54,081 |
+
+Almost all overlap is 2011-2019: 93,784 of the 93,861 drops. Kept per year, 2011-2019:
+2, 5, 5, 5, 23, 50, 29, 32, 1,130; 2020-2022 are nearly intact (77 dropped).
+Another 639 rows 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.
@@ -66,13 +86,14 @@ 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.
+Known limits: containment is measured against single reference documents, not a union,
+and a threshold of 0.5 with no minimum size also drops short formulaic speeches. The
+hand checks that follow were made on the build before the trailer cut (Hub PR 76),
+which had 170 drops dated 2020 or later, against 77 now. In a random 12 of those 170,
+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
 
@@ -81,12 +102,14 @@ between 0.3 and 0.7, 14 had the speech's own wording in the reference (4 of 10 b
 | Source rows inspected | 157,714 |
 | Rows after 2022-12-31 excluded | 38,812 |
 | Rows before 2011-01-01 excluded | 0 |
-| Exact duplicate texts removed | 0 |
-| 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 |
+| Statements split into rows of their own | 15,648 |
+| Rows under 200 characters after the trailer cut | 7,563 |
+| Exact duplicate texts removed | 20 |
+| Contained in `parliamentary` / `sejm_api` (containment >= 0.5) | 93,861 |
+| Documents published | 33,106 |
+| Characters | 70,230,096 |
+| Tokens (`cl100k_base` proxy) | 26,112,679 |
+| Documents with speaker attribution | 33,106 |
 
 The canonical schema is `id, text, source, added, created, token_count, license, author`.
 
@@ -115,11 +138,13 @@ 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".
+3. **Trailer cut and cross-source dedup** (`src/clean_sejm_api_2011_2022.py`, run on
+   the output of step 2): cuts the "Przebieg posiedzenia" trailers and splits the
+   appended statements into rows of their own (see "Trailer cut"), then drops the
+   93,861 rows 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
+Apart from the trailer cut, before/after at the text level is a deliberate no-op (the pinned
 release preserves post-normalization text and a documented protocol; the raw
 stenogram pages are not pinned and drift on sejm.gov.pl), so the concrete
 before/after evidence is the redaction record above (the one e-mail replaced

data/sejm_api_2011_2022/sejm_api_2011_2022.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8fad4b4eab069fb8a652f9dc6a2e7dbc8f49d1e1b6bfae0decd2b318d160a20a
-size 29096259
+oid sha256:622228ca4c287f91792b7da3fb97c098610c1cf890f1bdc08922dc3aca3742db
+size 28185916

data/sejm_api_2011_2022/sejm_api_2011_2022.stats.json

@@ -1,46 +1,55 @@
 {
   "added": "2026-08-31",
-  "authors_with_value": 32460,
+  "authors_with_value": 33106,
   "by_source_split": {
-    "train": 31822,
-    "validation": 638
+    "train": 32454,
+    "validation": 652
   },
   "by_term": {
-    "7": 118,
-    "8": 479,
-    "9": 31863
+    "7": 21,
+    "8": 157,
+    "9": 32928
   },
   "by_year": {
-    "2011": 1,
-    "2012": 10,
-    "2013": 36,
-    "2014": 36,
-    "2015": 78,
-    "2016": 187,
-    "2017": 130,
-    "2018": 78,
-    "2019": 1141,
-    "2020": 7632,
-    "2021": 9997,
-    "2022": 13134
+    "2011": 2,
+    "2012": 5,
+    "2013": 5,
+    "2014": 5,
+    "2015": 23,
+    "2016": 50,
+    "2017": 29,
+    "2018": 32,
+    "2019": 1130,
+    "2020": 7937,
+    "2021": 10239,
+    "2022": 13649
   },
-  "chars": 81385172,
+  "chars": 70230096,
   "created_max": "2022-12-14",
   "created_min": "2011-12-14",
   "drop_after_end": 38812,
   "drop_before_start": 0,
-  "drop_dup": 0,
-  "kept": 32460,
+  "drop_dup": 20,
+  "kept": 33106,
   "license": "public-domain (official documents)",
   "licenses": {
-    "public-domain (official documents)": 32460
+    "public-domain (official documents)": 33106
   },
   "read": 157714,
   "source_revision": "124557799608ce4212cf22fa90ca7904618de1b6",
   "stats_recomputed_from_parquet": true,
   "target_base_revision": "a9d134ac79a9fe586fc9c11cb39eb32d69dcd21f",
-  "tokens": 30766807,
-  "drop_cross_source_dup": 86442,
+  "tokens": 26112679,
+  "split_rows": 15648,
+  "drop_short": 7563,
+  "trailer_cut": {
+    "rows_cut": 105920,
+    "chars_cut": 97723744,
+    "split_rows": 15648,
+    "drop_short": 7563,
+    "drop_dup": 20
+  },
+  "drop_cross_source_dup": 93861,
   "cross_source_dedup": {
     "drop_at": 0.5,
     "report_at": 0.3,
@@ -52,49 +61,49 @@
     },
     "reference_sha256": {
       "parliamentary": "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8",
-      "sejm_api": "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161"
+      "sejm_api": "ba2daa20d2d2753c09e8bdd477839f43c82170f44caeadc634cb2295362c9c3b"
     },
-    "no_shingles": 271,
+    "no_shingles": 0,
     "dropped_by_best_group": {
-      "parliamentary:committee": 38083,
+      "parliamentary:committee": 40095,
       "parliamentary:interp_question": 2,
-      "parliamentary:other": 52,
-      "parliamentary:plenary": 48270,
-      "sejm_api": 35
+      "parliamentary:other": 61,
+      "parliamentary:plenary": 53683,
+      "sejm_api": 20
     },
     "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
+      "2011": 995,
+      "2012": 12577,
+      "2013": 12950,
+      "2014": 11402,
+      "2015": 11497,
+      "2016": 14176,
+      "2017": 12784,
+      "2018": 10876,
+      "2019": 6527,
+      "2020": 12,
+      "2021": 37,
+      "2022": 28
     },
     "dropped_by_shingles": {
-      "<10": 1236,
-      "10-19": 1177,
-      "20-49": 3153,
-      "50-199": 35360,
-      ">=200": 45516
+      "<10": 0,
+      "10-19": 5,
+      "20-49": 3910,
+      "50-199": 42880,
+      ">=200": 47066
     },
-    "kept_partial": 899,
+    "kept_partial": 639,
     "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
+      "all_references": 93861,
+      "sejm_api_only": 45,
+      "parliamentary_all": 93844,
+      "parliamentary_without_committee_plus_sejm_api": 54081,
+      "only_parliamentary_committee": 40429,
+      "only_parliamentary_interp_question": 244,
+      "only_parliamentary_interp_reply": 17,
+      "only_parliamentary_other": 107,
+      "only_parliamentary_plenary": 53904,
+      "only_sejm_api": 45
     }
   }
 }

src/clean_sejm_api_2011_2022.py

@@ -8,9 +8,12 @@ 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.
+near_dedup, src/shingle_containment.py). The "Przebieg posiedzenia" trailers that the snapshot appends
+to most speeches are cut first, and each appended statement becomes a row of its own
+(sejm_api_common.split_release_rows, as in src/clean_sejm_api.py), so a speech is scored on its own
+words and an appended statement on its own. 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
@@ -32,7 +35,6 @@ The inputs are the pre-dedup release files, pinned by SHA-256. Restore them befo
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import multiprocessing
 import os
@@ -44,9 +46,10 @@ from pathlib import Path
 
 import numpy as np
 import pyarrow as pa
-import pyarrow.compute as pc
 import pyarrow.parquet as pq
+import tiktoken
 
+from sejm_api_common import check_pin, release_stats, replace_all, split_release_rows
 from shingle_containment import shingles
 from sources import SOURCES
 
@@ -64,8 +67,8 @@ INPUT_SHA256 = {
 REFERENCES = {
     "parliamentary": (ROOT / "data/parliamentary/parliamentary.parquet",
                       "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8"),
-    "sejm_api": (ROOT / "data/sejm_api/sejm_api.parquet",
-                 "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161"),
+    "sejm_api": (ROOT / "data/sejm_api/sejm_api.parquet",  # after src/clean_sejm_api.py
+                 "ba2daa20d2d2753c09e8bdd477839f43c82170f44caeadc634cb2295362c9c3b"),
 }
 DECISIONS = f"{SOURCE}.decisions.jsonl"
 DROP_AT = 0.5
@@ -82,23 +85,6 @@ PPC_REPLY = _R(r'SPS-0\d\d|W odpowiedzi na (interpelacj|zapytani)|Odpowiadając
 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):
@@ -120,12 +106,6 @@ def min_shared(sizes: np.ndarray, at: float) -> np.ndarray:
     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
@@ -137,7 +117,7 @@ def _load_index(work: str) -> None:
 
 
 def _shingle_chunk(texts: list[str]) -> list[np.ndarray]:
-    return [shingles(body(text)) for text in texts]
+    return [shingles(text) for text in texts]
 
 
 def prefix_index(offsets: np.ndarray, flat: np.ndarray, need: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
@@ -176,7 +156,7 @@ def _scan_row_group(task: tuple[str, str, int]) -> dict[tuple[int, str], tuple[i
     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))
+        ref = shingles(text)
         lo = np.searchsorted(prefix_hash, ref, "left")
         lens = np.searchsorted(prefix_hash, ref, "right") - lo
         hits = int(lens.sum())
@@ -259,81 +239,67 @@ def build(input_dir: Path, references: dict[str, tuple[Path, str]], out_dir: Pat
         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 (input_dir / f"{SOURCE}.attribution.jsonl").open(encoding="utf-8") as stream:
+        sidecar = [json.loads(line) for line in stream]
+    stats = json.loads((input_dir / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+    rows = table.to_pylist()
+    recomputed = release_stats(rows, sidecar)
+    if recomputed != {key: stats.get(key) for key in recomputed}:
+        raise SystemExit("the input stats.json does not describe the input Parquet")
+
+    rows, sidecar, cut = split_release_rows(rows, sidecar, tiktoken.get_encoding("cl100k_base"))
     with tempfile.TemporaryDirectory() as work:
-        sizes, best = find_contained(table.column("text").to_pylist(), {s: p for s, (p, _) in references.items()},
+        sizes, best = find_contained([row["text"] for row in rows], {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",
+            "id": rows[doc]["id"], "created": rows[doc]["created"], "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"]:
+    kept_rows = [row for row, dropped in zip(rows, drop) if not dropped]
+    kept_sidecar = [line for line, dropped in zip(sidecar, drop) if not dropped]
+
+    stats.update(release_stats(kept_rows, kept_sidecar))
+    stats["split_rows"] = cut["split_rows"]
+    stats["drop_short"] = cut["drop_short"]
+    stats["drop_dup"] += cut["drop_dup"]
+    stats["trailer_cut"] = dict(cut)
+    stats["drop_cross_source_dup"] = int(drop.sum())
+    stats["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_short", "drop_cross_source_dup")
+    if stats["read"] + stats["split_rows"] - 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(
+    replace_all({
+        out_dir / f"{SOURCE}.parquet": lambda p: pq.write_table(
+            pa.Table.from_pylist(kept_rows, schema=table.schema), p, compression="zstd", row_group_size=ROW_GROUP_SIZE),
+        out_dir / f"{SOURCE}.attribution.jsonl": lambda p: p.write_text(
+            "".join(json.dumps(line, ensure_ascii=False, sort_keys=True) + "\n" for line in kept_sidecar), encoding="utf-8"),
+        out_dir / DECISIONS: 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(
+        out_dir / f"{SOURCE}.stats.json": 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
 
 

src/sources.py

@@ -286,10 +286,12 @@ SOURCES = {
                       "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 "
+                      "src/clean_sejm_api_2011_2022.py cuts the \"Przebieg posiedzenia\" "
+                      "trailers (appended statements become rows of their own) and drops rows "
+                      "whose 5-shingle containment in one document of the pinned "
+                      "parliamentary / sejm_api Parquets is >= 0.5 (118,902 -> 33,106 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",

src/test_sejm_api_2011_2022_contract.py

@@ -13,7 +13,9 @@ import pytest
 sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
 
 import clean_sejm_api_2011_2022 as clean
+from sejm_api_common import TRAILER, TRUNCATED_TRAILER, release_stats
 from sources import SOURCES
+from test_sejm_api_contract import header
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 DATA = ROOT / "data" / "sejm_api_2011_2022"
@@ -182,7 +184,9 @@ def test_shipped_files_follow_from_the_pinned_inputs():
     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"]
+    drops = ("drop_after_end", "drop_before_start", "drop_dup", "drop_short", "drop_cross_source_dup")
+    assert stats["read"] + stats["split_rows"] - sum(stats[k] for k in drops) == stats["kept"]
+    assert stats["trailer_cut"]["split_rows"] == stats["split_rows"] and stats["trailer_cut"]["drop_short"] == stats["drop_short"]
     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"]
@@ -202,6 +206,25 @@ def test_shipped_files_follow_from_the_pinned_inputs():
         assert {json.loads(line)["id"] for line in stream} == kept_ids
 
 
+def test_no_trailer_is_left_and_split_rows_are_marked():
+    rows = pq.read_table(DATA / "sejm_api_2011_2022.parquet").to_pylist()
+    with (DATA / "sejm_api_2011_2022.attribution.jsonl").open(encoding="utf-8") as stream:
+        sidecar = [json.loads(line) for line in stream]
+    stats = json.loads((DATA / "sejm_api_2011_2022.stats.json").read_text(encoding="utf-8"))
+    assert [row["id"] for row in rows if TRAILER.search(row["text"]) or TRUNCATED_TRAILER.search(row["text"])] == []
+    assert [row["id"] for row in rows] == [line["id"] for line in sidecar]
+    assert len({row["text"] for row in rows}) == len(rows)
+    assert all(row["author"] == line["speaker"] and line["char_count"] == len(row["text"])
+               for row, line in zip(rows, sidecar))
+    recomputed = release_stats(rows, sidecar)
+    assert {key: stats[key] for key in recomputed} == recomputed
+    split = [(row, line) for row, line in zip(rows, sidecar) if "split_from" in line]
+    # Fewer than split_rows: split rows under 200 characters, or contained in a reference, are dropped.
+    assert 0 < len(split) <= stats["split_rows"]
+    assert all(len(row["text"]) >= 200 and line["has_events"] is None and line["split_from"].startswith(f"{clean.SOURCE}_")
+               for row, line in split)
+
+
 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"):
@@ -274,21 +297,6 @@ def test_search_agrees_with_brute_force_and_ties_go_to_the_smaller_id(tmp_path):
             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"
@@ -305,12 +313,12 @@ def _synthetic_release(directory, ids_texts):
     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)]
+    sidecar = [{"id": r["id"], "term": "9", "source_split": "train", "source_url": "u", "speaker": r["author"]} for r in rows]
     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)}
+        "".join(json.dumps(line) + "\n" for line in sidecar), encoding="utf-8")
+    stats = {"read": len(rows) + 3, "drop_after_end": 3, "drop_before_start": 0, "drop_dup": 0,
+             **release_stats(rows, sidecar)}
     (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}
 
@@ -336,6 +344,25 @@ def test_synthetic_build_filters_every_output_consistently(tmp_path, monkeypatch
     assert not list(tmp_path.glob("*.tmp"))
 
 
+def test_trailers_are_cut_before_containment(tmp_path, monkeypatch):
+    (tmp_path / "refs").mkdir()
+    refs = _write_refs(tmp_path / "refs")
+    statement = WORDS("w", 40) + " " + WORDS("x", 20)  # 219 characters; 36 of its 56 shingles are in ref_p1
+    # Uncut, the row would hold those 36 among ~130 shingles (under REPORT_AT) and be kept whole.
+    text = WORDS("q", 60) + " " + header("Jan Nowak", "Poseł Jan Nowak", "01-01-2020") + " Poseł Jan Nowak: " + statement
+    monkeypatch.setattr(clean, "INPUT_SHA256", _synthetic_release(tmp_path, [("speech", text)]))
+    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").to_pylist()[0]["text"] == WORDS("q", 60)
+    assert [json.loads(line)["id"] for line in (tmp_path / f"{clean.SOURCE}.attribution.jsonl").open()] == ["speech"]
+    decisions = [json.loads(line) for line in (tmp_path / clean.DECISIONS).open()]
+    assert [(d["action"], d["containment"], d["ref_id"]) for d in decisions] == [("drop", round(36 / 56, 4), "ref_p1")]
+    assert decisions[0]["id"].startswith(f"{clean.SOURCE}_")
+    assert (stats["kept"], stats["split_rows"], stats["drop_short"], stats["drop_cross_source_dup"]) == (1, 1, 0, 1)
+    assert stats["trailer_cut"]["rows_cut"] == 1
+
+
 def test_build_refuses_an_unreleased_reference(tmp_path, monkeypatch):
     (tmp_path / "refs").mkdir()
     refs = _write_refs(tmp_path / "refs")