parliamentary: rebuild from IPI PAN's PPC TEI dump, official speakers only (v0.2.6 rights audit) (#108)

- parliamentary: rebuild from IPI PAN's PPC TEI dump, official speakers only (v0.2.6 rights audit, v2#54) (2c5d9a3f948f51e303c04b875bef4a3177b7c9be)
- parliamentary: split dropped-document counts into sittings and interpellations (0efe64b6bd675288c534648cc0e20da563fa7bda)
- parliamentary: keep unusual names that belong to a member (v2#54, decision 1A) (8496674f2f62d4cc142f092e32e7ae830a36591b)

data/parliamentary/parliamentary.attribution.jsonl

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

data/parliamentary/parliamentary.md

@@ -1,43 +1,226 @@
-# parliamentary
+# Polish Parliamentary Corpus (Sejm and Senate, 1919-2025) - official parliamentary materials
 
-Polish Parliamentary Corpus (Sejm/Senat)
+The Sejm and Senate part of IPI PAN's Polish Parliamentary Corpus (PPC), rebuilt from its
+speaker-labelled TEI dump: plenary and committee sittings **limited to statements by official
+speakers** (MPs and senators, members of the government, heads of constitutional organs, Sejm and
+Senate staff; see "Speaker allowlist"), and Sejm interpellations, questions and the government's
+replies kept whole:
+**348,475 records / 1,606,998,487 `cl100k_base` tokens / 4,370,190,797 characters**
+(43,734 sittings, 304,741 interpellation records), 1919-2025. The Sejm from term 9 (2019-) is not
+here: `sejm_api`, `sejm_committee_transcripts` and `sejm_interpellations` cover it.
 
-## Dataset description
-- **Source (upstream):** http://clip.ipipan.waw.pl/PPC
-- **Domain:** political/spoken
-- **Language:** Polish (pl)
-- **License:** `public-domain (official documents)`
-- **Created (range):** 1991-01-01, 2019-12-31
-- **Added:** 2026-06-15
+## Origin and license
 
-## Licensing — traceable basis
-Parliamentary proceedings are official documents outside copyright (PL art. 4 pr. aut.). IPI PAN's PPC page states that the parliamentary data is public domain; its CC BY licence covers only the corpus annotations, which this source does not include.
+- Origin: Polish Parliamentary Corpus, Institute of Computer Science, Polish Academy of Sciences
+  (IPI PAN), <https://clip.ipipan.waw.pl/PPC>: the per-term TEI dump of 2025-05-21,
+  `https://kdp.ipipan.waw.pl/static/ppcdump-tei/<term>-tei.zip`, 28 zips, 26,409,547,075 bytes,
+  downloaded 2026-10-07 and pinned by size and SHA-256 in `src/fetch_parliamentary.py`. The texts
+  are the stenographic reports, committee transcripts and interpellations published by the
+  Chancelleries of the Sejm and the Senate (each TEI header names the publisher). Each record's
+  `ppc_path` in `parliamentary.attribution.jsonl` pins its document in the dump.
+- Credit: the speaker turns, speaker labels, roles and dates that this source is cut and filtered
+  by come from IPI PAN's TEI markup. Cite Maciej Ogrodniczuk (2018), "Polish Parliamentary
+  Corpus", Proceedings of the LREC 2018 Workshop ParlaCLARIN: Creating and Using Parliamentary
+  Corpora. PPC's CC BY licence covers its annotations; none of the linguistic annotation layers is
+  shipped, and the speaker labels in the attribution sidecar are credited here.
+- License: official parliamentary materials are excluded from copyright by
+  [art. 4(2) of the Polish Copyright Act](https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf);
+  reuse is governed by the
+  [Polish Open Data and Reuse of PSI Act](https://eli.gov.pl/api/acts/DU/2023/1524/text.html).
+  IPI PAN's PPC page states that the parliamentary data is public domain. Asked for its basis, IPI
+  PAN answered (e-mail, 2026-10-07) that it is public information made available by statute (the
+  Open Data Act and the Access to Public Information Act), with no agreement with the
+  Chancelleries. Record license: `public-domain (official documents)`. No Creative Commons grant is
+  claimed for the text. Not lawyer-signed-off; whether statements of guests at sittings are
+  official documents under art. 4(2) is open (polish-dynaword-v2#54), so they are left out.
 
-## Provenance
-Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `PPC_corpus`) of the upstream source above. SpeakLeash credited as intermediate aggregator; upstream license/attribution preserved.
+## What the texts are
 
-## Statistics
-| documents | characters | tokens (tiktoken proxy) |
-|---:|---:|---:|
-| 324,622 | 4,492,746,014 | 1,646,835,986 |
+- **Genre**: stenographic reports of plenary sittings; transcripts and bulletins of committee
+  sittings; interpellations and questions ("zapytania") of MPs with the government's replies.
+- **Register**: parliamentary Polish as recorded and edited by the stenographers - speeches,
+  debate with interruptions, chair announcements, read-out documents - and, in the
+  interpellations, formal letters to and from ministers. The texts of 1919-1989 were digitised from
+  the printed reports (the dump does not say how; each header names an `.odt` original): samples
+  read clean, interwar spelling is kept ("zależnem"), and some speaker labels carry typos ("Poeł",
+  "Marszalek"). Not machine-translated.
+- **Time span**:
 
+  | Period | House | Kind | Records | Characters | Dates |
+  |---|---|---|---:|---:|---|
+  | 1919-1939 | Sejm | plenary | 1,021 | 156,362,281 | 1919-02-10 - 1939-09-02 |
+  | 1919-1939 | Senat | plenary | 323 | 43,495,751 | 1922-11-28 - 1939-09-02 |
+  | 1944-1946 | Krajowa Rada Narodowa | plenary | 6 | 1,093,152 | 1944-12-31 - 1946-09-23 |
+  | 1947-1989 | Sejm | plenary | 460 | 111,637,467 | 1947-02-04 - 1989-05-30 |
+  | 1947-1989 | Sejm | committee | 2,433 | 62,299,011 | 1965-09-17 - 1989-05-29 |
+  | 1989-1991 | Sejm | plenary | 79 | 47,102,915 | 1989-07-04 - 1991-10-25 |
+  | 1989-1991 | Senat | plenary | 61 | 18,104,530 | 1989-07-04 - 1991-10-24 |
+  | 1991-2019 | Sejm | plenary | 2,093 | 927,132,603 | 1991-11-25 - 2019-10-16 |
+  | 1991-2019 | Sejm | committee | 31,362 | 1,177,690,020 | 1993-05-23 - 2019-10-16 (one sitting dated 1988, see caveats) |
+  | 1997-2019 | Sejm | interpellations | 304,741 | 1,335,155,122 | terms 3-7 undated (1997-10-20 - 2015-11-11 by term); term 8 2015-11-17 - 2019-04-04 |
+  | 1991-2025 | Senat | plenary | 1,375 | 346,591,211 | 1991-11-26 - 2025-04-24 |
+  | 2015-2025 | Senat | committee | 4,521 | 143,526,734 | 2015-11-13 - 2025-04-24 |
 
-## Per-document license metadata
-| license | documents |
-|---|---:|
-| `public-domain (official documents)` | 324,622 |
+  Interpellation records: 114,126 interpellations (259,034,011 characters), 114,472 replies to
+  them (692,623,596), 38,051 questions (65,680,680) and 38,092 replies to questions (317,816,835).
+  20,447 distinct speaker labels are kept.
 
-Author metadata present for **0** documents. Empty values mean the upstream record did not expose a machine-readable author field.
+## Collection and normalization
 
-Statistics were recomputed directly from the released parquet file.
+Every step lives in `src/fetch_parliamentary.py`; the shard is reproducible from the pinned dump
+(`--download` fetches it and refuses a zip whose size or SHA-256 differs).
 
-## Filters applied (build_dynaword.py)
-Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
-- drop documents < 200 chars: **0**
-- drop non-Polish (diacritic ratio): **0**
-- exact cross-source dedup (sha1): **0**
-- OCR alpha-ratio < 0.70 (OCR sources only): **0**
-- read 324,622 → kept 324,622
+- **Scope**: every term of the dump except `2019-2023/sejm/` and `2023-2027/sejm/` (5,940
+  documents), which the `sejm_*` sources cover; the Senate of 2019-2025 is kept. The Sejm part ends
+  with the sitting of 2019-10-16; `sejm_api` checks that its own material starts after the end of
+  term 8 (`PARLIAMENTARY_SEJM_END` = 2019-11-11 in `src/sejm_api_common.py`).
+- **Records**: one record per sitting document (a sitting day, as the dump splits it) or per
+  interpellation, question or reply. A sitting's text is its kept utterances (`<u>`) joined by
+  newlines, without speaker labels; a dropped turn leaves no marker. The attribution sidecar lists
+  per record the kept speaker labels (`speakers`), `kept_characters` and `dropped_characters`, and
+  the header's `system`, `house`, `type`, `term_no` and `date`. An interpellation's text is its
+  paragraphs; its header names the author (298,185 records carry an `author`; sittings carry none).
+- **Dates**: `created` is the sitting or letter date. The dump writes 175 sittings over several
+  days as one date string ("1938-11-28 i 29", "1952-07-31 i 08-01"); they get the range
+  "first, last". The 226,062 interpellation records of terms 3-7 carry no date in the dump and get
+  their term's range (e.g. "1997-10-20, 2001-10-18"); the sidecar's `date` keeps the dump's string
+  (empty for those).
+- **Speaker allowlist** (sittings only, plenary and committee): every speaker in a sitting's
+  header is classified once, by its role followed by a placeholder name ("Jan Maria Kowalski"),
+  against the anchored rules `SPEAKER_RULES` of `src/fetch_sejm_committee_transcripts.py` (the
+  `sejm_committee_transcripts` allowlist) and then `PPC_RULES` in `src/fetch_parliamentary.py`.
+  A turn is kept only if its speaker matches a rule; a speaker no rule recognises is dropped (fail
+  closed). A person's own name that is not a 1-3 token name ("Piotr van der Coghen", "Jan Bury s.
+  Antoniego", "Artur Płokszto z Litwy") is kept only if it is, or starts with, the name of an MP,
+  senator or marshal of the same term zip (the chairs' member check, below; 349 persons kept, 673
+  dropped). PPC's removal of party tags sometimes leaves a cut tag as one more surname part ("(niez"; 1,850 persons), which is ignored. PPC strips
+  the party tags that the base allowlist keys MPs on, so it matches only 3,804 characters of
+  bare `mp` turns; the PPC rules close that gap. Kept, by rule (characters of utterance text,
+  turns; `parliamentary.speaker-roles.csv` lists every role with its decision):
 
-Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
-Llama-3 count is computed at release.
+  | Rule | Keeps | Characters | Turns |
+  |---|---|---:|---:|
+  | `mp_no_party` | "Poseł/Posłanka NAME", with "Sprawozdawca", "Sekretarz", "Wiceprzewodniczący"; "Sekretarz poseł NAME"; the typo "Poeł" | 1,694,953,227 | 4,477,657 |
+  | `state_secretary` | secretaries and undersecretaries of state in a ministry or the Chancellery of the Prime Minister (base rule) | 325,593,817 | 614,984 |
+  | `senator` | "Senator NAME" (base rule) | 315,926,447 | 883,499 |
+  | `marshal_no_house` | the chamber's own marshal and deputy marshals without "Sejmu"/"Senatu", "Marszałek Senior"; never a voivodeship marshal | 190,540,640 | 2,407,101 |
+  | `mp_committee_chair` | committee chairs who are MPs (base rule) | 158,002,628 | 1,038,553 |
+  | `government_member` | the Prime Minister, deputy PMs, ministers (base rule) | 87,399,387 | 175,562 |
+  | `committee_chair_named` | a committee chair or deputy chair named in the label, only if the name is an MP's, senator's or marshal's of that term (see below) | 46,499,132 | 439,802 |
+  | `government_historic` | "Prezydent Ministrów" (1919-21), "Prezes Rady Ministrów", "Wicepremier", ministers under historic names ("Minister Skarbu", "Minister Wyznań Religijnych i Oświecenia Publicznego", "Minister Przemysłu Chemicznego"), "Kierownik Ministerstwa ...", "Minister - Szef Urzędu Rady Ministrów" | 41,519,929 | 78,012 |
+  | `state_secretary_historic` | secretaries of state of historic ministries and of the Urząd Rady Ministrów (the Prime Minister's office before KPRM) | 36,177,142 | 72,609 |
+  | `constitutional_organ_head` | RPO, RPD, Prezes NIK, NBP, TK, NSA, Pierwszy Prezes SN, KRRiT, KRS, Prokurator Generalny (base rule) | 34,642,977 | 55,742 |
+  | `legislative_petitions_staff` | the Sejm's "Przedstawiciel Biura Legislacyjnego", Senate legislators and experts of the Biuro Legislacyjne, petitions staff of the Senate | 32,427,046 | 97,234 |
+  | `sejm_legislator` | Biuro Legislacyjne legislators (base rule) | 20,914,344 | 73,630 |
+  | `senator_no_party` | "Senator/Senatorka NAME" with "Sekretarz", "Sprawozdawca", "RP" | 10,344,087 | 43,480 |
+  | `stage_direction` | the stenographers' bracketed directions ("(Oklaski)", "(Początek posiedzenia o godz. 10)") | 8,281,651 | 471,173 |
+  | `mp_surname_1919_1939` | "P. Nowicki" in the Sejm of 1919-39 (not before an office) | 6,505,299 | 12,467 |
+  | `sejm_senate_office_head` | heads of the Sejm and Senate offices (base rule) | 5,579,703 | 13,761 |
+  | `sejm_bureau_expert` | BAS and BEOS experts (base rule) | 3,373,664 | 5,918 |
+  | `sejm_senate_marshal` | "Marszałek Sejmu/Senatu" (base rule) | 2,502,494 | 9,317 |
+  | `senator_surname_1919_1939` | "S. Karnicka" in the Senate of 1922-39 | 1,792,371 | 2,567 |
+  | `komentarz_continuation` | an unbracketed stenographer's line continuing a kept speaker in the same turn block | 548,873 | 28,611 |
+  | `sejm_committee_secretary` | "Sekretarz Komisji ... NAME" (base rule) | 543,439 | 8,392 |
+  | `mp` | MP labels with a party tag (base rule) | 3,804 | 13 |
+
+  Evidence for the PPC rules (also in the code comments and on polish-dynaword-v2#54): "P. X" and
+  "S. X" are announced as MPs and senators in the same texts ("Głos ma poseł Nowicki" before "P.
+  Nowicki", "Głos ma s. Karnicka"); "P." before an office in 1919-39 is "Pan" and is cut before the
+  label is classified (12 persons), and "P." in the Senate (17k characters) stays out. A marshal
+  without "Sejmu"/"Senatu" in a sitting of the Sejm or Senate is that chamber's marshal; labels
+  naming a voivodeship, sejmik or board are excluded. A chair's name, and any name that is not a 1-3
+  token name, is checked against the MPs, senators and marshals of the same term zip (headers of the
+  dropped 2019-2023 Sejm included). Case, punctuation, soft hyphens and one-letter tokens are
+  ignored, two parts run together are split ("JanuszPalikot"), and a name that starts with a
+  member's counts ("Jan Bury s. Antoniego"). A member's name of 4 tokens or with a particle ("Piotr
+  van der Coghen") is taken only from the header of a plenary sitting. Chairs who are not members,
+  such as a foreign or ministry committee's chair, are dropped (876 persons, 6,691,887 characters).
+  The historic ministry words were taken from the label census of the whole dump (2026-10-07).
+
+  Dropped, by reason (characters of utterance text):
+
+  | Reason | Characters | What it is |
+  |---|---:|---|
+  | `speaker:unmatched` | 601,219,281 | a named speaker whose role matches no rule (117,972 persons) |
+  | `speaker:no_role` | 84,057,911 | a name without a role in the header (12,222 persons): MP or guest cannot be told |
+  | `komentarz_colon` | 24,479,841 | a stenographer's line with ": ", i.e. an interjection ("Głos z sali: ...") |
+  | `komentarz_unattributed` | 9,757,058 | an unbracketed stenographer's line with no speaker before it in its turn block |
+  | `speaker:role_only_unmatched` | 9,322,256 | a role without a name that matches no rule (8,525 persons) |
+  | `inline_speaker` | 8,416,268 | text after a speaker line inside a turn whose label is not kept (see caveats) |
+  | `speaker:chair_not_member` | 6,691,887 | a named chair who is not an MP or senator of that term |
+  | `speaker:bad_name` | 3,074,332 | a name that is not 1-3 tokens and not a member's (673 persons: ambassadors, witnesses, "Dr NAME, Uniwersytet ...", foreign MPs "Poseł Artur Płokszto z Litwy") |
+  | `speaker:free_unmatched` | 1,782,824 | a free-text header label that no rule keeps |
+  | `komentarz_continuation_dropped` | 1,548,523 | a stenographer's line continuing a dropped speaker |
+  | `inline_label_line` | 352,435 | the speaker lines inside turns themselves |
+
+  The allowlist keeps 3,024,072,101 of 3,774,774,717 characters of utterance text (80.1%). The
+  largest dropped roles: the role-less names above (84.06M), bare "Podsekretarz stanu" (27.39M,
+  65,361 turns) and "Sekretarz stanu" (6.70M) without a ministry - the President's Chancellery uses
+  the same titles, so they cannot be told apart and fail closed -, "Dyrektor" (16.82M),
+  "Wiceminister" (11.80M, 31,147 turns; not in the allowlist), "Prezes" (9.49M), "Wiceprezes NIK"
+  (5.32M), "Sprawozdawca" without "poseł" (4.64M), "Ekspert Komisji" (3.07M), candidates for
+  ambassador (2.91M), representatives of citizens' legislative initiatives (2.35M), the secretaries
+  of state of the President's Chancellery (2.21M) and witnesses of investigative committees
+  (0.91M). Also out: the RCL, ministry departments, heads of agencies other than the constitutional
+  organs, MEPs and the heads of state ("Naczelnik Państwa", "Prezydent RP").
+- **Stage directions** (the "komentarz" speaker): a bracketed direction is kept; any other
+  komentarz line is kept only as the continuation of a kept speaker in the same turn block; a line
+  with ": " (an interjection from the floor) is always dropped.
+- **Speaker lines inside turns**: a `<u>` that ends with ":" and reads as a speaker label switches
+  the speaker until the next speaker change. Such a label is kept only if it matches a rule other
+  than `committee_chair_named` and either names a speaker that the zip's headers keep or puts a
+  title ("ob.", "ks.", "gen.") before the name; this guards against roles that swallow words of a
+  name ("Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk", "Marszałek Polski Józef
+  Piłsudski"). 8,910 such lines: 315 kept by name, 62 by title, 333 refused by the guard, 8,200
+  matching no rule.
+- **PII (which scrubber ran)**: the pattern pass `redact()` of
+  `src/fetch_sejm_committee_transcripts.py` - e-mail -> `[ADRES_EMAIL]`, checksum-valid PESEL, NIP,
+  REGON (9 and 14 digits) and IBAN candidates -> `[DANE_NUMERY]`, labelled phone/fax ->
+  `[DANE_KONTAKTOWE]`. Counted in the shipped shard: **12,733 redactions** (6,859
+  `[DANE_KONTAKTOWE]`, 5,414 `[ADRES_EMAIL]`, 460 `[DANE_NUMERY]`). This is **not**
+  [SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL): interpellations quote citizens' cases
+  by name, so the shard must be re-run through NERGAL before it is admitted to a release.
+- **Short documents**: 440 sittings keep no turn and 164 interpellation records have no text; 37
+  sittings and 583 interpellation records have under 200 characters after the filter and the PII
+  pass. All are dropped; a dropped sitting's turns stay counted under their rule above.
+- **Dedup**: none within the source or against other sources. This source is the reference set
+  that `src/clean_sejm_api_2011_2022.py` deduplicates `sejm_api_2011_2022` against.
+
+## Inclusion argument and caveats
+
+What this adds: a century of Polish parliamentary language - interwar, PRL and post-1989 plenary
+debate, Sejm committee work since 1965, the Senate since 1922, and 1.34B characters of
+interpellations and ministerial replies. 1.61B tokens.
+
+Changes against the shard shipped up to v0.2.5 (SpeakLeash's unlabelled `PPC_corpus`: 324,622
+records / 4,492,746,014 characters / 1,646,835,986 tokens, no authors): rebuilt from IPI PAN's
+labelled dump; guests and other non-official speakers removed from the sittings; 1919-1989 and the
+Senate of 2019-2025 added; the Sejm from 2019 left to the `sejm_*` sources; interpellation authors
+recorded; multi-day and undated records dated.
+
+Caveats: the allowlist is the conservative reading of art. 4(2), and it reads the printed role
+label, not the person: a name slot accepts any 1-3 token name, and only committee chairs and longer
+or unusual names are checked against the members of the term. Officials whose name is damaged (OCR "Teresa
+MaIczewska", "Krzysztof Michałkiewicz:", the typo "Piotr Van der Koghen") fail that check: about
+0.13M characters in a hand review of the 0.39M characters of such names whose role a rule keeps.
+Officials the rules miss are dropped with the guests:
+bare "Podsekretarz stanu"/"Sekretarz stanu" (34.09M characters), "Wiceminister" (11.80M) and the
+role-less names (84.06M, possibly including MPs; a member check like the chairs' could recover
+those).
+The speaker-line check inside turns errs towards dropping: on a character-weighted sample of 80
+refused lines (seed 20261007), 47 were guests, 28 were prose or headings ending with a colon (the
+secretary's "Dekrety przedstawione przez Ministerstwo Skarbu:" in 1919, "Koreferat przedstawił
+poseł X (PZPR)") and 5 were officials whose label the rules miss, so about two fifths of the
+8,416,268 characters dropped after such lines is official text lost. A guest's label that does not
+stand alone in its utterance is not detected and stays inside the previous turn (not measured).
+Dates: one term-3 committee sitting (`199701-sjm-nusxx-00004-01`) is dated 1988-07-02 in the dump
+and kept as dated; the 226,062 undated interpellation records carry their term's range, not a day.
+The dump's Sejm interpellations end on 2019-04-04 and the dump has none of term 9, so Sejm
+interpellations from April 2019 to the start of `sejm_interpellations` are in no source.
+Quotations of statutes, prints and citizens' letters are embedded and not filtered (near-dedup
+against `dziennik_ustaw` and a benchmark-overlap check remain targets). PII treatment is
+pattern-based (see above). Not lawyer-signed-off. Training benefit is an untested hypothesis.
+
+Limitations: records are sitting documents, not turns; the order of kept turns is preserved, and
+`ppc_path` in `parliamentary.attribution.jsonl` links each record to the TEI document with the full
+sitting. Figures: `parliamentary.stats.json`.

data/parliamentary/parliamentary.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8
-size 1732312807
+oid sha256:5f21252ee65425a77cdd48bdb964171fb06cd6cf0c59c0b882be995d84dcec7c
+size 1520421405

data/parliamentary/parliamentary.stats.json

@@ -1,16 +1,158 @@
 {
-  "read": 324622,
-  "kept": 324622,
-  "drop_short": 0,
-  "drop_lang": 0,
-  "drop_dup": 0,
-  "drop_ocr": 0,
-  "chars": 4492746014,
-  "tokens": 1646835986,
-  "licenses": {
-    "public-domain (official documents)": 324622
+  "added": "2026-06-15",
+  "authors_with_value": 298185,
+  "chars": 4370190797,
+  "chars_by_category": {
+    "II RP|Sejm|Posiedzenie plenarne": 156362281,
+    "II RP|Senat|Posiedzenie plenarne": 43495751,
+    "III RP|Sejm|Interpelacja": 259034011,
+    "III RP|Sejm|Komisja": 1177690020,
+    "III RP|Sejm|Odpowiedź na interpelację": 692623596,
+    "III RP|Sejm|Odpowiedź na zapytanie": 317816835,
+    "III RP|Sejm|Posiedzenie plenarne": 937187974,
+    "III RP|Sejm|Uroczyste Spotkanie": 12071,
+    "III RP|Sejm|Uroczyste zgromadzenie posłów i senatorów": 8185,
+    "III RP|Sejm|Wspólne posiedzenie Sejmu i Senatu": 28091,
+    "III RP|Sejm|Zapytanie": 65680680,
+    "III RP|Sejm|Zgromadzenie Narodowe": 3480455,
+    "III RP|Sejm|Zgromadzenie posłów i senatorów": 61564,
+    "III RP|Senat|Komisja": 143526734,
+    "III RP|Senat|Posiedzenie plenarne": 346591211,
+    "PRL/III RP|Sejm|Posiedzenie plenarne": 33058418,
+    "PRL/III RP|Senat|Posiedzenie plenarne": 17650518,
+    "PRL|Krajowa Rada Narodowa|Posiedzenie Plenarne": 1093152,
+    "PRL|Sejm|Komisja": 62299011,
+    "PRL|Sejm|Posiedzenie plenarne": 112036227,
+    "PRL|Senat|Posiedzenie plenarne": 454012
+  },
+  "created_max": "2025-04-24",
+  "created_max_by_house": {
+    "Krajowa Rada Narodowa": "1946-09-23",
+    "Sejm": "2019-10-16",
+    "Senat": "2025-04-24"
+  },
+  "created_min": "1919-02-10",
+  "created_min_by_house": {
+    "Krajowa Rada Narodowa": "1944-12-31",
+    "Sejm": "1919-02-10",
+    "Senat": "1922-11-28"
+  },
+  "date_max_by_house": {
+    "Krajowa Rada Narodowa": "1946-09-23",
+    "Sejm": "2019-10-16",
+    "Senat": "2025-04-24"
+  },
+  "date_min_by_house": {
+    "Krajowa Rada Narodowa": "1944-12-31",
+    "Sejm": "1919-02-10",
+    "Senat": "1922-11-28"
+  },
+  "docs_by_category": {
+    "II RP|Sejm|Posiedzenie plenarne": 1021,
+    "II RP|Senat|Posiedzenie plenarne": 323,
+    "III RP|Sejm|Interpelacja": 114126,
+    "III RP|Sejm|Komisja": 31362,
+    "III RP|Sejm|Odpowiedź na interpelację": 114472,
+    "III RP|Sejm|Odpowiedź na zapytanie": 38092,
+    "III RP|Sejm|Posiedzenie plenarne": 2070,
+    "III RP|Sejm|Uroczyste Spotkanie": 1,
+    "III RP|Sejm|Uroczyste zgromadzenie posłów i senatorów": 3,
+    "III RP|Sejm|Wspólne posiedzenie Sejmu i Senatu": 3,
+    "III RP|Sejm|Zapytanie": 38051,
+    "III RP|Sejm|Zgromadzenie Narodowe": 25,
+    "III RP|Sejm|Zgromadzenie posłów i senatorów": 8,
+    "III RP|Senat|Komisja": 4521,
+    "III RP|Senat|Posiedzenie plenarne": 1375,
+    "PRL/III RP|Sejm|Posiedzenie plenarne": 61,
+    "PRL/III RP|Senat|Posiedzenie plenarne": 60,
+    "PRL|Krajowa Rada Narodowa|Posiedzenie Plenarne": 6,
+    "PRL|Sejm|Komisja": 2433,
+    "PRL|Sejm|Posiedzenie plenarne": 461,
+    "PRL|Senat|Posiedzenie plenarne": 1
+  },
+  "drop_prefixes": [
+    "2019-2023/sejm/",
+    "2023-2027/sejm/"
+  ],
+  "dropped_chars": {
+    "inline_label_line": 352435,
+    "inline_speaker": 8416268,
+    "komentarz_colon": 24479841,
+    "komentarz_continuation_dropped": 1548523,
+    "komentarz_unattributed": 9757058,
+    "speaker:bad_name": 3074332,
+    "speaker:chair_not_member": 6691887,
+    "speaker:free_unmatched": 1782824,
+    "speaker:no_role": 84057911,
+    "speaker:role_only_unmatched": 9322256,
+    "speaker:unmatched": 601219281
+  },
+  "dropped_docs": {
+    "empty_interpellation": 164,
+    "empty_sitting": 440,
+    "prefix_sejm_2019_2027": 5940,
+    "short_interpellation": 583,
+    "short_sitting": 37
+  },
+  "dump": "2025-05-21",
+  "inline_labels": {
+    "free": 315,
+    "free_guard": 333,
+    "free_titled": 62,
+    "free_unmatched": 8200
+  },
+  "kept": 348475,
+  "kept_chars_by_rule": {
+    "committee_chair_named": 46499132,
+    "constitutional_organ_head": 34642977,
+    "government_historic": 41519929,
+    "government_member": 87399387,
+    "komentarz_continuation": 548873,
+    "legislative_petitions_staff": 32427046,
+    "marshal_no_house": 190540640,
+    "mp": 3804,
+    "mp_committee_chair": 158002628,
+    "mp_no_party": 1694953227,
+    "mp_surname_1919_1939": 6505299,
+    "sejm_bureau_expert": 3373664,
+    "sejm_committee_secretary": 543439,
+    "sejm_legislator": 20914344,
+    "sejm_senate_marshal": 2502494,
+    "sejm_senate_office_head": 5579703,
+    "senator": 315926447,
+    "senator_no_party": 10344087,
+    "senator_surname_1919_1939": 1792371,
+    "stage_direction": 8281651,
+    "state_secretary": 325593817,
+    "state_secretary_historic": 36177142
+  },
+  "komentarz": {
+    "komentarz_colon": 24479841,
+    "komentarz_continuation": 548873,
+    "komentarz_continuation_dropped": 1548523,
+    "komentarz_unattributed": 9757058,
+    "stage_direction": 8281651
   },
-  "authors_with_value": 0,
   "license": "public-domain (official documents)",
-  "stats_recomputed_from_parquet": true
+  "licenses": {
+    "public-domain (official documents)": 348475
+  },
+  "persons": {
+    "bad_name": 673,
+    "bad_name_member": 349,
+    "chair_not_member": 876,
+    "commentary": 44211,
+    "free_titled": 191,
+    "free_unmatched": 351,
+    "no_role": 12222,
+    "role_only": 5836,
+    "role_only_unmatched": 8525,
+    "structured": 598820,
+    "unmatched": 117972
+  },
+  "persons_p2_fallback": 3127,
+  "persons_p_strip": 12,
+  "redactions": 12733,
+  "sejm_coverage_end": "2019-11-11",
+  "tokens": 1606998487
 }

data/sejm_api/sejm_api.md

@@ -42,7 +42,8 @@ source. No unverified upstream Creative Commons license is asserted.
 
 ## Temporal novelty and deduplication
 
-`parliamentary` ends on `2019-12-31`. Every contributed
+The Sejm material of `parliamentary` ends with term 8 (`2019-11-11`; its
+Senate material is not compared: this source is Sejm-only). Every contributed
 record is dated on or after `2023-01-01`, so its date range does not overlap it.
 Exact duplicate speech texts within the contribution are removed using
 SHA-1 fingerprints; this is not a claim of global cross-domain near-deduplication.

data/sejm_committee_transcripts/sejm_committee_transcripts.md

@@ -32,9 +32,9 @@ heads of constitutional organs, Sejm and Senate staff; see "Speaker allowlist"):
   words are not left inside an official's record.
 - **Register**: prepared official transcript of spoken Polish - multi-party
   discussion with questions, answers and interruptions, formal address formulas,
-  occasional read-out quotations of documents. Not plenary speeches: this is the
-  committee working register that the plenary-only `parliamentary` / `sejm_api`
-  sources do not contain. Not OCR'd (born-digital PDFs), not machine-translated.
+  occasional read-out quotations of documents. Not plenary speeches: the
+  committee working register of terms 9-10, which neither `parliamentary` (Sejm
+  committees up to term 8) nor the plenary-only `sejm_api` contains. Not OCR'd (born-digital PDFs), not machine-translated.
 - **Time span**: sitting dates `2019-11-14` - `2026-09-03` (term 9: 313,699
   records; term 10: 300,023). 3,790 distinct speaker labels
   (role + name as printed in the transcript).

data/sejm_interpellations/sejm_interpellations.md

@@ -77,10 +77,10 @@ diacritic ratio, exact sha1).
 
 ## Why include it
 
-The corpus already has spoken Sejm (`parliamentary`, `sejm_api`). This adds
+The corpus already has spoken Sejm (`parliamentary`, `sejm_api`) and the
+interpellations of terms 3-8 (in `parliamentary`, up to 2019-04-04). This adds
 the written Q&A register for the current term: longer, formal, ministry-voiced
-replies that do not appear in the speech shards — the argumentative
-question/answer pair is a document type the corpus otherwise lacks entirely.
+replies that do not appear in the speech shards.
 Caveats for downstream users: single term (10th, 2023-11-15 – 2026-09-03), and
 interpellations quote constituency casework that can name private citizens (see
 Privacy below — a NERGAL pass is a release gate).

src/clean_sejm_committee_transcripts.py

@@ -116,12 +116,17 @@ def role_of(label: str, given: set[str]) -> str:
     return " ".join(tokens[:cut]) + suffix
 
 
-def roles_table(label_stats: dict[str, tuple[int, int, str | None]]) -> list[list]:
-    """CSV rows from {label: (turns, characters, rule or None)}, biggest first."""
-    given = given_names(label_stats)
+def roles_table(label_stats: dict, roles: dict | None = None) -> list[list]:
+    """CSV rows from {key: (turns, characters, rule or None)}, biggest first.
+
+    `roles` maps each key to its role; without it the keys are speaker labels and the role is the
+    label without the person's name (role_of)."""
+    if roles is None:
+        given = given_names(label_stats)
+        roles = {label: role_of(label, given) for label in label_stats}
     groups: dict[tuple[str, str, str], list[int]] = defaultdict(lambda: [0, 0, 0])
-    for label, (turns, characters, rule) in label_stats.items():
-        group = groups[(role_of(label, given), "include" if rule else "exclude", rule or "")]
+    for key, (turns, characters, rule) in label_stats.items():
+        group = groups[(roles[key], "include" if rule else "exclude", rule or "")]
         group[0] += turns
         group[1] += characters
         group[2] += 1

src/fetch_parliamentary.py

@@ -0,0 +1,667 @@
+"""parliamentary: the Polish Parliamentary Corpus (PPC) rebuilt from IPI PAN's speaker-labelled TEI dump.
+
+Upstream: the per-term TEI zips that the PPC page (https://clip.ipipan.waw.pl/PPC) links, dump of 2025-05-21
+(https://kdp.ipipan.waw.pl/static/ppcdump-tei/<term>-tei.zip), pinned below by size and SHA-256. It replaces
+the earlier unlabelled copy of PPC taken from SpeakLeash (`PPC_corpus`), whose committee transcripts mixed
+guests' statements with the official speakers' (polish-dynaword-v2#54, option C).
+
+Scope (polish-dynaword-v2#54, decided 2026-10-07: "1A / 2A but document / 3 A / 4A / 5 A"):
+- 1A: every term of the dump, 1919-2025, except the Sejm of 2019-2023 and 2023-2027 (DROP_PREFIXES), which
+  sejm_api, sejm_committee_transcripts and sejm_interpellations cover. Kept: the Sejm and Senate of the
+  Second Republic, the Krajowa Rada Narodowa and the Sejm of the PRL, the Sejm and Senate since 1989 and the
+  Senate of 2019-2025.
+- 2A: in sittings (plenary and committee) only turns by MPs and senators, members of the government, heads
+  of constitutional organs and Sejm/Senate staff are kept: the sejm_committee_transcripts allowlist
+  (classify_speaker) plus PPC_RULES below, each with its evidence. Everything else is dropped, among it
+  committee guests, witnesses of investigative committees, the President's Chancellery (KPRP), heads of
+  agencies other than the constitutional organs, the Government Legislation Centre (RCL), ministry
+  departments and the heads of state ("Naczelnik Państwa", "Prezydent RP").
+- 3A: the allowlist applies to plenary sittings too.
+- 4A: interpellations, questions and the government's replies are kept whole (no speaker filter).
+- 5A: this source stays the dedup reference of sejm_api_2011_2022 (clean_sejm_api_2011_2022.py re-pins it).
+
+Speakers. A sitting's header lists its speakers (<person>): role (roleName), forenames and surnames. PPC
+strips the party tags that the base allowlist keys MPs on, so a person is classified by role + a placeholder
+name ("Jan Maria Kowalski"), never by its own name: a role that swallows words of a name ("Minister Spraw
+Zagranicznych Ukrainy" + a name) then fails because the placeholder no longer fits a 2-3 token name. The
+person's own name that is not a 1-3 token name ("bad_name": "Piotr Van der Coghen", "Jan Bury s. Antoniego",
+"Artur Płokszto z Litwy") is kept only if it is, or starts with, the name of an MP, senator or marshal of the
+same zip (is_member, the check a named committee chair gets). Labels that are free text (persName
+without parts, and speaker lines inside a turn, "Poseł Kowalski:") are classified as they stand but kept
+only when the name closing them belongs to a speaker the header keeps in the same zip (absorption guard).
+
+Stage directions (the "komentarz" speaker): a bracketed direction ("(Oklaski)") is kept; any other
+komentarz turn is kept only as the continuation of a kept speaker in the same turn block; a komentarz that
+contains ": " (an interjection "Głos z sali: ...") is always dropped.
+
+Usage: python3 src/fetch_parliamentary.py [--dump DIR] [--out DIR] [--download] [--workers N]
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import functools
+import json
+import os
+import re
+import shutil
+import sys
+import unicodedata
+import urllib.request
+import xml.etree.ElementTree as ET
+import zipfile
+from collections import Counter, defaultdict
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+from clean_sejm_committee_transcripts import role_of, roles_table, write_roles
+from fetch_sejm_committee_transcripts import (
+    _GOVERNMENT_BODY, _MINISTRY_ABBREVIATION, _MINISTRY_WORDS, _NAME, _NOT_STATE_SECRETARY,
+    _LO, _OFFICE_WORD, _STATE_OFFICE, _STATE_PREFIX, _STATE_RANK, _STATE_SECRETARY_WORDS, _TOK, _UP, FIELDS, LICENSE,
+    classify_speaker, count_tokens, is_label, redact,
+)
+from sejm_api_common import MIN_CHARS, PARLIAMENTARY_SEJM_END, sha256_file, write_json
+
+SOURCE = "parliamentary"
+ADDED = "2026-06-15"
+DUMP_URL = "https://kdp.ipipan.waw.pl/static/ppcdump-tei/{term}-tei.zip"
+# (term, bytes, sha256) of the 2025-05-21 dump, as downloaded on 2026-10-07.
+MANIFEST = (
+    ("1919-1922", 218013940, "6be0273eccd20989add49e1ca106c5724b64c89c38f9a20f92e97c0dfca1011e"),
+    ("1922-1927", 333034736, "2fcfa873fb45e5f6647889f6fe7417990b3aab6824ebc839f22699a139a15fa0"),
+    ("1928-1930", 107456995, "2816f20b487636e2a879298dfa2fe15d7226641ed8a7f5df3d93fd09985bf9b6"),
+    ("1930-1935", 200928182, "be98a5636958b01be0a0197a6905e812045a282889378b3541839dbfeb1e025f"),
+    ("1935-1938", 126925493, "ce3440542eb757e7decf43e16d8a3f0266ee329f35df28bd180867b936de5f94"),
+    ("1938-1939", 29077576, "d3d115b3298b43d5df405bb8a3ab39ef247c2806af27289f857d71695d9711d6"),
+    ("1943-1947", 575193, "e15f69b186107cd545ad6f1b099fec89a0993a504f02a275b297da9bcf59ba80"),
+    ("1947-1952", 75320036, "0d9f1d60cdf8e6f425f6b5f86d655eb1ca9a5ec935cc6e51696d74ae5506aced"),
+    ("1952-1956", 32602235, "8e5c0be0092bb94b57f8e6fb51ad2b88f434d28f0619b7b55a308b4f587b0730"),
+    ("1957-1961", 76796260, "be2297b8de8ba5f95b7ed88172b3123bcf81d07c4f8611d1f334ba309e01ded3"),
+    ("1961-1965", 39972140, "839599ae0ca23ccebd142a94ddaf41b047e29dc86d7606cc56b094c61775646b"),
+    ("1965-1969", 60609250, "ce81e6ed59e4f1a6b67feab64230ed9d29e795a5e5000dd73181505d93074360"),
+    ("1969-1972", 16901879, "18c6eddef1941d859b16b7e2ad72383e23953ee571a593a19610d01c657206cd"),
+    ("1972-1976", 70960374, "f6d2ba032f47db38cb5ac8ccf8c72299ea43543f52fe70f9e8102fedf103ed4c"),
+    ("1976-1980", 82719414, "2ccd2cc4e4b8bdc627c393419244988f0842c03523e1c4b8ce85f59aeb414f7d"),
+    ("1980-1985", 305014407, "ec844f2968fb091ccbb1efaf9cc2730900b37aad4208e16876fe785926cd103b"),
+    ("1985-1989", 283699561, "94eb7a73f0e688582001d0687e4aeaa87f0d55258715caba07b570a02c431ff6"),
+    ("1989-1991", 322944949, "16aadc2ef1813d1a695049571da3c5af540655e2a82698f955fe382846d4cbbf"),
+    ("1991-1993", 290833981, "1ceebebde162dcc7e26994de8420518809d67c33cd92220a4fb01ef703f00c7d"),
+    ("1993-1997", 2083076422, "e7cd0805b1c2156de66335af389e59d72d728ba59eceeb331168ea162c654ad3"),
+    ("1997-2001", 2596857801, "d9f71ce6899cf29746abceef0c8f4eb990c36e1a59c7c4677c131a65fede7cd9"),
+    ("2001-2005", 3029260742, "6a4e409c7173b1f607dec87c932f69a2f6a254cc4fb28905de09f9b26c30b9b9"),
+    ("2005-2007", 1504583970, "eb0670e07302b03417073fddc2b7d6f253d646f7f05b8d4c0a044837d42950ea"),
+    ("2007-2011", 3613775393, "239a2d617440d9a1b47dc6d26c53d80d6399579bebb688887406e4ff31f62c92"),
+    ("2011-2015", 4119031719, "7b0f823562137e4d07dbaa3ef7ff1519f6f36d79350a5e319aef64ae3dcabccf"),
+    ("2015-2019", 3909365702, "79ef4c1845c37c3c08d569daf8066ba6b130d9ad6f7d1000db5a937fdfbfe5e6"),
+    ("2019-2023", 2086326237, "21d987b939728c08fa9d08df37fb3851f321b49b5da0102c59ef5e7eb2629932"),
+    ("2023-2027", 792882488, "61716f169d4378b158a54fb3f6c93c4ee69b876fab04811807d16bd0c435578c"),
+)
+DROP_PREFIXES = ("2019-2023/sejm/", "2023-2027/sejm/")  # 1A: the sejm_* sources cover the Sejm from term 9
+# Interpellations of terms 3-7 carry no date: `created` is the term (Sejm terms, first to last day).
+UNDATED_TERM_RANGES = {
+    "3": "1997-10-20, 2001-10-18", "4": "2001-10-19, 2005-10-18", "5": "2005-10-19, 2007-11-04",
+    "6": "2007-11-05, 2011-11-07", "7": "2011-11-08, 2015-11-11",
+}
+T = "{http://www.tei-c.org/ns/1.0}"
+XID = "{http://www.w3.org/XML/1998/namespace}id"
+PLACEHOLDER = " Jan Maria Kowalski"  # P3: role + a 3-token name stands in for the person's own name
+PLACEHOLDER_2 = " Jan Kowalski"  # P2: only for committee secretaries, whose rule takes exactly two tokens
+COMMENTARY = "komentarz"
+REDACTION_TAGS = re.compile(r"\[(?:ADRES_EMAIL|DANE_NUMERY|DANE_KONTAKTOWE)\]")
+_DATE_PART = re.compile(r"(?:(\d{4})-)?(?:(\d{2})-)?(\d{2})")
+
+# ------------------------------------------------------------------ PPC rules (2A)
+# Chars below are the census of the whole dump (2026-10-07, utterance text of the label, all terms).
+# Historic ministry words ("Minister Skarbu", "Minister Wyznań Religijnych i Oświecenia Publicznego",
+# "Minister Przemysłu Chemicznego") and "RP" ("Minister Finansów RP") on top of the base list.
+_PPC_MINISTRY_WORDS = _MINISTRY_WORDS + "|" + "|".join((
+    "RP skarbu państwa transportu opieki budownictwa przekształceń własnościowych ochrony zasobów naturalnych "
+    "przestrzennej gospodarczej współpracy zagranicą handlu wewnętrznego usług inwestycji łączności "
+    "regionalnego wyznań religijnych oświecenia publicznego reform rolnych żywnościowej oświaty wychowania "
+    "komunikacji wojskowych sztuki płac socjalnych chemicznego lekkiego hutnictwa terenowej poczt telegrafów "
+    "socjalnej rynku energetyki zagranicznego spożywczego skupu materiałów budowlanych górnictwa maszynowego "
+    "robót publicznych aprowizacji techniki kombatantów mieszkalnictwa pomocy postępu naukowo-technicznego "
+    "ciężkiego węglowego leśnictwa komunalnej").split())
+# Titles that may stand before a name ("Poseł ks. Kowalski", "Minister gen. Sikorski", "Poseł p. Kowalski").
+_HON = r"(?: (?:ks\.?|gen\.|dr\.?|p\.|ob\.|prof\.|inż\.|mgr))*"
+_PERSON = rf",?{_HON} (?:{_NAME}|{_TOK})"
+# A free label whose name follows a title ("Poseł ob. Ochab", "Prezes Rady Ministrów ob. Osóbka-Morawski"): the
+# title marks where the name starts, so the role before it can take the placeholder like a header person's.
+# The Krajowa Rada Narodowa (1943-47) has only such labels, no structured persons for the name guard.
+_TITLED = re.compile(rf"(?P<role>.+ (?:ks\.?|gen\.|dr\.?|p\.|ob\.|prof\.|inż\.|mgr)) (?P<name>{_NAME}|{_TOK})")  # a full name or a lone surname, optionally after a comma
+_MINISTER = rf"Minist(?:er|ra)(?:[ ,–-]+(?i:{_PPC_MINISTRY_WORDS}))*"
+_PREMIER = r"(?:Wice)?[Pp]rezes (?:Rady Ministrów|RM)|Prezydent Ministrów|Wicepremier"
+# No marker of the President's Chancellery, of local government or of other bodies sharing a word.
+_NOT_SURNAME_ONLY = (r"(?!.*(?:Minist|Prezes|Premier|Wicepremier|Marsza|Sekretarz|Podsekretarz|Poseł|Senator"
+                     r"|[Rr]eferent|Przewodnicz|Sprawozd|Kierown|Dyrekt|Genera|Prokur))")
+_SENATE_UNIT = (r"(?:Biurze Legislacyjnym|Dziale Petycji i Korespondencji w Biurze "
+                r"(?:Analiz, Dokumentacji i Korespondencji|Analiz i Petycji|Komunikacji Społecznej))")
+_SENATE_STAFF = (r"(?:Główn[ya] |Starsz[ya] )?(?:Legislator(?:ka)?|Ekspert(?:ka)?(?: do [Ss]praw "
+                 r"(?:Legislacji|Oceny Skutków Regulacji))?|[Ss]pecjalist(?:a|ka)) w " + _SENATE_UNIT)
+_PPC_STATE_BODY = (rf"(?:[ ,–-]+(?:(?i:{_STATE_SECRETARY_WORDS}|{_PPC_MINISTRY_WORDS}|urzędzie|urzędu)"
+                   rf"|{_MINISTRY_ABBREVIATION}|URM))*")
+_CHAIR_OF = r"(?: (?:Komisji|Podkomisji)(?: [^\W\d_]+,?){0,12})?"
+# The base deputy chair with a capital "Przewodniczącego" too (Senate committees 2015-2023, 2.89M chars).
+_PPC_CHAIR_DEPUTY = r"(?:(?:[Pp]ierwsz[ya]|[Dd]rug[ia]) )?[Zz]astęp(?:ca|czyni) [Pp]rzewodnicząc(?:ego|ej)"
+
+# (rule id, pattern matched with fullmatch, (system, house) the rule is limited to; None = any). After the
+# base allowlist; first match wins.
+PPC_RULES = [
+    # MPs without a party tag (PPC drops it): "Poseł Jan Kowalski", "Poseł Sprawozdawca Jan Kowalski",
+    # "Posłanka Wiceprzewodnicząca Anna Nowak", "Sekretarz poseł Jan Kowalski", "Sprawozdawca p. Kowalski",
+    # "Przewodniczący poseł ob. Szwalbe" (KRN, 32.6k chars), "Sekretarz Poseł Jan Kowalski" (1993-2019, 1.97M),
+    # the typo "Poeł Jan Kowalski" (707k).
+    # A "Poseł" label is an MP's by its own words; in 1919-39 often surname-only ("Poseł Nowicki").
+    ("mp_no_party", re.compile(
+        rf"(?:[Pp]oseł|[Pp]osłanka|Poeł)(?: (?:[Ss]prawozdawca|[Ww]nioskodawca|[Ss]ekretarz|(?:[Ww]ice)?[Pp]rzewodnicząc[ya]))?{_PERSON}"
+        rf"|(?:Sekretarz|Sprawozdawca|(?:[Ww]ice)?[Pp]rzewodnicząc[ya])(?: [Pp]oseł| [Pp]osłanka| p\.){_PERSON}"), (None, None)),
+    # The Sejm of 1919-39 prints MPs as "P. Nowicki" (6.77M chars). Checked: the plenary text announces the
+    # same people as MPs ("Głos ma poseł Nowicki" before "P. Nowicki"). Not when the label names an office.
+    ("mp_surname_1919_1939", re.compile(rf"P\.{_HON} {_NOT_SURNAME_ONLY}(?:{_NAME}|{_TOK})"), ("II RP", "Sejm")),
+    ("senator_no_party", re.compile(
+        rf"(?:Senator|Senatorka)(?: (?:[Ss]ekretarz|[Ss]prawozdawca|RP))?{_PERSON}"), (None, None)),
+    # The Senate of 1922-39 prints senators as "S. Karnicka" (1.51M chars), announced as "Głos ma s. Karnicka".
+    # ("P." in the Senate, 17k chars, is "Pan" and stays out.)
+    ("senator_surname_1919_1939", re.compile(rf"S\.{_HON} {_NOT_SURNAME_ONLY}(?:{_NAME}|{_TOK})"), ("II RP", "Senat")),
+    # The chamber's own marshals without "Sejmu"/"Senatu" ("Marszałek", "Wicemarszałek Jan Kowalski",
+    # "Marszałek Senior", the 1919 typo "Marszalek poseł Ferdynand Radziwiłł"), never a voivodeship marshal.
+    ("marshal_no_house", re.compile(
+        r"(?!.*(?i:wojew|sejmik|zarząd|SSWW))(?:Wicemarszałkini|(?:Wice)?[Mm]arsza[łl]ek)(?:[- ][Ss]enior)?"
+        r"(?: (?:Sejmu|Senatu)(?: (?:RP|Rzeczypospolitej Polskiej|Ustawodawczego|PRL))?)?(?: poseł)?,?"
+        rf"{_HON}(?: (?:{_NAME}|{_TOK}))?"), (None, None)),
+    # Members of the government before 1989 and since, under their historic titles: "Prezes Rady Ministrów,
+    # Minister Spraw Wewnętrznych Jan Kowalski", "Prezydent Ministrów" (1919-21), "Wicepremier", "Kierownik
+    # Ministerstwa Skarbu", "Minister - Szef Urzędu Rady Ministrów", "Minister - Członek Rady Ministrów".
+    ("government_historic", re.compile(
+        rf"(?:{_PREMIER})(?:,? (?:i )?{_MINISTER})?{_PERSON}|{_MINISTER}{_PERSON}"
+        rf"|Kierownik Ministerstwa(?:[ ,–-]+(?i:{_PPC_MINISTRY_WORDS}))+{_PERSON}"
+        rf"|Minist(?:er|ra) ?[—–-] ?(?:[Ss]zef Urzędu Rady Ministrów|Kierownik|Członek Rady Ministrów)(?: {_OFFICE_WORD}){{0,14}}{_PERSON}"
+        rf"|Szef Urzędu Rady Ministrów{_PERSON}"), (None, None)),
+    # Secretaries/undersecretaries of state as in the base rule, with the historic ministry words and the
+    # Urząd Rady Ministrów (the PM's chancellery before KPRM) as a government body. The President's
+    # Chancellery stays out (_NOT_STATE_SECRETARY).
+    ("state_secretary_historic", re.compile(
+        rf"(?!.*{_NOT_STATE_SECRETARY})(?=.*(?:{_GOVERNMENT_BODY}|Urzęd\w* Rady Ministrów|URM))"
+        rf"(?:(?:{_STATE_PREFIX})?{_STATE_RANK}{_PPC_STATE_BODY}(?:{_STATE_OFFICE} {_NAME}|{_PERSON})"
+        rf"|{_NAME} {_STATE_RANK}{_PPC_STATE_BODY})"), (None, None)),
+    # Sejm and Senate legislative and petitions staff. Evidence (chars): Senate "Główny Legislator w Biurze
+    # Legislacyjnym w Kancelarii Senatu" 10.79M, "Ekspert do spraw Legislacji" 1.59M, "Główny Ekspert" 771k,
+    # "Starszy Legislator" 466k, petitions specialists ~3.6M, "Kancelarii Senatu" without "w" 100k, OSR 77k;
+    # Sejm "Przedstawiciel Biura Legislacyjnego KS" 4.87M (named 3.88M), "Przedstawicielka" 1.49M + 733k,
+    # "Kancelarii Sejmu" forms 325k + 81k, "Legislator w BL KS" 79k.
+    ("legislative_petitions_staff", re.compile(
+        rf"Przedstawiciel(?:ka)? Biura Legislacyjnego (?:KS|Kancelarii (?:Sejmu|Senatu))(?:,? {_NAME})?"
+        rf"|Dyrektor Biura Legislacyjnego Kancelarii Sejmu, {_NAME}"
+        rf"|Legislator(?:ka)? w BL KS {_NAME}"
+        rf"|{_SENATE_STAFF}(?: w)? Kancelarii Senatu {_NAME}"
+        rf"|Kierownik Działu Petycji i Korespondencji w Biurze Komunikacji Społecznej w Kancelarii Senatu {_NAME}"),
+     (None, None)),
+    # The same Senate staff without "Kancelarii Senatu" (102k chars), only in the Senate's own transcripts.
+    ("legislative_petitions_staff", re.compile(rf"{_SENATE_STAFF} {_NAME}"), (None, "Senat")),
+    # A committee chair named in the label: kept only if the same forenames and surnames are an MP or a
+    # senator in the same term (chair_is_member); a foreign or ministry committee's chair is not.
+    ("committee_chair_named", re.compile(
+        rf"(?:Wice)?[Pp]rzewodnicząc[ya]{_CHAIR_OF}(?: obradom)?{_PERSON}|{_PPC_CHAIR_DEPUTY}{_CHAIR_OF}{_PERSON}"),
+     (None, None)),
+]
+MEMBER_RULES = {"mp", "senator", "sejm_senate_marshal", "mp_committee_chair", "mp_no_party",
+                "mp_surname_1919_1939", "senator_no_party", "senator_surname_1919_1939", "marshal_no_house"}
+STAGE_DIRECTION = re.compile(r"\(.*\)\.?")
+# A plenary header name that _NAME refuses but that still makes its MP a member: 2-4 tokens, a particle that
+# may take "der" ("Piotr Van der Coghen"), no lowercase word ("Artur Płokszto z Litwy").
+_LONG_NAME = re.compile(rf"{_TOK}(?: (?:(?:[Vv]el|de|von|van)(?: der)? )?{_TOK}){{1,3}}")
+_CAMEL = re.compile(rf"(?<=[{_LO}])(?=[{_UP}][{_LO}])")  # two parts run together: "JanuszPalikot"
+
+
+def _classify(label, system, house):
+    rule = classify_speaker(label)
+    if rule:
+        return rule
+    for rule_id, pattern, (only_system, only_house) in PPC_RULES:
+        if only_system in (None, system) and only_house in (None, house) and pattern.fullmatch(label):
+            return rule_id
+    return None
+
+
+@functools.lru_cache(maxsize=None)
+def classify_label(label, system, house):
+    """(rule id or None, whether a leading "P. " was cut) of a PPC speaker label in NFC.
+
+    In 1919-39 "P." also stands for "Pan" before an office ("P. Minister Skarbu ..."): when nothing
+    matches, the label is classified again without it."""
+    label = unicodedata.normalize("NFC", label)
+    rule = _classify(label, system, house)
+    if rule is None and system == "II RP" and label.startswith("P. "):
+        rule = _classify(label[3:], system, house)
+        return rule, rule is not None
+    return rule, False
+
+
+def sitting_days(date):
+    """ISO days of a <date>: "1938-11-28", or a multi-day sitting as the dump writes it ("1938-11-28 i 29",
+    "1990-09-12, 13 i 14", "1952-07-31 i 08-01", "1989-07-28, 29, 31 i 1989-08-01"); a short part takes the
+    year and month of the part before it. Anything else raises."""
+    days, year, month = [], None, None
+    for part in re.split(r",\s*|\s+i\s+", date):
+        match = _DATE_PART.fullmatch(part)
+        if not match or (year is None and not match[1]) or (match[1] and not match[2]):
+            raise ValueError(f"unexpected date {date!r}")
+        year, month = match[1] or year, match[2] or month
+        days.append(datetime.date(int(year), int(month), int(match[3])).isoformat())
+    return days
+
+
+def collapse(text):
+    return " ".join(text.split())
+
+
+def note(bibl, kind):
+    element = bibl.find(f"{T}note[@type='{kind}']")
+    return collapse(element.text or "") if element is not None else ""
+
+
+# ------------------------------------------------------------------ speakers
+class Speakers:
+    """The speakers of one zip: per-person verdicts, plus the names the free-label guard trusts."""
+
+    def __init__(self, stats):
+        self.stats = stats
+        self.members = set()  # name_key() of every MP/senator/marshal, any doc of the zip
+        self.kept_names = set()  # "Forename Surname" of every kept structured person
+        self.kept_labels = set()
+
+    def structured(self, person, system, house):
+        """(label, role, rule or None, reason, key) of a header person (rule None: dropped)."""
+        pn = person.find(f"{T}persName")
+        label = collapse(" ".join(pn.itertext())) if pn is not None else ""
+        if person.get(XID) == COMMENTARY:
+            return COMMENTARY, COMMENTARY, None, "commentary", None
+        if not label:
+            return label, "(no role)", None, "no_label", None
+        parts = {child.tag for child in pn}
+        if collapse(pn.text or "") or not parts or parts - {f"{T}roleName", f"{T}forename", f"{T}surname"}:
+            return label, None, None, "free", None  # classified by free(), after every structured person
+        role = collapse(" ".join(collapse(e.text or "") for e in pn.findall(f"{T}roleName")))
+        forenames = tuple(collapse(e.text or "") for e in pn.findall(f"{T}forename"))
+        # PPC's party strip leaves a cut tag as one more surname ("Czerniawski", "(niez"; 1,850 persons):
+        # a surname part starting with "(" is never a name.
+        surnames = tuple(s for e in pn.findall(f"{T}surname") if (s := collapse(e.text or "")) and not s.startswith("("))
+        name = " ".join(forenames + surnames)
+        if not name:
+            # A role alone ("Marszałek", "Przedstawiciel Związku Harcerstwa Polskiego"): it must match both
+            # as it stands and with the placeholder name, so a role ending in capitalised words is no name.
+            rule, stripped = classify_label(role + PLACEHOLDER, system, house)
+            if rule and classify_label(role, system, house)[0]:
+                return label, role, rule, "role_only", None
+            return label, role, None, "role_only_unmatched", None
+        if not role:
+            return label, "(no role)", None, "no_role", None
+        rule, stripped = classify_label(role + PLACEHOLDER, system, house)
+        self.stats["persons_p_strip"] += stripped
+        if rule is None and re.fullmatch(rf"{_TOK} {_TOK}", name) \
+                and classify_label(role + PLACEHOLDER_2, system, house)[0] == "sejm_committee_secretary":
+            rule = "sejm_committee_secretary"
+            self.stats["persons_p2_fallback"] += 1
+        if not re.fullmatch(rf"{_NAME}|{_TOK}", name):  # the rule stands only if scan_headers finds a member
+            return label, role, rule, "bad_name", (forenames, surnames)
+        return label, role, rule, "structured" if rule else "unmatched", (forenames, surnames)
+
+    def free(self, label, system, house):
+        """Rule of a free-text label (a header persName without parts, a speaker line inside a turn).
+
+        Kept only when it matches a rule other than committee_chair_named (which needs a structured name)
+        and either names a speaker the zip's headers keep (the label itself, or its last 1-3 tokens as a
+        name) or has a title before the name (_TITLED) and its role takes the placeholder. Guards against
+        "Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk", "Marszałek Polski Józef Piłsudski", where a
+        role absorbs words that the rules take for a name."""
+        rule = classify_label(label, system, house)[0]
+        if rule is None or rule == "committee_chair_named":
+            return None, "free_unmatched"
+        tokens = label.split()
+        if label in self.kept_labels or any(" ".join(tokens[-k:]) in self.kept_names for k in (1, 2, 3)):
+            return rule, "free"
+        titled = _TITLED.fullmatch(label)
+        if titled and classify_label(titled["role"] + PLACEHOLDER, system, house)[0] == rule:
+            return rule, "free_titled"
+        return None, "free_guard"
+
+
+def name_key(key):
+    """Casefolded name tokens of a (forenames, surnames) key, without punctuation and one-letter tokens."""
+    name = _CAMEL.sub(" ", " ".join(key[0] + key[1]).replace("\xad", ""))
+    tokens = (t.strip(":;,.\\/()–-") for t in name.casefold().split())
+    return tuple(t for t in tokens if len(t) > 1)
+
+
+def is_member(key, members):
+    """The name is a member's, or starts with one ("Jan Bury s. Antoniego", "Jerzy Eysymontt niez")."""
+    tokens = name_key(key)
+    return tokens in members or any(tokens[:n] in members for n in range(len(tokens) - 1, 1, -1))
+
+
+def chair_is_member(rule, key, members):
+    """A role-only chair ("Przewodniczący Komisji Spraw Zagranicznych", key None) has no name to check."""
+    return rule != "committee_chair_named" or (key is not None and is_member(key, members))
+
+
+# ------------------------------------------------------------------ documents
+def doc_meta(z, d):
+    header = ET.fromstring(z.read(d + "header.xml"))
+    bibl = header.find(f".//{T}sourceDesc/{T}bibl")
+    date_el = bibl.find(f"{T}date")
+    date = collapse(date_el.text or "") if date_el is not None else ""
+    meta = {k: note(bibl, k) for k in ("system", "house", "type", "termNo")}
+    if date:
+        try:
+            days = sitting_days(date)  # a sitting over several days (21 shapes in 1922-1991) is a range
+        except ValueError as error:
+            raise ValueError(f"{d}: {error}") from error
+        created = min(days) if len(set(days)) == 1 else f"{min(days)}, {max(days)}"
+    elif meta["termNo"] in UNDATED_TERM_RANGES and "/interpelacje/" in d:
+        created = UNDATED_TERM_RANGES[meta["termNo"]]
+    else:
+        raise ValueError(f"{d}: no date and no term range for term {meta['termNo']!r}")
+    authors = "; ".join(collapse(" ".join(a.itertext())) for a in bibl.findall(f"{T}author"))
+    return header, meta | {"date": date, "created": created, "author": authors}
+
+
+def interpellation_text(z, d):
+    root = ET.fromstring(z.read(d + "text_structure.xml"))
+    return "\n".join(t for p in root.iter(f"{T}p") if (t := collapse("".join(p.itertext()))))
+
+
+def sitting_text(z, d, meta, persons, speakers, acc):
+    """Kept utterances of a sitting joined by "\\n", the labels of their speakers, dropped characters.
+
+    `persons` maps an utterance's @who to [label, role, rule, reason, key]. The loop runs per body child (a <div> turn
+    block, or a lone <u>): a komentarz continues the speaker before it in the same block only."""
+    system, house = meta["system"], meta["house"]
+    kept, labels, dropped = [], {}, 0
+    body = ET.fromstring(z.read(d + "text_structure.xml")).find(f".//{T}body")
+
+    def count(label, role, rule, text, keep):
+        nonlocal dropped
+        stat = acc["labels"][(role, label, rule if keep else None)]
+        stat[0] += 1
+        stat[1] += len(text)
+        if keep:
+            kept.append(text)
+            labels.setdefault(label, None)
+            acc["stats"]["kept_chars_by_rule"][rule] += len(text)
+        else:
+            dropped += len(text)
+
+    for block in body:
+        current = None  # (label, role, rule) of the turn going on
+        switch = None  # (who, label, role, rule) of a speaker line inside a turn
+        for u in ([block] if block.tag == f"{T}u" else block.iter(f"{T}u")):
+            who = (u.get("who") or "").lstrip("#")
+            text = collapse("".join(u.itertext()))
+            if not text:
+                continue
+            if switch and who not in (COMMENTARY, switch[0]):
+                switch = None
+            line = text[:-1].strip()
+            if text.endswith(":") and (is_label(line) or classify_label(line, system, house)[0]):
+                rule, reason = speakers.free(line, system, house)
+                acc["stats"]["inline_labels"][reason] += 1
+                current = (line, role_of(line, set()), rule)
+                switch = (who, *current)
+                acc["stats"]["dropped_chars"]["inline_label_line"] += len(text)
+                dropped += len(text)
+                continue
+            if who == COMMENTARY:
+                if ": " in text:
+                    kind, keep = "komentarz_colon", False
+                elif STAGE_DIRECTION.fullmatch(text):
+                    kind, keep = "stage_direction", True
+                elif current is None:
+                    kind, keep = "komentarz_unattributed", False
+                else:
+                    kind, keep = ("komentarz_continuation", True) if current[2] else ("komentarz_continuation_dropped", False)
+                acc["stats"]["komentarz"][kind] += len(text)
+                if not keep:
+                    acc["stats"]["dropped_chars"][kind] += len(text)
+                count(COMMENTARY, COMMENTARY, kind, text, keep)
+                continue
+            if switch:
+                speaker = switch[1:]
+            elif who in persons:
+                speaker = persons[who][:3]
+            else:
+                speaker = ("<unknown>", "(unknown who)", None)
+                acc["stats"]["dropped_chars"]["unknown_who"] += len(text)
+            current = speaker
+            label, role, rule = speaker
+            if not rule and who in persons and not switch:
+                acc["stats"]["dropped_chars"]["speaker:" + persons[who][3]] += len(text)
+            elif not rule and switch:
+                acc["stats"]["dropped_chars"]["inline_speaker"] += len(text)
+            count(label, role, rule, text, bool(rule))
+    return kept, list(labels), dropped
+
+
+def scan_headers(z, docs, speakers, stats):
+    """Pass 1: the verdict on every person of the zip's sittings, and the zip's member set.
+
+    Headers of docs under DROP_PREFIXES count too: a chair of 2019-2023 is checked against that term's MPs.
+    A member rule makes its person a member; with a name _NAME refuses only in a plenary sitting, where a
+    "Poseł" is an MP, and only for a _LONG_NAME (a committee's "Poseł ... z Litwy" is a foreign guest)."""
+    raw = {}
+    for d in docs:
+        if "/interpelacje/" in d:
+            continue
+        header, meta = doc_meta(z, d)
+        persons = {}
+        for person in header.iter(f"{T}person"):
+            label, role, rule, reason, key = speakers.structured(person, meta["system"], meta["house"])
+            persons[person.get(XID)] = [label, role, rule, reason, key]
+            if rule in MEMBER_RULES and (reason == "structured" or (
+                    reason == "bad_name" and "/posiedzenia/" in d and _LONG_NAME.fullmatch(" ".join(key[0] + key[1])))):
+                speakers.members.add(name_key(key))
+        raw[d] = (meta, persons)
+    for d, (meta, persons) in raw.items():
+        for record in persons.values():
+            label, role, rule, reason, key = record
+            if rule and reason == "bad_name":
+                if is_member(key, speakers.members):
+                    record[3] = "bad_name_member"
+                else:
+                    record[2] = rule = None
+            if rule and not chair_is_member(rule, key, speakers.members):
+                record[2], record[3] = None, "chair_not_member"
+            if record[2]:
+                speakers.kept_labels.add(label)
+                if key:
+                    speakers.kept_names.add(" ".join(key[0] + key[1]))
+    for d, (meta, persons) in raw.items():
+        for record in persons.values():
+            if record[3] == "free":
+                record[2], record[3] = speakers.free(record[0], meta["system"], meta["house"])
+                record[1] = role_of(record[0], set())
+            if not d.startswith(DROP_PREFIXES):
+                stats["persons"][record[3]] += 1
+    return raw
+
+
+def process_zip(job):
+    """Pass 1 + pass 2 over one zip; writes <out>/parts/<term>.parquet and .jsonl, returns the tallies."""
+    term, size, sha, dump, out = job
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    path = Path(dump) / f"{term}-tei.zip"
+    if path.stat().st_size != size or sha256_file(path) != sha:
+        raise SystemExit(f"{path} does not match the pinned size/SHA-256; rerun with --download")
+    stats = {k: Counter() for k in ("dropped_docs", "dropped_chars", "kept_chars_by_rule", "komentarz",
+                                    "inline_labels", "persons", "chars_by_category", "docs_by_category")}
+    stats |= {"kept": 0, "chars": 0, "tokens": 0, "authors_with_value": 0, "persons_p_strip": 0,
+              "persons_p2_fallback": 0, "redactions": 0, "date_min": {}, "date_max": {}, "created_min": {},
+              "created_max": {}}
+    acc = {"stats": stats, "labels": defaultdict(lambda: [0, 0])}
+    speakers = Speakers(stats)
+    schema = pa.schema([(f, pa.int64() if f == "token_count" else pa.string()) for f in FIELDS])
+    parts = Path(out) / "parts"
+    with zipfile.ZipFile(path) as z:
+        names = set(z.namelist())
+        docs = sorted(n[:-len("header.xml")] for n in names if n.endswith("/header.xml"))
+        raw = scan_headers(z, docs, speakers, stats)
+        writer = pq.ParquetWriter(parts / f"{term}.parquet", schema, compression="zstd")
+        attribution = open(parts / f"{term}.jsonl", "w", encoding="utf-8")
+        batch = []
+
+        def flush():
+            for (row, _), tokens in zip(batch, count_tokens([row["text"] for row, _ in batch])):
+                row["token_count"] = tokens
+                stats["tokens"] += tokens
+            if batch:
+                writer.write_table(pa.Table.from_pylist([r for r, _ in batch], schema=schema))
+                for _, line in batch:
+                    attribution.write(json.dumps(line, ensure_ascii=False, sort_keys=True) + "\n")
+            batch.clear()
+
+        for d in docs:
+            if d.startswith(DROP_PREFIXES):
+                stats["dropped_docs"]["prefix_sejm_2019_2027"] += 1
+                continue
+            if d + "text_structure.xml" not in names:
+                stats["dropped_docs"]["no_text_structure"] += 1
+                continue
+            kind = "interpellation" if "/interpelacje/" in d else "sitting"
+            if kind == "interpellation":
+                _, meta = doc_meta(z, d)
+                text, speakers_kept, dropped = interpellation_text(z, d), [], 0
+            else:
+                meta, persons = raw[d]
+                lines, speakers_kept, dropped = sitting_text(z, d, meta, persons, speakers, acc)
+                text = "\n".join(lines)
+            category = f"{meta['system']}|{meta['house']}|{meta['type']}"
+            if not text:
+                stats["dropped_docs"][f"empty_{kind}"] += 1
+                continue
+            before = len(REDACTION_TAGS.findall(text))
+            text, _ = redact(text)
+            if len(text) < MIN_CHARS:  # its turns stay counted under their rule: dropped_chars is the allowlist's
+                stats["dropped_docs"][f"short_{kind}"] += 1
+                continue
+            stats["redactions"] += len(REDACTION_TAGS.findall(text)) - before
+            docid = d.rstrip("/").rsplit("/", 1)[1]
+            row = {"id": f"{SOURCE}_{docid}", "text": text, "source": SOURCE, "added": ADDED,
+                   "created": meta["created"], "token_count": 0, "license": LICENSE, "author": meta["author"]}
+            line = {"id": row["id"], "ppc_path": d.rstrip("/"), "term": term, "system": meta["system"],
+                    "house": meta["house"], "type": meta["type"], "term_no": meta["termNo"], "date": meta["date"],
+                    "created": meta["created"], "speakers": speakers_kept, "kept_characters": len(text),
+                    "dropped_characters": dropped, "author": meta["author"]}
+            batch.append((row, line))
+            stats["kept"] += 1
+            stats["chars"] += len(text)
+            stats["authors_with_value"] += bool(meta["author"])
+            stats["docs_by_category"][category] += 1
+            stats["chars_by_category"][category] += len(text)
+            house, first, last = meta["house"], meta["created"].split(", ")[0], meta["created"].split(", ")[-1]
+            for key, value, pick in (("created_min", first, min), ("created_max", last, max)) + (
+                    (("date_min", first, min), ("date_max", last, max)) if meta["date"] else ()):
+                stats[key][house] = pick(stats[key].get(house, value), value)
+            if len(batch) >= 500:
+                flush()
+        flush()
+        writer.close()
+        attribution.close()
+    return term, stats, dict(acc["labels"])
+
+
+# ------------------------------------------------------------------ download, merge
+def download(dump):
+    """Fetch any zip that is missing or the wrong size; a fresh download must match its SHA-256."""
+    dump.mkdir(parents=True, exist_ok=True)
+    for term, size, sha in MANIFEST:
+        path = dump / f"{term}-tei.zip"
+        if path.exists() and path.stat().st_size == size:
+            continue
+        part = path.with_name(path.name + ".part")
+        request = urllib.request.Request(DUMP_URL.format(term=term), headers={"User-Agent": "polish-dynaword"})
+        with urllib.request.urlopen(request, timeout=120) as response, open(part, "wb") as fh:
+            shutil.copyfileobj(response, fh, 1 << 20)
+        if part.stat().st_size != size or sha256_file(part) != sha:
+            raise SystemExit(f"{part}: size or SHA-256 differs from the 2025-05-21 dump")
+        os.replace(part, path)
+
+
+def merge(out, results):
+    """Concatenate the per-zip parts in MANIFEST order; sum the tallies."""
+    import pyarrow.parquet as pq
+
+    root, parts = Path(out) / "data" / SOURCE, Path(out) / "parts"
+    root.mkdir(parents=True, exist_ok=True)
+    ids, writer = set(), None
+    with open(root / f"{SOURCE}.attribution.jsonl", "w", encoding="utf-8") as attribution:
+        for term, _, _ in MANIFEST:
+            table = pq.read_table(parts / f"{term}.parquet")
+            for rid in table.column("id").to_pylist():
+                if rid in ids:
+                    raise SystemExit(f"duplicate id {rid}")
+                ids.add(rid)
+            if writer is None:
+                writer = pq.ParquetWriter(root / f"{SOURCE}.parquet", table.schema, compression="zstd")
+            writer.write_table(table)
+            with open(parts / f"{term}.jsonl", encoding="utf-8") as fh:
+                shutil.copyfileobj(fh, attribution)
+    writer.close()
+
+    labels, total = defaultdict(lambda: [0, 0, None]), defaultdict(Counter)
+    scalars, extremes = Counter(), {k: {} for k in ("date_min", "date_max", "created_min", "created_max")}
+    for term, stats, label_stats in results:
+        for key, (turns, chars) in label_stats.items():
+            labels[key][0] += turns
+            labels[key][1] += chars
+            labels[key][2] = key[2]
+        for k, v in stats.items():
+            if isinstance(v, Counter):
+                total[k].update(v)
+            elif k in extremes:
+                pick = min if k.endswith("_min") else max
+                for house, date in v.items():
+                    extremes[k][house] = pick(extremes[k].get(house, date), date)
+            else:
+                scalars[k] += v
+    rows = roles_table({key: tuple(v) for key, v in labels.items()}, {key: key[0] for key in labels})
+    write_roles(root / f"{SOURCE}.speaker-roles.csv", rows)
+
+    if scalars["kept"] != len(ids):
+        raise SystemExit(f"{len(ids)} rows written, {scalars['kept']} counted")
+    stats = {
+        "license": LICENSE, "licenses": {LICENSE: scalars["kept"]},
+        "created_min": min(extremes["created_min"].values()), "created_max": max(extremes["created_max"].values()),
+        **{f"{k}_by_house": dict(sorted(v.items())) for k, v in extremes.items()},
+        "added": ADDED, "dump": "2025-05-21", "drop_prefixes": list(DROP_PREFIXES),
+        "sejm_coverage_end": PARLIAMENTARY_SEJM_END,
+        **{k: dict(sorted(v.items())) for k, v in total.items()}, **dict(scalars),
+    }
+    write_json(root / f"{SOURCE}.stats.json", stats)
+    shutil.rmtree(parts)
+    return stats
+
+
+def build(dump, out, workers):
+    (Path(out) / "parts").mkdir(parents=True, exist_ok=True)
+    jobs = sorted(((t, s, h, str(dump), str(out)) for t, s, h in MANIFEST), key=lambda j: -j[1])  # largest first
+    with ProcessPoolExecutor(workers) as pool:
+        results = list(pool.map(process_zip, jobs))
+    return merge(out, results)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--dump", type=Path, default=Path("ppc-tei-20250521"))
+    parser.add_argument("--out", type=Path, default=Path("."))
+    parser.add_argument("--download", action="store_true", help="fetch missing zips from kdp.ipipan.waw.pl")
+    parser.add_argument("--workers", type=int, default=min(12, os.cpu_count() or 1))
+    args = parser.parse_args(argv)
+    if args.download:
+        download(args.dump)
+    stats = build(args.dump, args.out, args.workers)
+    print(json.dumps({k: stats[k] for k in ("kept", "chars", "tokens", "created_min", "created_max")}, indent=1))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/fetch_sejm_api.py

@@ -116,36 +116,21 @@ def registry_entry(registry: str, source_name: str) -> re.Match[str] | None:
     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}")
-    # 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 created.group(1)
+# `parlamint_pl` (2015-2022) left the registry in Hub PR 54 without ever shipping data, and sejm_api_2011_2022
+# ends on 2022-12-31 by its own END_DATE, so only `parliamentary` is checked. Its registry `created` range runs
+# to 2025 because it holds the Senate; this source is Sejm-only, so the check uses the end of its Sejm material.
+PRIOR_SEJM_END_DATES = {"parliamentary": common.PARLIAMENTARY_SEJM_END}
 
 
-# `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]:
+def assert_temporal_novelty(start_date: str) -> dict[str, str]:
     threshold = dt.date.fromisoformat(start_date)
-    end_dates = {
-        name: registry_source_end_date(registry, name)
-        for name in PRIOR_PARLIAMENTARY_SOURCES
-    }
     overlapping = {
-        name: value for name, value in end_dates.items()
+        name: value for name, value in PRIOR_SEJM_END_DATES.items()
         if dt.date.fromisoformat(value) >= threshold
     }
     if overlapping:
         raise ContributionError(f"candidate date range overlaps registered sources: {overlapping}")
-    return end_dates
+    return dict(PRIOR_SEJM_END_DATES)
 
 
 def insert_source_registry_entry(registry: str, *, end_date: str) -> str:
@@ -253,7 +238,8 @@ source. No unverified upstream Creative Commons license is asserted.
 
 ## Temporal novelty and deduplication
 
-`parliamentary` ends on `{prior_sources['parliamentary']}`. Every contributed
+The Sejm material of `parliamentary` ends with term 8 (`{prior_sources['parliamentary']}`; its
+Senate material is not compared: this source is Sejm-only). Every contributed
 record is dated on or after `{START_DATE}`, so its date range does not overlap it.
 Exact duplicate speech texts within the contribution are removed using
 SHA-1 fingerprints; this is not a claim of global cross-domain near-deduplication.
@@ -334,7 +320,7 @@ def ontology_manifest(
     ]
     claims = [
         {"id": f"slayer://claim/sejm-api-temporal-novelty@sha256:{version_digest[:20]}",
-         "statement": "Every contributed speech postdates every checked registered parliamentary source range.",
+         "statement": "Every contributed speech postdates the Sejm material of every checked registered parliamentary source.",
          "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]}",
@@ -402,7 +388,7 @@ def build_contribution(
     if not registry_file.is_file():
         raise ContributionError(f"target source registry missing: {registry_file}")
     registry = registry_file.read_text(encoding="utf-8")
-    previous_sources = assert_temporal_novelty(registry, START_DATE)
+    previous_sources = assert_temporal_novelty(START_DATE)
 
     try:
         import pyarrow as pa

src/fetch_sejm_committee_transcripts.py

@@ -620,9 +620,10 @@ def regon_ok(d: str) -> bool:
         w = [8, 9, 2, 3, 4, 5, 6, 7]
         s = sum(int(a) * b for a, b in zip(d[:8], w)) % 11
         return s % 10 == int(d[8])
-    w = [8, 9, 2, 3, 4, 5, 6, 7, -1, 2, 3, 4, 5, 6, 7]
-    s = sum(int(a) * b for a, b in zip(d[:14], w)) % 11
-    return s % 10 == int(d[14])
+    # GUS weights for the 14-digit REGON; the 14th digit is the check digit.
+    w = [2, 4, 8, 5, 0, 9, 7, 3, 6, 1, 2, 4, 8]
+    s = sum(int(a) * b for a, b in zip(d[:13], w)) % 11
+    return s % 10 == int(d[13])
 
 
 def redact(text: str) -> tuple[str, int]:

src/sejm_api_common.py

@@ -20,6 +20,10 @@ 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"
 SEJM_API = "https://api.sejm.gov.pl/"
 SEJM_API_DOCUMENTATION = "https://api.sejm.gov.pl/sejm.html"
+# The end of the Sejm material that `parliamentary` keeps: the last day of term 8 (its last Sejm sitting in the
+# shard is 2019-10-16). `parliamentary` also holds the Senate to 2025 (polish-dynaword-v2#54), which the Sejm-only
+# API sources do not overlap.
+PARLIAMENTARY_SEJM_END = "2019-11-11"
 
 EXPECTED_FIELDS = (
     "id", "text", "source", "added", "created", "token_count", "license", "author"

src/sources.py

@@ -263,18 +263,52 @@ SOURCES = {
     "parliamentary": {
         "added": "2026-06-15",
         "release": "0.2.0",
-        "speakleash_key": "PPC_corpus",
+        "file_key": "parliamentary",
         "pretty": "Polish Parliamentary Corpus (Sejm/Senat)",
         "license": "public-domain (official documents)",
         "license_spdx": "LicenseRef-Polish-Official-Documents",
-        "traceable": "Parliamentary proceedings are official documents outside "
-                     "copyright (PL art. 4 pr. aut.). IPI PAN's PPC page states that "
-                     "the parliamentary data is public domain; its CC BY licence covers "
-                     "only the corpus annotations, which this source does not include.",
+        "traceable": "Parliamentary proceedings, interpellations and the government's "
+                     "replies are official documents outside copyright (PL art. 4 pr. "
+                     "aut.). IPI PAN's PPC page states that the parliamentary data is "
+                     "public domain; its CC BY licence covers the corpus annotations. "
+                     "No annotation layer is shipped, but the speaker turns and labels "
+                     "the filter reads come from IPI PAN's TEI markup, which the card "
+                     "credits. Per-record ppc_path pins the document in the "
+                     "SHA-256-pinned dump.",
+        "legal_note": "Not lawyer-signed-off. In sittings (plenary and committee) "
+                      "only turns by MPs and senators, members of the government, "
+                      "heads of constitutional organs and Sejm/Senate staff are kept "
+                      "(the sejm_committee_transcripts allowlist plus PPC rules for "
+                      "labels without a party tag, II RP surname-only labels and "
+                      "historic offices; polish-dynaword-v2#54): 3,024,072,101 of "
+                      "3,774,774,717 characters of utterance text (80.1%). A turn whose "
+                      "label matches no rule is dropped, among them committee guests, "
+                      "witnesses of investigative committees, the President's "
+                      "Chancellery, heads of agencies other than constitutional organs, "
+                      "the RCL, ministry departments, heads of state and every "
+                      "interjection from the floor. Interpellations, questions and "
+                      "replies are kept whole (304,741 records). Whether guest "
+                      "statements are official documents under art. 4(2) is open. "
+                      "IPI PAN states its own basis as public information made "
+                      "available by statute (Open Data Act, Access to Public "
+                      "Information Act), with no agreement with the Chancelleries "
+                      "(e-mail, 2026-10-07). The rules read the printed role label, "
+                      "not the person. Role table: data/parliamentary/"
+                      "parliamentary.speaker-roles.csv.",
         "upstream": "http://clip.ipipan.waw.pl/PPC",
+        "provenance": "Built by src/fetch_parliamentary.py from the PPC per-term TEI "
+                      "dump of 2025-05-21 (28 zips pinned by size and SHA-256), "
+                      "without the Sejm of 2019-2027 (covered by the sejm_* "
+                      "sources): speaker turns from the TEI <u> elements, the "
+                      "fail-closed role allowlist applied to sittings, interpellations "
+                      "kept whole, PII pattern redaction with checksum-validated "
+                      "national IDs. Pattern redaction only - re-run through "
+                      "SlayerLab/NERGAL before release. Replaces the unlabelled "
+                      "SpeakLeash copy (PPC_corpus) shipped up to v0.2.5.",
         "domain": "political/spoken",
-        "created": "1991-01-01, 2019-12-31",
+        "created": "1919-02-10, 2025-04-24",
         "is_ocr": False,
+        "custom_datasheet": True,
     },
     "sejm_api_2011_2022": {
         "added": "2026-08-31",

src/test_parliamentary_contract.py

@@ -0,0 +1,582 @@
+"""Contract for the parliamentary rebuild from the PPC TEI dump (fetch_parliamentary.py) and the shipped shard."""
+import csv
+import json
+import sys
+import tempfile
+import unicodedata
+import unittest
+import xml.etree.ElementTree as ET
+import zipfile
+from collections import Counter
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import fetch_parliamentary as fp
+from fetch_parliamentary import (
+    DROP_PREFIXES, SOURCE, UNDATED_TERM_RANGES, Speakers, classify_label, doc_meta,
+    sitting_days,
+)
+from fetch_sejm_committee_transcripts import FIELDS, LICENSE
+from sejm_api_common import PARLIAMENTARY_SEJM_END, sha256_file
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+TEI = "http://www.tei-c.org/ns/1.0"
+LONG = "Wysoka Izbo, " + "projekt ustawy wymaga starannej pracy w komisji i dalszych poprawek. " * 4
+
+
+def person(xid, role=None, forenames=(), surnames=(), free=None):
+    """A header <person>: structured (roleName/forename/surname) or, with `free`, a persName of plain text."""
+    if free is not None:
+        return f'<person xml:id="{xid}" role="speaker"><persName>{free}</persName></person>'
+    parts = (f"<roleName>{role}</roleName>" if role else "") + "".join(
+        f"<forename>{f}</forename>" for f in forenames) + "".join(f"<surname>{s}</surname>" for s in surnames)
+    return f'<person xml:id="{xid}" role="speaker"><persName>{parts}</persName></person>'
+
+
+def header(persons=(), date="2016-01-10", system="III RP", house="Sejm", type_="Posiedzenie plenarne",
+           term_no="8", authors=()):
+    date_el = f"<date>{date}</date>" if date is not None else ""
+    author_els = "".join(f"<author>{a}</author>" for a in authors)
+    return (f'<teiHeader xmlns="{TEI}"><fileDesc><sourceDesc><bibl>{author_els}'
+            f'<note type="system">{system}</note><note type="house">{house}</note>'
+            f'<note type="type">{type_}</note><note type="termNo">{term_no}</note>{date_el}</bibl>'
+            f"</sourceDesc></fileDesc><profileDesc><particDesc>{''.join(persons)}</particDesc></profileDesc>"
+            "</teiHeader>")
+
+
+def body(*blocks):
+    """text_structure.xml; a block is [(who, text)] (a <div>) or one (who, text) pair (a lone <u>)."""
+    def u(who, text):
+        return f'<u who="#{who}">{text}</u>'
+    inner = "".join(u(*b) if isinstance(b, tuple) else "<div>" + "".join(u(*x) for x in b) + "</div>"
+                    for b in blocks)
+    return f'<teiCorpus xmlns="{TEI}"><TEI><text><body>{inner}</body></text></TEI></teiCorpus>'
+
+
+def interpellation(*paragraphs):
+    ps = "".join(f"<p>{p}</p>" for p in paragraphs)
+    return f'<teiCorpus xmlns="{TEI}"><TEI><text><body><div>{ps}</div></body></text></TEI></teiCorpus>'
+
+
+def write_zip(path, docs):
+    """docs: {doc dir: (header xml, text_structure xml or None)}."""
+    with zipfile.ZipFile(path, "w") as z:
+        for d, (head, text) in docs.items():
+            z.writestr(d + "header.xml", head)
+            if text is not None:
+                z.writestr(d + "text_structure.xml", text)
+
+
+def person_element(xml):
+    return ET.fromstring(f'<particDesc xmlns="{TEI}">{xml}</particDesc>')[0]
+
+
+class SittingDaysTest(unittest.TestCase):
+    def test_single_day(self):
+        self.assertEqual(sitting_days("1938-11-28"), ["1938-11-28"])
+
+    def test_multi_day_shapes_of_the_dump(self):
+        cases = {
+            "1938-11-28 i 29": ["1938-11-28", "1938-11-29"],
+            "1990-09-12, 13 i 14": ["1990-09-12", "1990-09-13", "1990-09-14"],
+            "1952-07-31 i 08-01": ["1952-07-31", "1952-08-01"],
+            "1945-12-29, 30, 31, 1946-01-02 i 03": ["1945-12-29", "1945-12-30", "1945-12-31", "1946-01-02",
+                                                    "1946-01-03"],
+            "1957-04-24,25,26,27 i 28": ["1957-04-24", "1957-04-25", "1957-04-26", "1957-04-27", "1957-04-28"],
+            "1983-01-31 i 1983-02-01": ["1983-01-31", "1983-02-01"],
+            "1957-05-29 i 28": ["1957-05-29", "1957-05-28"],
+        }
+        for date, days in cases.items():
+            with self.subTest(date=date):
+                self.assertEqual(sitting_days(date), days)
+
+    def test_anything_else_raises(self):
+        for date in ("", "29 listopada 1938", "11-28", "1938-28", "1938-13-01", "1938-02-30", "1938-11-28 lub 29"):
+            with self.subTest(date=date), self.assertRaises(ValueError):
+                sitting_days(date)
+
+
+class ClassifyLabelTest(unittest.TestCase):
+    KEPT = [
+        ("Poseł Jan Kowalski", "III RP", "Sejm", "mp_no_party"),
+        ("Poseł ks. Marian Borowiec", "PRL", "Krajowa Rada Narodowa", "mp_no_party"),
+        ("Posłanka Wiceprzewodnicząca Anna Nowak", "III RP", "Sejm", "mp_no_party"),
+        ("Sekretarz poseł Jan Kowalski", "III RP", "Sejm", "mp_no_party"),
+        ("Sekretarz Poseł Jan Kowalski", "III RP", "Sejm", "mp_no_party"),
+        ("Poeł Jan Kowalski", "III RP", "Sejm", "mp_no_party"),
+        ("Przewodniczący poseł ob. Szwalbe", "PRL", "Krajowa Rada Narodowa", "mp_no_party"),
+        ("P. Nowicki", "II RP", "Sejm", "mp_surname_1919_1939"),
+        ("S. Karnicka", "II RP", "Senat", "senator_surname_1919_1939"),
+        ("Senator Jan Kowalski", "III RP", "Senat", "senator"),
+        ("Marszałek", "III RP", "Senat", "marshal_no_house"),
+        ("Wicemarszałek Jan Kowalski", "III RP", "Sejm", "marshal_no_house"),
+        ("Marszalek poseł Ferdynand Radziwiłł", "II RP", "Sejm", "marshal_no_house"),
+        ("Marszałek Senior Jan Kowalski", "III RP", "Sejm", "marshal_no_house"),
+        ("Prezes Rady Ministrów Jan Kowalski", "III RP", "Sejm", "government_member"),
+        ("Prezydent Ministrów Ignacy Paderewski", "II RP", "Sejm", "government_historic"),
+        ("Wicepremier Jan Kowalski", "III RP", "Sejm", "government_historic"),
+        ("Minister Wyznań Religijnych i Oświecenia Publicznego Jan Kowalski", "II RP", "Sejm", "government_historic"),
+        ("Kierownik Ministerstwa Skarbu Jan Kowalski", "II RP", "Sejm", "government_historic"),
+        ("Minister - Szef Urzędu Rady Ministrów Jan Kowalski", "PRL", "Sejm", "government_historic"),
+        ("Minister - szef Urzędu Rady Ministrów Jan Kowalski", "III RP", "Sejm", "government_historic"),
+        ("Podsekretarz Stanu w Urzędzie Rady Ministrów Jan Kowalski", "III RP", "Sejm", "state_secretary_historic"),
+        ("Sekretarz stanu w Urzędzie Rady Ministrów, Jan Kowalski", "III RP", "Sejm", "state_secretary_historic"),
+        ("Podsekretarz stanu w URM Jan Kowalski", "III RP", "Sejm", "state_secretary_historic"),
+        ("Prezes Rady Ministrów ob. Osóbka-Morawski", "PRL", "Krajowa Rada Narodowa", "government_historic"),
+        ("Podsekretarz Stanu w Ministerstwie Przemysłu Chemicznego Jan Kowalski", "PRL", "Sejm", "state_secretary"),
+        ("Główny Legislator w Biurze Legislacyjnym w Kancelarii Senatu Jan Kowalski", "III RP", "Senat",
+         "legislative_petitions_staff"),
+        ("Główny Legislator w Biurze Legislacyjnym Jan Kowalski", "III RP", "Senat", "legislative_petitions_staff"),
+        ("Przedstawiciel Biura Legislacyjnego KS Jan Kowalski", "III RP", "Sejm", "legislative_petitions_staff"),
+        ("Przewodniczący Komisji Finansów Publicznych Jan Kowalski", "III RP", "Sejm", "committee_chair_named"),
+        ("Zastępca Przewodniczącego Jan Kowalski", "III RP", "Senat", "committee_chair_named"),
+        ("Sekretarz Komisji Finansów Publicznych Jan Kowalski", "III RP", "Sejm", "sejm_committee_secretary"),
+        ("Prezes NIK Jan Kowalski", "III RP", "Sejm", "constitutional_organ_head"),
+    ]
+    # Out by decision 2A (head of state, KPRP, agency deputies, "Wiceminister", bare "Sprawozdawca") or as
+    # not the chamber's own ("P." in the Senate is "Pan"; the surname-only forms are 1919-39 only).
+    DROPPED = [
+        ("P. Nowicki", "III RP", "Sejm"),
+        ("P. Nowicki", "II RP", "Senat"),
+        ("S. Karnicka", "II RP", "Sejm"),
+        ("Marszałek Województwa Mazowieckiego Adam Struzik", "III RP", "Senat"),
+        ("Sekretarz stanu w Kancelarii Prezydenta RP Jan Kowalski", "III RP", "Sejm"),
+        ("Wiceminister Finansów Jan Kowalski", "III RP", "Sejm"),
+        ("Naczelnik Państwa Józef Piłsudski", "II RP", "Sejm"),
+        ("Prezydent RP Jan Kowalski", "III RP", "Sejm"),
+        ("Ob. Prezydent", "PRL", "Krajowa Rada Narodowa"),
+        ("Wiceprezydent ob. Szwalbe", "PRL", "Krajowa Rada Narodowa"),
+        ("Przewodniczący Rady Państwa Henryk Jabłoński", "PRL", "Sejm"),
+        ("Główny Legislator w Biurze Legislacyjnym Jan Kowalski", "III RP", "Sejm"),
+        ("Wiceprezes NIK Jan Kowalski", "III RP", "Sejm"),
+        # "Urzędzie" admits the Urząd Rady Ministrów only, not other offices
+        ("Podsekretarz Stanu w Urzędzie Komitetu Integracji Europejskiej Jan Kowalski", "III RP", "Sejm"),
+        ("Podsekretarz stanu w Urzędzie Mieszkalnictwa Jan Kowalski", "III RP", "Sejm"),
+        ("Zastępca Przewodniczącego KRRiT Jan Kowalski", "III RP", "Sejm"),
+        ("Sprawozdawca", "III RP", "Sejm"),
+        ("Głos z sali", "III RP", "Sejm"),
+        # A role that swallows words of a name no longer fits the placeholder (structured persons).
+        ("Minister Spraw Zagranicznych Ukrainy Jan Maria Kowalski", "III RP", "Sejm"),
+        ("Marszałek Polski Jan Maria Kowalski", "II RP", "Sejm"),
+        ("Prezes Fundacji Batorego Jan Maria Kowalski", "III RP", "Sejm"),
+    ]
+
+    def test_kept_labels(self):
+        for label, system, house, rule in self.KEPT:
+            with self.subTest(label=label, system=system, house=house):
+                self.assertEqual(classify_label(label, system, house), (rule, False))
+
+    def test_dropped_labels(self):
+        for label, system, house in self.DROPPED:
+            with self.subTest(label=label, system=system, house=house):
+                self.assertIsNone(classify_label(label, system, house)[0])
+
+    def test_pan_before_an_office_in_1919_1939(self):
+        self.assertEqual(classify_label("P. Minister Skarbu Zdziechowski", "II RP", "Sejm"), ("government_member", True))
+        self.assertEqual(classify_label("P. Minister Skarbu", "II RP", "Sejm"), ("government_historic", True))
+        self.assertEqual(classify_label("P. Minister Skarbu Zdziechowski", "III RP", "Sejm"), (None, False))
+
+    def test_labels_are_read_in_nfc(self):
+        decomposed = unicodedata.normalize("NFD", "Poseł Jan Kowalczyk-Żółć")
+        self.assertNotEqual(decomposed, unicodedata.normalize("NFC", decomposed))
+        self.assertEqual(classify_label(decomposed, "III RP", "Sejm"), ("mp_no_party", False))
+
+
+class SpeakersTest(unittest.TestCase):
+    def structured(self, xml, system="III RP", house="Sejm"):
+        speakers = Speakers(Counter())
+        return speakers.structured(person_element(xml), system, house), speakers
+
+    def test_person_shapes(self):
+        cases = [
+            (person("komentarz", free="Komentarz"), ("komentarz", "komentarz", None, "commentary", None)),
+            (person("x", free=""), ("", "(no role)", None, "no_label", None)),
+            (person("x", free="Poseł ob. Ochab"), ("Poseł ob. Ochab", None, None, "free", None)),
+            (person("x", "Marszałek"), ("Marszałek", "Marszałek", "marshal_no_house", "role_only", None)),
+            (person("x", "Sprawozdawca"), ("Sprawozdawca", "Sprawozdawca", None, "role_only_unmatched", None)),
+            # a role alone must match without the placeholder too: "Przedstawiciel Związku Harcerstwa Polskiego"
+            (person("x", "Przedstawiciel Związku Harcerstwa Polskiego"),
+             ("Przedstawiciel Związku Harcerstwa Polskiego", "Przedstawiciel Związku Harcerstwa Polskiego", None,
+              "role_only_unmatched", None)),
+            (person("x", None, ["Jan"], ["Kowalski"]), ("Jan Kowalski", "(no role)", None, "no_role", None)),
+            # a name _NAME refuses keeps its rule and key for the member check of scan_headers
+            (person("x", "Ekspert", ["Artur"], ["Płokszto z Litwy"]),
+             ("Ekspert Artur Płokszto z Litwy", "Ekspert", None, "bad_name", (("Artur",), ("Płokszto z Litwy",)))),
+            (person("x", "Poseł", ["Piotr"], ["Van der Coghen"]),
+             ("Poseł Piotr Van der Coghen", "Poseł", "mp_no_party", "bad_name", (("Piotr",), ("Van der Coghen",)))),
+            (person("x", "Poseł", ["Jan"], ["Kowalski"]),
+             ("Poseł Jan Kowalski", "Poseł", "mp_no_party", "structured", (("Jan",), ("Kowalski",)))),
+            # PPC's cut party tag as one more surname part
+            (person("x", "Poseł", ["Ludwik"], ["Dorn", "(niez"]),
+             ("Poseł Ludwik Dorn (niez", "Poseł", "mp_no_party", "structured", (("Ludwik",), ("Dorn",)))),
+            (person("x", "Minister Spraw Zagranicznych Ukrainy", ["Borys"], ["Tarasiuk"]),
+             ("Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk", "Minister Spraw Zagranicznych Ukrainy", None,
+              "unmatched", (("Borys",), ("Tarasiuk",)))),
+        ]
+        for xml, expected in cases:
+            with self.subTest(xml=xml):
+                self.assertEqual(self.structured(xml)[0], expected)
+
+    def test_committee_secretary_takes_the_two_token_placeholder(self):
+        verdict, speakers = self.structured(person("x", "Sekretarz Komisji Finansów Publicznych", ["Jan"], ["Kowalski"]))
+        self.assertEqual(verdict[2:4], ("sejm_committee_secretary", "structured"))
+        self.assertEqual(speakers.stats["persons_p2_fallback"], 1)
+        verdict, _ = self.structured(person("x", "Sekretarz Komisji Finansów Publicznych", ["Jan", "Maria"],
+                                            ["Kowalski"]))
+        self.assertEqual(verdict[2:4], (None, "unmatched"))
+
+    def test_pan_strip_is_counted(self):
+        verdict, speakers = self.structured(person("x", "P. Minister Skarbu", ["Gabriel"], ["Czechowicz"]), "II RP")
+        self.assertEqual(verdict[2], "government_historic")
+        self.assertEqual(speakers.stats["persons_p_strip"], 1)
+
+    def test_free_label_guard(self):
+        speakers = Speakers(Counter())
+        speakers.kept_names = {"Jan Kowalski", "Nowicki"}
+        speakers.kept_labels = {"Wicemarszałek Anna Nowak"}
+        cases = [
+            ("Poseł Jan Kowalski", "III RP", "Sejm", ("mp_no_party", "free")),
+            ("Wicemarszałek Anna Nowak", "III RP", "Sejm", ("marshal_no_house", "free")),
+            ("P. Nowicki", "II RP", "Sejm", ("mp_surname_1919_1939", "free")),
+            # a role absorbing words of a name, with no kept speaker of that name in the zip
+            ("Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk", "III RP", "Sejm", (None, "free_guard")),
+            ("Marszałek Polski Józef Piłsudski", "II RP", "Sejm", (None, "free_guard")),
+            # a title marks where the name starts (KRN, which has no structured persons)
+            ("Poseł ob. Ochab", "PRL", "Krajowa Rada Narodowa", ("mp_no_party", "free_titled")),
+            ("Prezes Rady Ministrów ob. Osóbka-Morawski", "PRL", "Krajowa Rada Narodowa",
+             ("government_historic", "free_titled")),
+            ("Wiceprezydent ob. Szwalbe", "PRL", "Krajowa Rada Narodowa", (None, "free_unmatched")),
+            # a named chair needs a structured name to check against the members
+            ("Przewodniczący Komisji Finansów Publicznych Jan Kowalski", "III RP", "Sejm", (None, "free_unmatched")),
+            ("Głos z sali", "III RP", "Sejm", (None, "free_unmatched")),
+        ]
+        for label, system, house, expected in cases:
+            with self.subTest(label=label):
+                self.assertEqual(speakers.free(label, system, house), expected)
+
+    def test_chair_is_member(self):
+        members = {("jan", "kowalski")}
+        self.assertTrue(fp.chair_is_member("committee_chair_named", (("Jan",), ("Kowalski",)), members))
+        self.assertFalse(fp.chair_is_member("committee_chair_named", (("Hans",), ("Müller",)), members))
+        self.assertTrue(fp.chair_is_member("mp_no_party", (("Hans",), ("Müller",)), set()))
+        self.assertFalse(fp.chair_is_member("committee_chair_named", None, members))
+
+    def test_name_key(self):
+        cases = [
+            ((("Jan",), ("Kowalski",)), ("jan", "kowalski")),
+            ((("Piotr",), ("Van der Coghen",)), ("piotr", "van", "der", "coghen")),
+            # one-letter tokens (initials, "s." of a patronymic) and punctuation go
+            ((("Jan",), ("Bury", "s. Antoniego")), ("jan", "bury", "antoniego")),
+            ((("Mieczysław", "M"), ("Łuczak",)), ("mieczysław", "łuczak")),
+            ((("Zdzisław",), ("Pupa:",)), ("zdzisław", "pupa")),
+            ((("JANUSZ",), ("PALIKOT",)), ("janusz", "palikot")),
+            # two parts run together, a soft hyphen
+            ((("JanuszPalikot",), ()), ("janusz", "palikot")),
+            ((("Anna",), ("Ko\xadwalska",)), ("anna", "kowalska")),
+        ]
+        for key, expected in cases:
+            with self.subTest(key=key):
+                self.assertEqual(fp.name_key(key), expected)
+
+    def test_is_member(self):
+        members = {("jan", "bury"), ("piotr", "van", "der", "coghen")}
+        for key in [(("Jan",), ("Bury",)), (("Jan",), ("Bury", "s. Antoniego")), (("Jan",), ("Bury", "syn", "Józefa")),
+                    (("Piotr",), ("Van der Coghen",)), (("Piotr",), ("van der Coghen",))]:
+            with self.subTest(key=key):
+                self.assertTrue(fp.is_member(key, members))
+        # a member's name must be the whole name or its start, of at least two tokens
+        for key in [(("Jan",), ("Burysz",)), (("Józef",), ("Jan", "Bury")), (("Piotr",), ("Van der Koghen",)),
+                    (("Jan",), ("Burak",)), (("Artur",), ("Płokszto z Litwy",))]:
+            with self.subTest(key=key):
+                self.assertFalse(fp.is_member(key, members | {("jan",)}))
+
+
+class ScanHeadersTest(unittest.TestCase):
+    PLENARY = "1922-1927/sejm/posiedzenia/pp/192227-sjm-ppxxx-00001-01/"
+    COMMITTEE = "1922-1927/sejm/komisje/ks/192227-sjm-ksxxx-00001-01/"
+
+    def verdicts(self, plenary, committee):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "t.zip"
+            write_zip(path, {self.PLENARY: (header(plenary, date="1923-01-10", system="II RP"), None),
+                             self.COMMITTEE: (header(committee, date="1923-01-11", system="II RP",
+                                                     type_="Posiedzenie komisji"), None)})
+            speakers, stats = Speakers(Counter()), Counter(persons=Counter())
+            stats["persons"] = Counter()
+            with zipfile.ZipFile(path) as z:
+                raw = fp.scan_headers(z, [self.PLENARY, self.COMMITTEE], speakers, stats)
+        return {xid: tuple(record[2:4]) for _, persons in raw.values() for xid, record in persons.items()}, speakers
+
+    def test_an_unusual_name_is_kept_only_for_a_member(self):
+        verdicts, speakers = self.verdicts(
+            [person("Coghen", "Poseł", ["Piotr"], ["van der Coghen"]),  # plenary evidence: a 4-token name
+             person("Bury", "Poseł", ["Jan"], ["Bury"]),
+             person("Litwa", "Poseł", ["Artur"], ["Płokszto z Litwy"])],  # no evidence: a lowercase word
+            [person("CoghenK", "Poseł", ["Piotr"], ["Van der Coghen"]),  # the member, cased as the dump has it
+             person("BuryK", "Poseł", ["Jan"], ["Bury", "s. Antoniego"]),  # a member's name and more
+             person("Berg", "Poseł", ["Hans"], ["van der Berg"]),  # a committee name is no evidence
+             person("LitwaK", "Poseł", ["Artur"], ["Płokszto z Litwy"]),
+             person("Chair", "Przewodniczący Komisji Skarbowej", ["Piotr"], ["van der Coghen"]),
+             person("RoleOnlyChair", "Przewodniczący Komisji Spraw Zagranicznych")])
+        self.assertEqual(verdicts, {
+            "Coghen": ("mp_no_party", "bad_name_member"), "Bury": ("mp_no_party", "structured"),
+            "Litwa": (None, "bad_name"), "CoghenK": ("mp_no_party", "bad_name_member"),
+            "BuryK": ("mp_no_party", "bad_name_member"), "Berg": (None, "bad_name"), "LitwaK": (None, "bad_name"),
+            "Chair": ("committee_chair_named", "bad_name_member"), "RoleOnlyChair": (None, "chair_not_member")})
+        self.assertEqual(speakers.members, {("piotr", "van", "der", "coghen"), ("jan", "bury")})
+        self.assertIn("Piotr Van der Coghen", speakers.kept_names)
+        self.assertNotIn("Artur Płokszto z Litwy", speakers.kept_names)
+
+
+class DocMetaTest(unittest.TestCase):
+    def meta(self, d, head):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "t.zip"
+            write_zip(path, {d: (head, None)})
+            with zipfile.ZipFile(path) as z:
+                return doc_meta(z, d)[1]
+
+    def test_single_day_and_authors(self):
+        meta = self.meta("t/sejm/interpelacje/i1/", header(date="2016-01-10", type_="Interpelacja",
+                                                             authors=["Jan Kowalski", "Anna  Nowak"]))
+        self.assertEqual((meta["created"], meta["date"], meta["author"]),
+                         ("2016-01-10", "2016-01-10", "Jan Kowalski; Anna Nowak"))
+
+    def test_multi_day_sitting_is_a_range(self):
+        meta = self.meta("t/sejm/posiedzenia/pp/s1/", header(date="1957-05-29 i 28", system="PRL"))
+        self.assertEqual(meta["created"], "1957-05-28, 1957-05-29")
+        meta = self.meta("t/sejm/posiedzenia/pp/s1/", header(date="1938-11-28 i 28", system="II RP"))
+        self.assertEqual(meta["created"], "1938-11-28")
+
+    def test_undated_interpellation_takes_its_term(self):
+        for term_no, created in UNDATED_TERM_RANGES.items():
+            with self.subTest(term_no=term_no):
+                meta = self.meta("t/sejm/interpelacje/i1/", header(date=None, type_="Interpelacja", term_no=term_no))
+                self.assertEqual((meta["created"], meta["date"]), (created, ""))
+
+    def test_undated_anything_else_raises(self):
+        with self.assertRaisesRegex(ValueError, "no date"):
+            self.meta("t/sejm/posiedzenia/pp/s1/", header(date=None, term_no="5"))
+        with self.assertRaisesRegex(ValueError, "no date"):
+            self.meta("t/sejm/interpelacje/i1/", header(date=None, type_="Interpelacja", term_no="8"))
+
+    def test_bad_date_names_the_document(self):
+        with self.assertRaisesRegex(ValueError, "t/sejm/posiedzenia/pp/s1/: unexpected date"):
+            self.meta("t/sejm/posiedzenia/pp/s1/", header(date="29 listopada 1938"))
+
+
+class BuildTest(unittest.TestCase):
+    """process_zip + merge on one synthetic zip: every speaker and komentarz path of sitting_text."""
+
+    TERM = "2015-2019"
+    SITTING = "2015-2019/sejm/posiedzenia/pp/201519-sjm-ppxxx-00001-01/"
+    INTERPELLATION = "2015-2019/sejm/interpelacje/201519-sjm-inxxx-00001/"
+    DROPPED = "2019-2023/sejm/posiedzenia/pp/201923-sjm-ppxxx-00001-01/"
+
+    def docs(self):
+        persons = [
+            person("komentarz", free="Komentarz"),
+            person("Marszalek", "Marszałek"),
+            person("PoselJanKowalski", "Poseł", ["Jan"], ["Kowalski"]),
+            person("Przewodniczacy", "Przewodniczący Komisji Finansów Publicznych", ["Jan"], ["Kowalski"]),
+            person("PrzewodniczacyKomisji", "Przewodniczący Komisji Spraw Zagranicznych Bundestagu", ["Hans"],
+                   ["Müller"]),
+            # chair of the next term: an MP only in the dropped 2019-2023 header, which still counts for members
+            person("PrzewodniczacaNowak", "Przewodnicząca Komisji Zdrowia", ["Ewa"], ["Nowak"]),
+            person("Gosc", "Prezes Fundacji Batorego", ["Anna"], ["Zielińska"]),
+            person("PoselFree", free="Poseł Jan Kowalski"),
+            person("PoselCoghen", "Poseł", ["Piotr"], ["van der Coghen"]),
+            person("PoselLitwa", "Poseł", ["Artur"], ["Płokszto z Litwy"]),
+        ]
+        sitting = body(
+            ("komentarz", "(Początek posiedzenia o godz. 10)"),
+            [("Marszalek", "Otwieram posiedzenie Sejmu."),
+             ("komentarz", "Głos z sali: Hańba!"),
+             ("komentarz", "Proszę o spokój.")],
+            [("Gosc", "Mówię jako gość Komisji."),
+             ("komentarz", "Dalszy ciąg wypowiedzi gościa.")],
+            [("PoselJanKowalski", LONG),
+             ("PoselJanKowalski", "Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk:"),
+             ("PoselJanKowalski", "Dziękuję za zaproszenie do Sejmu."),
+             ("komentarz", "(Oklaski)"),
+             ("Marszalek", "Dziękuję panu ministrowi.")],
+            [("Przewodniczacy", "Komisja przyjęła sprawozdanie."),
+             ("PrzewodniczacyKomisji", "Ich danke."),
+             ("PrzewodniczacaNowak", "Zamykam dyskusję."),
+             ("PoselFree", "Pytanie z wolnej etykiety."),
+             ("Nikt", "Tekst bez mówcy w nagłówku.")],
+            [("PoselCoghen", "Głos posła van der Coghena."),
+             ("PoselLitwa", "Głos posła z Litwy.")],
+        )
+        return {
+            self.SITTING: (header(persons, date="2016-01-10, 11 i 12"), sitting),
+            self.INTERPELLATION: (header(date="2016-02-01", type_="Interpelacja", authors=["Jan Kowalski"]),
+                                  interpellation("Szanowny Panie Ministrze,", LONG, "Z poważaniem")),
+            "2015-2019/sejm/interpelacje/201519-sjm-inxxx-00002/": (
+                header(date="2016-02-02", type_="Interpelacja"), interpellation("Za krótka.")),
+            "2015-2019/sejm/posiedzenia/pp/201519-sjm-ppxxx-00002-01/": (header(date="2016-01-13"), None),
+            self.DROPPED: (header([person("PoslankaNowak", "Posłanka", ["Ewa"], ["Nowak"])], date="2019-11-12",
+                                  term_no="9"), body([("PoslankaNowak", LONG)])),
+        }
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        tmp = Path(self.tmp.name)
+        self.dump, self.out = tmp / "dump", tmp / "out"
+        self.dump.mkdir()
+        path = self.dump / f"{self.TERM}-tei.zip"
+        write_zip(path, self.docs())
+        self.job = (self.TERM, path.stat().st_size, sha256_file(path), str(self.dump), str(self.out))
+        (self.out / "parts").mkdir(parents=True)
+        self.term, self.stats, self.labels = fp.process_zip(self.job)
+
+    def merged(self):
+        with mock.patch.object(fp, "MANIFEST", (self.job[:3],)):
+            stats = fp.merge(self.out, [(self.term, self.stats, self.labels)])
+        root = self.out / "data" / SOURCE
+        import pyarrow.parquet as pq
+        rows = pq.read_table(root / f"{SOURCE}.parquet").to_pylist()
+        attribution = [json.loads(line) for line in (root / f"{SOURCE}.attribution.jsonl").read_text().splitlines()]
+        with open(root / f"{SOURCE}.speaker-roles.csv", encoding="utf-8") as fh:
+            roles = list(csv.DictReader(fh))
+        return stats, rows, attribution, roles, root
+
+    def test_the_sitting_keeps_only_allowed_speakers(self):
+        _, rows, attribution, _, _ = self.merged()
+        sitting = {r["id"]: r for r in rows}[f"{SOURCE}_201519-sjm-ppxxx-00001-01"]
+        self.assertEqual(sitting["text"].split("\n"), [
+            "(Początek posiedzenia o godz. 10)", "Otwieram posiedzenie Sejmu.", "Proszę o spokój.", LONG.strip(),
+            "(Oklaski)", "Dziękuję panu ministrowi.", "Komisja przyjęła sprawozdanie.", "Zamykam dyskusję.",
+            "Pytanie z wolnej etykiety.", "Głos posła van der Coghena."])
+        line = {a["id"]: a for a in attribution}[sitting["id"]]
+        self.assertEqual(line["speakers"], ["komentarz", "Marszałek", "Poseł Jan Kowalski",
+                                            "Przewodniczący Komisji Finansów Publicznych Jan Kowalski",
+                                            "Przewodnicząca Komisji Zdrowia Ewa Nowak", "Poseł Piotr van der Coghen"])
+        self.assertEqual((sitting["created"], line["date"]), ("2016-01-10, 2016-01-12", "2016-01-10, 11 i 12"))
+        self.assertEqual(line["kept_characters"], len(sitting["text"]))
+
+    def test_dropped_characters_by_reason(self):
+        dropped = self.stats["dropped_chars"]
+        self.assertEqual(dropped["komentarz_colon"], len("Głos z sali: Hańba!"))
+        self.assertEqual(dropped["komentarz_continuation_dropped"], len("Dalszy ciąg wypowiedzi gościa."))
+        self.assertEqual(dropped["speaker:unmatched"], len("Mówię jako gość Komisji."))
+        self.assertEqual(dropped["speaker:chair_not_member"], len("Ich danke."))
+        self.assertEqual(dropped["speaker:bad_name"], len("Głos posła z Litwy."))
+        self.assertEqual(dropped["inline_label_line"], len("Minister Spraw Zagranicznych Ukrainy Borys Tarasiuk:"))
+        self.assertEqual(dropped["inline_speaker"], len("Dziękuję za zaproszenie do Sejmu."))
+        self.assertEqual(dropped["unknown_who"], len("Tekst bez mówcy w nagłówku."))
+        self.assertNotIn("short_doc", dropped)  # the short interpellation is no utterance text
+        self.assertEqual(self.stats["inline_labels"], Counter({"free_guard": 1}))
+        self.assertEqual(self.stats["komentarz"], Counter({
+            "stage_direction": len("(Początek posiedzenia o godz. 10)") + len("(Oklaski)"),
+            "komentarz_colon": len("Głos z sali: Hańba!"), "komentarz_continuation": len("Proszę o spokój."),
+            "komentarz_continuation_dropped": len("Dalszy ciąg wypowiedzi gościa.")}))
+
+    def test_kept_and_dropped_characters_add_up_to_the_utterance_text(self):
+        with zipfile.ZipFile(self.dump / f"{self.TERM}-tei.zip") as z:
+            root = ET.fromstring(z.read(self.SITTING + "text_structure.xml"))
+        total = sum(len(fp.collapse("".join(u.itertext()))) for u in root.iter(f"{fp.T}u"))
+        self.assertEqual(sum(self.stats["kept_chars_by_rule"].values()) + sum(self.stats["dropped_chars"].values()),
+                         total)
+
+    def test_documents_and_persons(self):
+        self.assertEqual(self.stats["dropped_docs"], Counter({"prefix_sejm_2019_2027": 1, "no_text_structure": 1,
+                                                              "short_interpellation": 1}))
+        # the dropped term's header is not counted; the bodiless sitting's header has no persons
+        self.assertEqual(self.stats["persons"], Counter({"structured": 3, "commentary": 1, "role_only": 1,
+                                                         "chair_not_member": 1, "unmatched": 1, "free": 1,
+                                                         "bad_name_member": 1, "bad_name": 1}))
+        self.assertEqual(self.stats["docs_by_category"], Counter({"III RP|Sejm|Posiedzenie plenarne": 1,
+                                                                  "III RP|Sejm|Interpelacja": 1}))
+
+    def test_merge_writes_a_consistent_shard(self):
+        stats, rows, attribution, roles, root = self.merged()
+        self.assertFalse((self.out / "parts").exists())
+        self.assertEqual([r["id"] for r in rows], [a["id"] for a in attribution])
+        self.assertEqual((stats["kept"], stats["chars"], stats["tokens"]),
+                         (len(rows), sum(len(r["text"]) for r in rows), sum(r["token_count"] for r in rows)))
+        self.assertTrue(all(r["token_count"] > 0 and r["source"] == SOURCE and r["license"] == LICENSE
+                            and r["added"] == fp.ADDED for r in rows))
+        interp = {r["id"]: r for r in rows}[f"{SOURCE}_201519-sjm-inxxx-00001"]
+        self.assertEqual(interp["text"], "Szanowny Panie Ministrze,\n" + LONG.strip() + "\nZ poważaniem")
+        self.assertEqual(interp["author"], "Jan Kowalski")
+        self.assertEqual((stats["created_min"], stats["created_max"]), ("2016-01-10", "2016-02-01"))
+        self.assertEqual(stats["date_max_by_house"], {"Sejm": "2016-02-01"})
+        self.assertEqual(stats["licenses"], {LICENSE: 2})
+        self.assertEqual(stats["drop_prefixes"], list(DROP_PREFIXES))
+        include = sum(int(r["characters"]) for r in roles if r["decision"] == "include")
+        self.assertEqual(include, sum(stats["kept_chars_by_rule"].values()))
+        by_role = {(r["role"], r["decision"]): r for r in roles}
+        self.assertEqual(by_role[("Prezes Fundacji Batorego", "exclude")]["characters"],
+                         str(len("Mówię jako gość Komisji.")))
+
+    def test_a_changed_zip_is_refused(self):
+        with self.assertRaisesRegex(SystemExit, "pinned size/SHA-256"):
+            fp.process_zip((self.TERM, self.job[1], "0" * 64, *self.job[3:]))
+
+
+class ShippedShardTest(unittest.TestCase):
+    def test_shard_matches_its_stats_and_attribution(self):
+        import pyarrow.parquet as pq
+
+        table = pq.read_table(DATA / f"{SOURCE}.parquet")
+        self.assertEqual(table.column_names, FIELDS)
+        rows = table.to_pylist()
+        stats = json.loads((DATA / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+        attribution = [json.loads(line) for line in
+                       (DATA / f"{SOURCE}.attribution.jsonl").read_text(encoding="utf-8").splitlines() if line]
+        self.assertEqual(len(rows), stats["kept"])
+        self.assertEqual(sum(len(r["text"]) for r in rows), stats["chars"])
+        self.assertEqual(sum(r["token_count"] for r in rows), stats["tokens"])
+        self.assertEqual(len({r["id"] for r in rows}), len(rows))
+        self.assertEqual([r["id"] for r in rows], [a["id"] for a in attribution])
+        self.assertEqual([r["author"] for r in rows], [a["author"] for a in attribution])
+        self.assertTrue(all(r["source"] == SOURCE and r["license"] == LICENSE and r["token_count"] > 0
+                            and len(r["text"]) >= fp.MIN_CHARS for r in rows))
+        self.assertTrue(all(len(r["created"]) == 10 or (len(r["created"]) == 22 and r["created"][10:12] == ", ")
+                            for r in rows))
+        self.assertEqual(stats["created_min"], min(r["created"][:10] for r in rows))
+        self.assertEqual(stats["created_max"], max(r["created"][-10:] for r in rows))
+        self.assertFalse([a for a in attribution if a["ppc_path"].startswith(DROP_PREFIXES)])
+        self.assertLessEqual(stats["date_max_by_house"]["Sejm"], PARLIAMENTARY_SEJM_END)
+        self.assertEqual(stats["sejm_coverage_end"], PARLIAMENTARY_SEJM_END)
+
+    def test_speaker_roles_table_matches_the_stats(self):
+        stats = json.loads((DATA / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+        with open(DATA / f"{SOURCE}.speaker-roles.csv", encoding="utf-8") as fh:
+            roles = list(csv.DictReader(fh))
+        include = Counter()
+        for row in roles:
+            if row["decision"] == "include":
+                include[row["rule"]] += int(row["characters"])
+        self.assertEqual(dict(include), stats["kept_chars_by_rule"])
+
+    def test_card_and_legal_note_cite_the_stats(self):
+        from sources import SOURCES
+
+        stats = json.loads((DATA / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+        card = (DATA / f"{SOURCE}.md").read_text(encoding="utf-8")
+        kept, dropped = sum(stats["kept_chars_by_rule"].values()), sum(stats["dropped_chars"].values())
+        self.assertIn(f"**{stats['kept']:,} records / {stats['tokens']:,} `cl100k_base` tokens / "
+                      f"{stats['chars']:,} characters**", card)
+        self.assertIn(f"**{stats['redactions']:,} redactions**", card)
+        docs, flat = stats["dropped_docs"], " ".join(card.split())
+        self.assertIn(f"{docs['empty_sitting']:,} sittings keep no turn and {docs['empty_interpellation']:,} "
+                      f"interpellation records have no text; {docs['short_sitting']:,} sittings and "
+                      f"{docs['short_interpellation']:,} interpellation records have under", flat)
+        for rule, chars in stats["kept_chars_by_rule"].items():
+            self.assertIn(f"| `{rule}` |", card)
+            self.assertIn(f"| {chars:,} |", card)
+        for reason, chars in stats["dropped_chars"].items():
+            self.assertIn(f"| `{reason}` | {chars:,} |", card)
+        utterance = f"{kept:,} of {kept + dropped:,} characters of utterance text ({100 * kept / (kept + dropped):.1f}%)"
+        self.assertIn(utterance, card)
+        self.assertIn(utterance, " ".join(SOURCES[SOURCE]["legal_note"].split()))
+
+
+if __name__ == "__main__":
+    unittest.main()

src/test_sejm_api_contract.py

@@ -125,12 +125,15 @@ class DynawordContractTests(unittest.TestCase):
                 start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder()
             )
 
-    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_temporal_novelty_uses_the_sejm_end_of_parliamentary(self) -> None:
+        # The registry range of `parliamentary` runs to 2025 (Senate); only its Sejm material counts.
+        self.assertEqual(SOURCES["parliamentary"]["created"].split(", ")[1][:4], "2025")
+        self.assertEqual(assert_temporal_novelty(START_DATE), {"parliamentary": "2019-11-11"})
+        self.assertEqual(assert_temporal_novelty("2019-11-12"), {"parliamentary": "2019-11-11"})
 
     def test_overlap_with_registered_parliamentary_fails_closed(self) -> None:
         with self.assertRaisesRegex(ContributionError, "overlaps"):
-            assert_temporal_novelty(REGISTRY, "2019-06-01")
+            assert_temporal_novelty("2019-11-11")
 
     def test_registry_entry_is_valid_and_preserves_existing_sources(self) -> None:
         updated = insert_source_registry_entry(REGISTRY, end_date="2026-07-03")
@@ -147,7 +150,6 @@ class DynawordContractTests(unittest.TestCase):
 
     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)
 

src/test_sejm_committee_transcripts_contract.py

@@ -283,6 +283,12 @@ class RedactionTest(unittest.TestCase):
         self.assertEqual(n, 1)
         self.assertEqual(text.count("[DANE_NUMERY]"), 1)
 
+    def test_fourteen_digit_regon(self):
+        # This used to raise IndexError (check digit read at index 14).
+        text, _ = redact("REGON 12345678512347 oraz 12345678512348.")
+        self.assertNotIn("12345678512347", text)
+        self.assertIn("12345678512348", text)
+
     def test_email_phone_iban_masked(self):
         text, n = redact("pisać na jan.kowalski@sejm.gov.pl, tel. 22 694 12 34, IBAN PL61109010140000071219812874")
         self.assertGreaterEqual(n, 3)
@@ -758,6 +764,17 @@ class RoleLabelTest(unittest.TestCase):
                                 ["Poseł", "include", "mp", 2, 100, 1],
                                 ["Prezes NIK", "include", "constitutional_organ_head", 1, 50, 1]])
 
+    def test_roles_table_takes_the_roles_it_is_given(self):
+        # fetch_parliamentary passes (role, label, rule) keys with their roles already cut.
+        rows = clean.roles_table({("Poseł", "Poseł Jan Kowalski", "mp_no_party"): (2, 100, "mp_no_party"),
+                                  ("Poseł", "Poseł Anna Nowak", "mp_no_party"): (1, 30, "mp_no_party"),
+                                  ("Ekspert", "Ekspert Adam Nowak", None): (1, 50, None)},
+                                 {("Poseł", "Poseł Jan Kowalski", "mp_no_party"): "Poseł",
+                                  ("Poseł", "Poseł Anna Nowak", "mp_no_party"): "Poseł",
+                                  ("Ekspert", "Ekspert Adam Nowak", None): "Ekspert"})
+        self.assertEqual(rows, [["Poseł", "include", "mp_no_party", 3, 130, 2],
+                                ["Ekspert", "exclude", "", 1, 50, 1]])
+
 
 class CleanScriptTest(unittest.TestCase):
     """clean_sejm_committee_transcripts.build() on a small pinned input."""