sejm_api: cut the "Przebieg posiedzenia" trailers, split appended statements (amends #69, v2#57)

artifacts/source_findings.md

@@ -2214,3 +2214,42 @@ was assembled is not re-verified.
 
 **Lesson** — a label that drops the version is not a licence. 28,280 rows are CC BY and
 13,705 CC BY-SA, and 13,273 of the 41,985 rows are not 4.0.
+
+## sejm_api — "Przebieg posiedzenia" trailers cut, appended statements split out (2026-10-06)
+
+**Finding** (slayerlabs/polish-dynaword-v2#57) — the PiotrSty snapshot appends to 34,980
+of 38,812 speeches the header of a later statement of the same sitting day
+("Przebieg posiedzenia {name}: {term}. kadencja, {n}. posiedzenie, {d}. dzień - {label}
+… ({dd-mm-yyyy})"), and after 2,466 of those headers that statement's text. The trailers
+are 23,485,670 characters (24% of the source), released in v0.2.5 (Hub PR 16).
+
+**Fix** — `src/clean_sejm_api.py` (inputs pinned by SHA-256 to the pre-cut files at
+`262df1b`, unchanged since v0.2.5) cuts every trailer with `sejm_api_common.split_trailers` and emits each
+appended statement as a row of its own (`split_release_rows`): speaker = the name the
+header gives ("Przebieg posiedzenia {name}:"), date and term of the parent row,
+`split_from` = parent id, `has_events: null`. Rows under 200 characters after the cut
+(1,318 parents, 53 split rows) and 8 new exact duplicates are dropped. 38,812 → 39,899
+documents, 36,335,587 → 30,860,439 tokens. Same-speaker follow-ups (373) are kept as
+separate rows; agenda titles ("N. punkt porządku dziennego: …", "Oświadczenia.") before a
+follow-up are dropped.
+
+**Author of a split row** — the first push of this PR credited split rows in the snapshot's own
+`speaker` convention, the header label minus its first word. That is right for "Poseł Jan
+Kowalski" but leaves an office fragment for officials ("Podsekretarz Stanu w Ministerstwie
+Zdrowia Janusz Cieszyński" -> "Stanu w Ministerstwie Zdrowia Janusz Cieszyński"). The header's
+name fixes 2,052 published split rows; 129 more lose a "(tekst niewygłoszony)" suffix and 12 a
+"Sprawozdawca" prefix that the snapshot keeps on its own rows. Text, counts and stats are
+unchanged; the ids of these 2,193 rows change, since the id hashes the speaker.
+
+**Upstream quirk** — the snapshot labels the 11th sitting of term 10 (2024-05-08/09/15)
+"11. kadencja" in 696 headers. The split keeps the parent's term; a trailer dated on
+another day than its parent fails closed (none occur).
+
+**Also fixed** — `fetch_sejm_api.py` read the registry end date as the latest date in
+the entry, which picked up `added` (2026-07-02) once entries carried it, and a rerun
+then failed temporal novelty. It now parses the `created` range only, checks against
+`parliamentary` alone (`parlamint_pl` left in Hub PR 54 and never shipped), and keeps an
+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.

data/sejm_api/sejm_api.attribution.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4ab6513f8173498d403f7ec1a9534b8e0086264d3eca6ff9ac4f9c5dbca4c069
-size 18722278
+oid sha256:47d87542492629791df1112455ad4f5754fc74cd11ef620d7559ee4a243e80b1
+size 19448386

data/sejm_api/sejm_api.md

@@ -33,7 +33,8 @@ source. No unverified upstream Creative Commons license is asserted.
 - Immutable source release: `PiotrSty/sejm-speeches-corpus@v1.0.1`.
 - Pinned source commit: `124557799608ce4212cf22fa90ca7904618de1b6`.
 - Reviewed DynaWord base commit: `8cc48a3c564ac9edabfbbf012842ad11f70a3e5c`.
-- Rebuild: `python src/fetch_sejm_api.py --help`.
+- Rebuild: `python src/fetch_sejm_api.py --help`, then `python3 src/clean_sejm_api.py`
+  (trailer cut, below).
 - Speaker attribution and source URLs are in `sejm_api.attribution.jsonl`. Each
   `source_url` is a day-level listing (`https://api.sejm.gov.pl/sejm/term{N}/videos/{date}`),
   not a per-speech URL.
@@ -52,15 +53,35 @@ SHA-1 fingerprints; this is not a claim of global cross-domain near-deduplicatio
 |---|---:|
 | Source rows inspected | 157,714 |
 | Rows before 2023-01-01 | 118,902 |
-| Exact duplicate texts removed | 0 |
-| Documents published | 38,812 |
-| Characters | 96,596,566 |
-| Tokens (`cl100k_base` proxy) | 36,335,587 |
-| Documents with speaker attribution | 38,812 |
+| Statements split into rows of their own | 2,466 |
+| Rows under 200 characters | 1,371 |
+| Exact duplicate texts removed | 8 |
+| Documents published | 39,899 |
+| Characters | 83,482,628 |
+| Tokens (`cl100k_base` proxy) | 30,860,439 |
+| Documents with speaker attribution | 39,899 |
 
 Statistics are recomputed from the released Parquet file. The canonical schema
 is `id, text, source, added, created, token_count, license, author`.
 
+## Trailer cut
+
+The rights audit (slayerlabs/polish-dynaword-v2#57) found that the snapshot
+appends to 34,980 of the 38,812 fetched speeches a "Przebieg posiedzenia" header
+of a later statement of the same sitting day, and sometimes that statement's
+text. `src/clean_sejm_api.py` cuts every trailer (23,485,670 characters). An
+appended statement with text becomes a row of its own (2,466 rows), credited to
+the speaker the header names ("Przebieg posiedzenia Janusz Kowalski: …"), without
+the office in its label. Its date and term are those
+of the row it was cut from: the snapshot labels the 11th sitting of term 10
+(2024-05-08, 2024-05-09, 2024-05-15) "11. kadencja" in 696 headers. 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 v0.2.5) 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 (1,318 cut speeches and 53 split rows) and 8
+texts that became exact duplicates are dropped.
+
 ## Privacy and limitations
 
 The upstream release heuristically redacts email addresses, PESEL identifiers

data/sejm_api/sejm_api.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161
-size 35267581
+oid sha256:ba2daa20d2d2753c09e8bdd477839f43c82170f44caeadc634cb2295362c9c3b
+size 34336428

data/sejm_api/sejm_api.stats.json

@@ -1,36 +1,49 @@
 {
   "added": "2026-08-22",
-  "authors_with_value": 38812,
+  "authors_with_value": 39899,
   "by_source_split": {
-    "train": 38053,
-    "validation": 759
+    "train": 39132,
+    "validation": 767
   },
   "by_term": {
-    "10": 30789,
-    "9": 8023
+    "10": 31655,
+    "9": 8244
   },
   "by_year": {
-    "2023": 10220,
-    "2024": 4788,
-    "2025": 13712,
-    "2026": 10092
+    "2023": 10341,
+    "2024": 4937,
+    "2025": 14110,
+    "2026": 10511
   },
-  "chars": 96596566,
+  "chars": 83482628,
   "created_max": "2026-07-03",
   "created_min": "2023-01-11",
   "drop_before_start": 118902,
-  "drop_dup": 0,
+  "drop_dup": 8,
   "drop_lang": 0,
   "drop_ocr": 0,
-  "drop_short": 0,
-  "kept": 38812,
+  "drop_short": 1371,
+  "kept": 39899,
   "license": "public-domain (official documents)",
   "licenses": {
-    "public-domain (official documents)": 38812
+    "public-domain (official documents)": 39899
   },
   "read": 157714,
   "source_revision": "124557799608ce4212cf22fa90ca7904618de1b6",
+  "split_rows": 2466,
   "stats_recomputed_from_parquet": true,
   "target_base_revision": "8cc48a3c564ac9edabfbbf012842ad11f70a3e5c",
-  "tokens": 36335587
+  "tokens": 30860439,
+  "trailer_cut": {
+    "chars_cut": 23485670,
+    "drop_dup": 8,
+    "drop_short": 1371,
+    "input_sha256": {
+      "sejm_api.attribution.jsonl": "4ab6513f8173498d403f7ec1a9534b8e0086264d3eca6ff9ac4f9c5dbca4c069",
+      "sejm_api.parquet": "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161",
+      "sejm_api.stats.json": "edee610cdc0fcbc1c7015ed4f7d5dda74b549100cca5f410beaaf8ae3b0229c2"
+    },
+    "rows_cut": 34980,
+    "split_rows": 2466
+  }
 }

src/clean_sejm_api.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Cut the "Przebieg posiedzenia" trailers off the sejm_api speeches (slayerlabs/polish-dynaword-v2#57).
+
+The PiotrSty snapshot appends to most speeches the header of a later statement of the same sitting
+day, and sometimes that statement's text (see sejm_api_common.split_trailers). This script cuts every
+trailer and keeps a trailer's speech as a row of its own under the header's speaker
+(sejm_api_common.split_release_rows); rows that fall under the 200-character minimum after the cut,
+and texts that become exact duplicates, are dropped.
+
+The inputs are the pre-cut release files, pinned by SHA-256. Restore them before a rerun:
+  git checkout 262df1b -- data/sejm_api/sejm_api.{parquet,attribution.jsonl,stats.json}
+  python3 src/clean_sejm_api.py
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import tiktoken
+
+from sejm_api_common import check_pin, release_stats, replace_all, split_release_rows
+
+SOURCE = "sejm_api"
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+# Pre-cut release files (main at 262df1b; the Parquet is the v0.2.5 file);
+# artifacts/sejm_api_ontology_manifest.json records the fetch output, i.e. these.
+INPUT_SHA256 = {
+    f"{SOURCE}.parquet": "56f7b03483488dec8f0fa145c6d26746926175d83096e9d1931e535aa81cf161",
+    f"{SOURCE}.attribution.jsonl": "4ab6513f8173498d403f7ec1a9534b8e0086264d3eca6ff9ac4f9c5dbca4c069",
+    f"{SOURCE}.stats.json": "edee610cdc0fcbc1c7015ed4f7d5dda74b549100cca5f410beaaf8ae3b0229c2",
+}
+ROW_GROUP_SIZE = 512  # the layout of the released file
+
+
+def build(input_dir: Path, out_dir: Path) -> dict:
+    for name, sha in INPUT_SHA256.items():
+        check_pin(input_dir / name, sha, f"restore it with `git checkout 262df1b -- data/{SOURCE}/{name}`")
+    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[key] for key in recomputed}:
+        raise SystemExit("the input stats.json does not describe the input Parquet")
+
+    rows, sidecar, counts = split_release_rows(rows, sidecar, tiktoken.get_encoding("cl100k_base"))
+    stats.update(release_stats(rows, sidecar))
+    stats["split_rows"] = counts["split_rows"]
+    stats["drop_short"] += counts["drop_short"]
+    stats["drop_dup"] += counts["drop_dup"]
+    stats["trailer_cut"] = {"input_sha256": INPUT_SHA256, **counts}
+    drops = ("drop_before_start", "drop_dup", "drop_short", "drop_lang", "drop_ocr")
+    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")
+
+    replace_all({
+        out_dir / f"{SOURCE}.parquet": lambda p: pq.write_table(
+            pa.Table.from_pylist(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 sidecar), encoding="utf-8"),
+        out_dir / f"{SOURCE}.stats.json": lambda p: p.write_text(
+            json.dumps(stats, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8"),
+    })
+    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")
+    args = parser.parse_args()
+    print(json.dumps(build(args.data, args.data), indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

src/fetch_sejm_api.py

@@ -107,26 +107,37 @@ def normalize_source_row(
     return document, attribution
 
 
-def registry_source_end_date(registry: str, source_name: str) -> str:
+def registry_entry(registry: str, source_name: str) -> re.Match[str] | None:
     pattern = re.compile(
         rf'^\s{{4}}["\']{re.escape(source_name)}["\']\s*:\s*\{{'
         rf'(?P<body>.*?)^\s{{4}}\}},?',
         flags=re.MULTILINE | re.DOTALL,
     )
-    match = pattern.search(registry)
+    return pattern.search(registry)
+
+
+def registry_source_end_date(registry: str, source_name: str) -> str:
+    match = registry_entry(registry, source_name)
     if not match:
         raise ContributionError(f"existing parliamentary source missing from registry: {source_name}")
-    dates = re.findall(r"\d{4}-\d{2}-\d{2}", match.group("body"))
-    if not dates:
+    # The `created` range only: entries also carry an `added` date.
+    created = re.search(r'["\']created["\']\s*:\s*["\']\d{4}-\d{2}-\d{2}, (\d{4}-\d{2}-\d{2})["\']',
+                        match.group("body"))
+    if not created:
         raise ContributionError(f"source {source_name} has no documented date range")
-    return max(dates)
+    return created.group(1)
+
+
+# `parlamint_pl` (2015-2022) left the registry in Hub PR 54 without ever shipping data, so only
+# `parliamentary` is checked; sejm_api_2011_2022 ends on 2022-12-31 by its own END_DATE.
+PRIOR_PARLIAMENTARY_SOURCES = ("parliamentary",)
 
 
 def assert_temporal_novelty(registry: str, start_date: str) -> dict[str, str]:
     threshold = dt.date.fromisoformat(start_date)
     end_dates = {
         name: registry_source_end_date(registry, name)
-        for name in ("parliamentary", "parlamint_pl")
+        for name in PRIOR_PARLIAMENTARY_SOURCES
     }
     overlapping = {
         name: value for name, value in end_dates.items()
@@ -138,11 +149,23 @@ def assert_temporal_novelty(registry: str, start_date: str) -> dict[str, str]:
 
 
 def insert_source_registry_entry(registry: str, *, end_date: str) -> str:
-    if re.search(r'^\s{4}["\']sejm_api["\']\s*:', registry, flags=re.MULTILINE):
-        raise ContributionError("sejm_api already exists in the DynaWord source registry")
-    marker = '    "parlamint_pl": {'
-    if registry.count(marker) != 1:
-        raise ContributionError("cannot safely locate the existing parlamint_pl registry entry")
+    """Add the sejm_api entry after `parliamentary`; on a rerun, check the existing entry and keep it."""
+    existing = registry_entry(registry, SOURCE_NAME)
+    if existing:
+        required = (
+            f'"file_key": "{SOURCE_NAME}"',
+            f'"license": "{SOURCE_LICENSE}"',
+            '"license_spdx": "LicenseRef-Polish-Official-Documents"',
+            f'"upstream": "{SEJM_API}"',
+            f'"created": "{START_DATE}, {end_date}"',
+        )
+        differing = [value for value in required if value not in existing.group("body")]
+        if differing:
+            raise ContributionError(f"existing sejm_api registry entry differs from the contract: {differing}")
+        return registry
+    anchor = registry_entry(registry, "parliamentary")
+    if not anchor:
+        raise ContributionError("cannot safely locate the existing parliamentary registry entry")
     entry = (
         '    "sejm_api": {\n'
         '        "file_key": "sejm_api",\n'
@@ -163,7 +186,8 @@ def insert_source_registry_entry(registry: str, *, end_date: str) -> str:
         '        "is_ocr": False,\n'
         '    },\n'
     )
-    updated = registry.replace(marker, entry + marker, 1)
+    insert_at = registry.index("\n", anchor.end()) + 1
+    updated = registry[:insert_at] + entry + registry[insert_at:]
     ast.parse(updated)
     return updated
 
@@ -310,8 +334,8 @@ def ontology_manifest(
     ]
     claims = [
         {"id": f"slayer://claim/sejm-api-temporal-novelty@sha256:{version_digest[:20]}",
-         "statement": "Every contributed speech postdates both registered parliamentary source ranges.",
-         "falsification_condition": "Any contributed created date is <= either documented source end date.",
+         "statement": "Every contributed speech postdates every checked registered parliamentary source range.",
+         "falsification_condition": "Any contributed created date is <= a documented source end date.",
          "scope": [version], "supported_by": [evidence_ids["temporal-novelty"]], "asserted_by": actor},
         {"id": f"slayer://claim/sejm-api-full-speaker-attribution@sha256:{version_digest[:20]}",
          "statement": "Every contributed document has a non-empty speech-speaker attribution.",

src/sejm_api_common.py

@@ -10,8 +10,11 @@ from __future__ import annotations
 
 import hashlib
 import json
+import os
 import pathlib
-from typing import Any
+import re
+from collections import Counter
+from typing import Any, Callable
 
 COPYRIGHT_ACT = "https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf"
 OPEN_DATA_ACT = "https://eli.gov.pl/api/acts/DU/2023/1524/text.html"
@@ -23,6 +26,149 @@ EXPECTED_FIELDS = (
 )
 
 
+# The PiotrSty snapshot ends many speeches with the header of a later statement of the sitting,
+# "Przebieg posiedzenia <name>: <T>. kadencja,  <n>. posiedzenie, <d>. dzień - <label> <T>. kadencja,
+# ... (dd-mm-yyyy)", then an optional agenda title ("<k>. punkt porządku dziennego: <title>." or
+# "Oświadczenia."), then, when that statement has no row of its own (ministers, follow-up questions),
+# its text, usually opened by "<label>: ". Term 7 omits the dots after the numbers. A row can carry
+# several trailers; some rows end with a bare or truncated header instead.
+_SITTING = r"\d+\.? kadencja,\s+\d+\.? posiedzenie, \d+\.? dzień"
+TRAILER = re.compile(
+    r"Przebieg posiedzenia (?P<name>[^:\n]{1,120}?): (?P<term>\d+)\.? kadencja,\s+\d+\.? posiedzenie, \d+\.? dzień"
+    r" - (?P<label>[^\n]{1,300}?) (?P=term)\.? kadencja,\s+\d+\.? posiedzenie, \d+\.? dzień \((?P<date>\d{2}-\d{2}-\d{4})\)"
+)
+TRUNCATED_TRAILER = re.compile(
+    r"\s*Przebieg posiedzenia(?: [^:\n]{1,120}?: " + _SITTING + r"(?: - [^.():!?\n]{1,200})?)?\s*$"
+)
+# A title ends at its "(druk nr N)." citation, else at its first full stop; numbered items ("9. ...")
+# that follow belong to it.
+_SENTENCE = r"(?:.{0,800}?\(druki? nr [^)]{0,80}\)\.|.*?\.)(?=\s|\Z)"
+AGENDA = re.compile(
+    r"\s*(?:\d[\d., i]{0,40} punkt porządku dziennego: " + _SENTENCE + r"(?:\s\d+\. " + _SENTENCE + r")*"
+    r"|Oświadczenia\.)?"
+)
+
+
+def split_trailers(text: str, author: str) -> tuple[str, list[dict[str, str]]]:
+    """Cut the trailers off a speech: (its own text, one dict per trailer).
+
+    A trailer's `text` is what follows its "<label>: " line. Without that line it is what follows
+    the agenda title when the trailer names the row's own speaker (a follow-up of theirs), else ""
+    (the header of a statement that has a row of its own). `date` is ISO. `name` is the header's
+    own speaker name; the label prefixes it with an office ("Podsekretarz Stanu w Ministerstwie
+    Zdrowia Janusz Cieszyński"), which the snapshot's `speaker` convention (the label without its
+    first word) would garble.
+    """
+    end = TRUNCATED_TRAILER.search(text)
+    stop = end.start() if end else len(text)
+    heads = list(TRAILER.finditer(text, 0, stop))
+    own = text[: heads[0].start() if heads else stop].rstrip()
+    trailers = []
+    for head, following in zip(heads, heads[1:] + [None]):
+        chunk = text[head.end(): following.start() if following else stop]
+        line = chunk.find(head["label"] + ": ")
+        if line >= 0:
+            body = chunk[line + len(head["label"]) + 2:]
+        elif re.search(rf"(?<!\w){re.escape(head['name'])}(?!\w)", author):
+            body = chunk[AGENDA.match(chunk).end():]
+        else:
+            body = ""
+        day, month, year = head["date"].split("-")
+        trailers.append({"name": head["name"], "term": head["term"],
+                         "date": f"{year}-{month}-{day}", "text": body.strip()})
+    return own, trailers
+
+
+MIN_CHARS = 200  # the fetchers' own minimum (normalize_source_row)
+
+
+def split_release_rows(rows: list[dict[str, Any]], sidecar: list[dict[str, Any]], encoder: Any
+                       ) -> tuple[list[dict[str, Any]], list[dict[str, Any]], Counter[str]]:
+    """Cut the trailers off released rows and give each trailer speech a row of its own.
+
+    `rows` (Parquet) and `sidecar` (attribution) are parallel. A cut row keeps its id, and its
+    token_count, char_count and word_count are recomputed. A trailer speech becomes a new row right
+    after its parent, with the snapshot's id scheme over (date, term, speaker, text), the parent's
+    source, license, added, term and source_url, and `split_from` = the parent id in the sidecar.
+    `has_events` (an upstream flag the text cannot give) is null on new rows. Cut and new rows under
+    MIN_CHARS, and exact text duplicates (SHA-1, first wins), are dropped, as the fetchers do; uncut
+    rows pass unchecked.
+    """
+    if [row["id"] for row in rows] != [line["id"] for line in sidecar]:
+        raise ValueError("the attribution sidecar does not match the Parquet ids")
+    out_rows: list[dict[str, Any]] = []
+    out_sidecar: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    counts: Counter[str] = Counter(rows_cut=0, chars_cut=0, split_rows=0, drop_short=0, drop_dup=0)
+
+    def emit(row: dict[str, Any], line: dict[str, Any], changed: bool) -> None:
+        fingerprint = hashlib.sha1(row["text"].encode("utf-8")).hexdigest()
+        if changed and len(row["text"]) < MIN_CHARS:
+            counts["drop_short"] += 1
+        elif fingerprint in seen:
+            counts["drop_dup"] += 1
+        else:
+            seen.add(fingerprint)
+            out_rows.append(row)
+            out_sidecar.append(line)
+
+    def with_text(row: dict[str, Any], line: dict[str, Any], text: str) -> tuple[dict, dict]:
+        return ({**row, "text": text, "token_count": len(encoder.encode_ordinary(text))},
+                {**line, "char_count": len(text), "word_count": len(text.split())})
+
+    for row, line in zip(rows, sidecar):
+        own, trailers = split_trailers(row["text"], row["author"])
+        cut = own != row["text"]
+        if cut:
+            counts["rows_cut"] += 1
+            counts["chars_cut"] += len(row["text"]) - len(own)
+        emit(*(with_text(row, line, own) if cut else (row, line)), cut)
+        for trailer in trailers:
+            if not trailer["text"]:
+                continue
+            # The row's term, not the header's: the snapshot labels the 11th sitting of term 10
+            # (2024-05-08/09/15) "11. kadencja" in 696 headers.
+            if trailer["date"] != row["created"]:
+                raise ValueError(f"{row['id']}: a trailer from another sitting day: {trailer['date']}")
+            counts["split_rows"] += 1
+            new_id = stable_document_id({"date": trailer["date"], "term": line["term"],
+                                         "speaker": trailer["name"], "text": trailer["text"]}, row["source"])
+            new_row, new_line = with_text({**row, "id": new_id, "author": trailer["name"]},
+                                          {**line, "id": new_id, "speaker": trailer["name"],
+                                           "has_events": None, "split_from": row["id"]}, trailer["text"])
+            emit(new_row, new_line, True)
+    return out_rows, out_sidecar, counts
+
+
+def release_stats(rows: list[dict[str, Any]], sidecar: list[dict[str, Any]]) -> dict[str, Any]:
+    """The stats.json fields that are recomputed from the released rows."""
+    created = [row["created"] for row in rows]
+    return {
+        "kept": len(rows),
+        "chars": sum(len(row["text"]) for row in rows),
+        "tokens": sum(row["token_count"] for row in rows),
+        "licenses": dict(sorted(Counter(row["license"] for row in rows).items())),
+        "authors_with_value": sum(bool(row["author"]) for row in rows),
+        "created_min": min(created), "created_max": max(created),
+        "by_year": dict(sorted(Counter(date[:4] for date in created).items())),
+        "by_term": dict(sorted(Counter(line["term"] for line in sidecar).items())),
+        "by_source_split": dict(sorted(Counter(line["source_split"] for line in sidecar).items())),
+    }
+
+
+def check_pin(path: pathlib.Path, expected: str, restore: str) -> None:
+    if sha256_file(path) != expected:
+        raise SystemExit(f"{path} does not match the pinned SHA-256; {restore}")
+
+
+def replace_all(writers: dict[pathlib.Path, Callable[[pathlib.Path], None]]) -> None:
+    """Write every output to <path>.tmp first, then move them all into place."""
+    for path, write in writers.items():
+        write(path.with_name(path.name + ".tmp"))
+    for path in writers:
+        os.replace(path.with_name(path.name + ".tmp"), path)
+
+
 def sha256_file(path: pathlib.Path) -> str:
     digest = hashlib.sha256()
     with path.open("rb") as stream:

src/test_sejm_api_contract.py

@@ -29,18 +29,22 @@ except ImportError:
     )
 
 from sources import SOURCES  # noqa: E402  (src/ is on sys.path above)
+from sejm_api_common import (  # noqa: E402
+    TRAILER, TRUNCATED_TRAILER, release_stats, split_release_rows, split_trailers,
+)
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 DAY_LEVEL_URL = re.compile(r"https://api\.sejm\.gov\.pl/sejm/term\d+/videos/\d{4}-\d{2}-\d{2}")
 
 REGISTRY = '''SOURCES = {
     "parliamentary": {
+        "added": "2026-07-02",
         "created": "1991-01-01, 2019-12-31",
         "license": "public-domain (official documents)",
     },
-    "parlamint_pl": {
-        "created": "2015-01-01, 2022-12-31",
-        "license": "CC-BY-4.0",
+    "sejm_interpellations": {
+        "created": "2023-11-13, 2026-07-03",
+        "license": "public-domain (official documents)",
     },
 }
 '''
@@ -89,7 +93,7 @@ class DynawordContractTests(unittest.TestCase):
             added_date="2026-08-22", encoder=FakeEncoder()
         ))
 
-    def test_first_day_after_parlamint_is_included(self) -> None:
+    def test_first_day_of_2023_is_included(self) -> None:
         self.assertIsNotNone(normalize_source_row(
             sample_row(2, date="2023-01-01"), start_date=START_DATE,
             added_date="2026-08-22", encoder=FakeEncoder()
@@ -121,23 +125,32 @@ class DynawordContractTests(unittest.TestCase):
                 start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder()
             )
 
-    def test_temporal_novelty_against_both_registered_sources(self) -> None:
-        self.assertEqual(assert_temporal_novelty(REGISTRY, START_DATE), {
-            "parliamentary": "2019-12-31",
-            "parlamint_pl": "2022-12-31",
-        })
+    def test_temporal_novelty_reads_the_created_range_not_the_added_date(self) -> None:
+        self.assertEqual(assert_temporal_novelty(REGISTRY, START_DATE), {"parliamentary": "2019-12-31"})
 
-    def test_overlap_with_registered_parlamint_fails_closed(self) -> None:
+    def test_overlap_with_registered_parliamentary_fails_closed(self) -> None:
         with self.assertRaisesRegex(ContributionError, "overlaps"):
-            assert_temporal_novelty(REGISTRY, "2022-01-01")
+            assert_temporal_novelty(REGISTRY, "2019-06-01")
 
     def test_registry_entry_is_valid_and_preserves_existing_sources(self) -> None:
         updated = insert_source_registry_entry(REGISTRY, end_date="2026-07-03")
         ast.parse(updated)
-        self.assertIn('"sejm_api": {', updated)
-        self.assertIn('"parlamint_pl": {', updated)
+        self.assertLess(updated.index('"parliamentary": {'), updated.index('"sejm_api": {'))
+        self.assertLess(updated.index('"sejm_api": {'), updated.index('"sejm_interpellations": {'))
         self.assertIn('"created": "2023-01-01, 2026-07-03"', updated)
 
+    def test_rerun_keeps_an_existing_entry_that_meets_the_contract(self) -> None:
+        updated = insert_source_registry_entry(REGISTRY, end_date="2026-07-03")
+        self.assertEqual(insert_source_registry_entry(updated, end_date="2026-07-03"), updated)
+        with self.assertRaisesRegex(ContributionError, "differs from the contract"):
+            insert_source_registry_entry(updated, end_date="2026-08-01")
+
+    def test_rerun_against_the_shipped_registry(self) -> None:
+        registry = (ROOT / "src" / "sources.py").read_text(encoding="utf-8")
+        self.assertEqual(assert_temporal_novelty(registry, START_DATE), {"parliamentary": "2019-12-31"})
+        end_date = SOURCES["sejm_api"]["created"].split(", ")[1]
+        self.assertEqual(insert_source_registry_entry(registry, end_date=end_date), registry)
+
     def test_registry_template_matches_the_shipped_provenance(self) -> None:
         updated = insert_source_registry_entry(REGISTRY, end_date="2026-07-03")
         template = ast.literal_eval(updated.split("=", 1)[1])["sejm_api"]
@@ -217,5 +230,174 @@ class DynawordParquetIntegrationTests(unittest.TestCase):
             self.assertTrue((output / "src" / "test_sejm_api_contract.py").is_file())
 
 
+def header(name: str, label: str, date: str, *, term: str = "9", sitting: str = "70", day: str = "1") -> str:
+    """A "Przebieg posiedzenia" trailer header as the snapshot writes it (terms 8-10; term 7 drops the dots)."""
+    if term == "7":
+        sitting_day = f"7 kadencja,   {sitting} posiedzenie, {day} dzień"
+    else:
+        sitting_day = f"{term}. kadencja,  {sitting}. posiedzenie, {day}. dzień"
+    return f"Przebieg posiedzenia {name}: {sitting_day} - {label} {sitting_day} ({date})"
+
+
+class TrailerSplitTests(unittest.TestCase):
+    """v2#57: the trailers are cut, and a trailer's speech becomes a row of its own (real snippets)."""
+
+    def test_header_of_a_statement_with_its_own_row_is_cut(self) -> None:
+        own = "Komisja Ochrony Środowiska, Zasobów Naturalnych i Leśnictwa - godz. 17. Dziękuję."
+        text = own + " " + header("Krzysztof Paszyk", "Poseł Krzysztof Paszyk", "11-01-2023")
+        self.assertEqual(split_trailers(text, "Ryszard Terlecki"), (own, [{
+            "name": "Krzysztof Paszyk", "term": "9",
+            "date": "2023-01-11", "text": ""}]))
+
+    def test_appended_statement_after_its_label_line_is_kept(self) -> None:
+        label = "Sekretarz Stanu w Ministerstwie Rolnictwa i Rozwoju Wsi Janusz Kowalski"
+        speech = "Szanowna Pani Marszałek! Szanowna Wysoka Izbo! Szanowny Panie Pośle!"
+        text = ("Co zamierzacie zrobić w najbliższym czasie? Dziękuję. "
+                + header("Janusz Kowalski", label, "12-01-2023", day="2")
+                + " 11. punkt porządku dziennego: Pytania w sprawach bieżących. " + label + ": " + speech)
+        own, trailers = split_trailers(text, "Stefan Krajewski")
+        self.assertEqual(own, "Co zamierzacie zrobić w najbliższym czasie? Dziękuję.")
+        self.assertEqual(len(trailers), 1)
+        self.assertEqual(trailers[0]["text"], speech)
+        # The header's name, not the label minus its first word ("Stanu w Ministerstwie ...").
+        self.assertEqual(trailers[0]["name"], "Janusz Kowalski")
+
+    def test_term_7_follow_up_of_the_same_speaker_and_a_later_header(self) -> None:
+        follow_up = ("Mój wniosek formalny jest taki, żeby pani marszałek odpowiedziała Wysokiej Izbie. "
+                     "Dziękuję. (Poruszenie na sali)")
+        text = ("Nie ma biało-czerwonej flagi. (Poruszenie, wesołość na sali) "
+                + header("Marek Matuszewski", "Poseł Marek Matuszewski", "01-12-2011", term="7", sitting="1", day="5")
+                + " " + follow_up + " "
+                + header("Stanisław Piotrowicz", "Poseł Stanisław Piotrowicz", "01-12-2011", term="7", sitting="1", day="5")
+                + " 15 punkt porządku dziennego: Wybór zastępcy przewodniczącego Trybunału Stanu (druk nr 31).")
+        own, trailers = split_trailers(text, "Marek Matuszewski")
+        self.assertEqual(own, "Nie ma biało-czerwonej flagi. (Poruszenie, wesołość na sali)")
+        self.assertEqual([(t["name"], t["term"], t["date"], t["text"]) for t in trailers], [
+            ("Marek Matuszewski", "7", "2011-12-01", follow_up),
+            ("Stanisław Piotrowicz", "7", "2011-12-01", ""),
+        ])
+
+    def test_agenda_title_before_a_same_speaker_follow_up_is_dropped(self) -> None:
+        for agenda in ("1 punkt porządku dziennego: Wybór marszałka Sejmu Rzeczypospolitej Polskiej.",
+                       "Oświadczenia."):
+            text = ("Panie marszałku, nie bójmy się tej nazwy. (Oklaski) "
+                    + header("Beata Mazurek", "Poseł Beata Mazurek", "08-11-2011", term="7", sitting="1")
+                    + f" {agenda} Pani minister, to moje pierwsze pytanie.")
+            _, trailers = split_trailers(text, "Beata Mazurek")
+            self.assertEqual(trailers[0]["text"], "Pani minister, to moje pierwsze pytanie.")
+
+    def test_truncated_and_bare_headers_at_the_end_are_cut(self) -> None:
+        own = "Dziękuję bardzo. (Oklaski)"
+        for tail in (" Przebieg posiedzenia Barbara Dolniak: 8. kadencja,  31. posiedzenie, 1. dzień - Poseł Barbara Dolniak",
+                     " Przebieg posiedzenia"):
+            self.assertEqual(split_trailers(own + tail, "Małgorzata Pępek"), (own, []))
+
+    def test_speech_about_a_sitting_is_not_cut(self) -> None:
+        text = "Przebieg posiedzenia komisji był burzliwy: 9. kadencja nie widziała takiej debaty."
+        self.assertEqual(split_trailers(text, "Jan Kowalski"), (text, []))
+
+
+def release_row(index: int, text: str, *, author: str = "Ryszard Terlecki", created: str = "2023-01-11") -> tuple[dict, dict]:
+    row_id = f"sejm_api_{index}"
+    return ({"id": row_id, "text": text, "source": "sejm_api", "added": "2026-08-22", "created": created,
+             "token_count": len(text.split()), "license": SOURCE_LICENSE, "author": author},
+            {"id": row_id, "source_url": f"https://api.sejm.gov.pl/sejm/term10/videos/{created}", "speaker": author,
+             "created": created, "term": "10", "has_events": True, "word_count": len(text.split()),
+             "char_count": len(text), "provider": "Kancelaria Sejmu RP", "source_split": "train"})
+
+
+class SplitReleaseRowsTests(unittest.TestCase):
+    OWN = "Wysoka Izbo!" + " Mówię o budżecie państwa." * 10
+    SPEECH = "Panie Marszałku! " + "Odpowiadam na pytanie pana posła. " * 10
+
+    def split(self, *rows: tuple[dict, dict]):
+        return split_release_rows([r for r, _ in rows], [s for _, s in rows], FakeEncoder())
+
+    def test_cut_parent_keeps_its_id_and_the_speech_gets_a_row(self) -> None:
+        # The header says "11. kadencja" as the snapshot does for the 11th sitting of term 10.
+        text = (self.OWN + " " + header("Jan Nowak", "Poseł Jan Nowak", "08-05-2024", term="11", sitting="11")
+                + " Poseł Jan Nowak: " + self.SPEECH)
+        rows, sidecar, counts = self.split(release_row(1, text, created="2024-05-08"))
+        parent, child = rows
+        self.assertEqual((parent["id"], parent["text"]), ("sejm_api_1", self.OWN))
+        self.assertEqual(parent["token_count"], len(self.OWN.split()))
+        self.assertEqual((sidecar[0]["char_count"], sidecar[0]["has_events"]), (len(self.OWN), True))
+        self.assertEqual((child["author"], child["created"], child["text"]), ("Jan Nowak", "2024-05-08", self.SPEECH.strip()))
+        self.assertEqual(child["id"], stable_document_id(
+            {"date": "2024-05-08", "term": "10", "speaker": "Jan Nowak", "text": self.SPEECH.strip()}))
+        self.assertEqual({k: sidecar[1][k] for k in ("id", "speaker", "term", "has_events", "split_from", "source_url")},
+                         {"id": child["id"], "speaker": "Jan Nowak", "term": "10", "has_events": None,
+                          "split_from": "sejm_api_1", "source_url": sidecar[0]["source_url"]})
+        self.assertEqual(dict(counts), {"rows_cut": 1, "chars_cut": len(text) - len(self.OWN),
+                                        "split_rows": 1, "drop_short": 0, "drop_dup": 0})
+
+    def test_short_rows_and_exact_duplicates_are_dropped(self) -> None:
+        trailer = " " + header("Jan Nowak", "Poseł Jan Nowak", "11-01-2023")
+        rows, _, counts = self.split(release_row(1, "Dziękuję." + trailer), release_row(2, self.OWN + trailer),
+                                     release_row(3, self.OWN, author="Inny Poseł"))
+        self.assertEqual([row["id"] for row in rows], ["sejm_api_2"])
+        self.assertEqual((counts["drop_short"], counts["drop_dup"], counts["rows_cut"]), (1, 1, 2))
+
+    def test_uncut_rows_pass_unchecked(self) -> None:
+        rows, _, counts = self.split(release_row(1, "Dziękuję."))
+        self.assertEqual(([row["id"] for row in rows], counts["drop_short"]), (["sejm_api_1"], 0))
+
+    def test_a_trailer_from_another_day_fails_closed(self) -> None:
+        text = self.OWN + " " + header("Jan Nowak", "Poseł Jan Nowak", "12-01-2023") + " Poseł Jan Nowak: " + self.SPEECH
+        with self.assertRaisesRegex(ValueError, "another sitting day"):
+            self.split(release_row(1, text))
+
+    def test_misaligned_sidecar_fails_closed(self) -> None:
+        row, line = release_row(1, self.OWN)
+        with self.assertRaisesRegex(ValueError, "sidecar"):
+            split_release_rows([row], [dict(line, id="sejm_api_2")], FakeEncoder())
+
+
+class ReleasedTrailerCutTests(unittest.TestCase):
+    """The released files after src/clean_sejm_api.py."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        try:
+            import pyarrow.parquet as pq
+        except ImportError:
+            raise unittest.SkipTest("pyarrow is installed on the release runner")
+        data = ROOT / "data" / "sejm_api"
+        cls.rows = pq.read_table(data / "sejm_api.parquet").to_pylist()
+        with (data / "sejm_api.attribution.jsonl").open(encoding="utf-8") as stream:
+            cls.sidecar = [json.loads(line) for line in stream]
+        cls.stats = json.loads((data / "sejm_api.stats.json").read_text(encoding="utf-8"))
+        cls.card = (data / "sejm_api.md").read_text(encoding="utf-8")
+
+    def test_no_trailer_is_left(self) -> None:
+        self.assertEqual([row["id"] for row in self.rows
+                          if TRAILER.search(row["text"]) or TRUNCATED_TRAILER.search(row["text"])], [])
+
+    def test_rows_meet_the_fetch_contract(self) -> None:
+        self.assertEqual([row["id"] for row in self.rows], [line["id"] for line in self.sidecar])
+        self.assertEqual(min(len(row["text"]) for row in self.rows), 200)
+        self.assertEqual(len({row["text"] for row in self.rows}), len(self.rows))
+        self.assertTrue(all(row["author"] == line["speaker"] for row, line in zip(self.rows, self.sidecar)))
+        self.assertTrue(all(line["char_count"] == len(row["text"]) for row, line in zip(self.rows, self.sidecar)))
+
+    def test_split_rows_are_marked(self) -> None:
+        split = [line for line in self.sidecar if "split_from" in line]
+        # Fewer than split_rows: new rows under 200 characters are dropped like the cut parents.
+        self.assertTrue(0 < len(split) <= self.stats["split_rows"])
+        self.assertTrue(all(line["has_events"] is None for line in split))
+        self.assertTrue(all(line["split_from"].startswith("sejm_api_") for line in split))
+
+    def test_stats_and_card_describe_the_parquet(self) -> None:
+        recomputed = release_stats(self.rows, self.sidecar)
+        self.assertEqual({key: self.stats[key] for key in recomputed}, recomputed)
+        drops = ("drop_before_start", "drop_dup", "drop_short", "drop_lang", "drop_ocr")
+        self.assertEqual(self.stats["read"] + self.stats["split_rows"] - sum(self.stats[k] for k in drops),
+                         self.stats["kept"])
+        for label, key in (("Documents published", "kept"), ("Characters", "chars"),
+                           ("Tokens (`cl100k_base` proxy)", "tokens"), ("Rows under 200 characters", "drop_short"),
+                           ("Statements split into rows of their own", "split_rows")):
+            self.assertIn(f"| {label} | {self.stats[key]:,} |", self.card)
+
+
 if __name__ == "__main__":
     unittest.main()