sejm_interpellations: Art. 4 wording, SIS credit, acquisition route and attribution sidecar (v2#107)

data/sejm_interpellations/sejm_interpellations.attribution.jsonl

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

data/sejm_interpellations/sejm_interpellations.license-evidence.json

@@ -68,6 +68,15 @@
       ],
       "quote": "teksty interpelacji, którym Prezydium Sejmu nadało bieg, są udostępniane w Systemie Informacyjnym Sejmu"
     },
+    "live_capture": {
+      "retrieved": "2026-10-19",
+      "method": "read in a browser; scripted fetches get a bot-verification page, so the content block was saved from the rendered page",
+      "sha256_of_content_html": "cb4d21a44f5b09d50cdf95518aad77632b2750b5df6535c1d8aa894152b80469",
+      "archived_in": "slayerlabs/polish-dynaword-v2, evidence/sis_copyright_2026-10-19.{content.html,meta.json,md} (pull request 121)",
+      "source_note_present": true,
+      "commercial_offer_clause_present": true,
+      "reading": "Same source note and same commercial-offer clause as the 2026-06-03 capture. The page does not say the terms cover api.sejm.gov.pl output; the clause is reported as information, not as a licence term of this dataset."
+    },
     "api_channel": "V: the API documentation, response headers and a sampled interpellation body (term 10, no. 1) carry no terms. No source states that API output is part of SIS; SIS is defined as the www.sejm.gov.pl system (Regulamin art. 201a; Zarządzenie Szefa KS 3/2006 § 1).",
     "reading": "I: the commercial-offer clause is not among the conditions Open Data Act art. 15 ust. 1 allows and runs against arts 14 ust. 1, 16 and 17; it could bind only through rights the Kancelaria holds (art. 14 ust. 2), and replies are written by ministries, not the Kancelaria. The source-note clause fits art. 15 ust. 1 pkt 1; the datasheet carries the requested wording as a precaution.",
     "source": "artifacts/rights_audit_2026-10/reports/citations/sejm_sis.md (W1-W4, D1, D4, D7, C1-C5, L7-L15)"
@@ -90,7 +99,7 @@
   ],
   "not_checked": [
     "lawyer review of the statutory basis and of the SIS terms",
-    "the live SIS page on the fetch date (bot challenge; latest readable capture 2026-06-03)",
+    "the live SIS page on the fetch date (bot challenge then; a later live read, 2026-10-19, is in sis_terms.live_capture; latest archived capture 2026-06-03)",
     "the Kancelaria Sejmu BIP 'Ponowne wykorzystywanie' page (bip.sejm.gov.pl did not connect; Wayback answered 429)",
     "whether the API interpellation bodies are the same documents as those on www.sejm.gov.pl",
     "the exact fetch date: 2026-09-05 is inferred from the findings log, the input file date and the last record (2026-09-03)",

data/sejm_interpellations/sejm_interpellations.md

@@ -16,26 +16,42 @@ ministerstw dostępnymi jako HTML.
 
 ## Licensing — traceable basis
 
-Official parliamentary materials are excluded from copyright under Polish
-Copyright Act art. 4 pkt 2
-(https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf). Reuse of
-public-sector information is governed by the Polish Open Data Act arts. 2(12),
-5, 14 and 17 (https://eli.gov.pl/api/acts/DU/2023/1524/text.html). Same basis
-as the shipped `sejm_api` shard. No Creative Commons grant is asserted.
+**Legal status (our assessment).** We consider the interpellations, written
+questions and replies in this shard official documents, excluded from copyright under
+Art. 4 pkt 2 of the Polish Copyright Act (official documents, materials, signs and
+symbols; text: https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf).
+That is a statement of Polish law only; their status may differ in other jurisdictions.
+The label `public-domain (official documents)` is a descriptive term for this status, not
+a licence: no Creative Commons public-domain mark (CC0, Public Domain Mark) is applied or
+implied, and no upstream Creative Commons license is asserted. api.sejm.gov.pl states no
+licence or terms of use, and we found no disclaimer on it. The statement does not extend
+to third-party fragments quoted inside the documents (for example constituents' letters
+and press articles), and personal data is a separate matter (see "Privacy and
+limitations"). The Open Data Act (Dz. U. 2023 poz. 1524, articles 2(12), 5, 6, 14, 15 and
+17; text: https://eli.gov.pl/api/acts/DU/2023/1524/text.html) is cited as the reuse framework for the institutions' own
+material, not as a basis for third-party works.
 
 Caveats (quotes, URLs and hashes in `sejm_interpellations.license-evidence.json`;
 not lawyer-reviewed):
 
-- **SIS terms.** The Regulamin Sejmu places interpellations, replies and written
-  questions in the System Informacyjny Sejmu (arts. 192 ust. 7, 193 ust. 2,
-  195 ust. 2). The Sejm's SIS page asks for a source note on material taken from
-  www.sejm.gov.pl and bars SIS material from being part of a commercial offer of
-  any agency, TV station, portal or other entity. No terms were found on
-  api.sejm.gov.pl, in its documentation or in a sampled body, and no source says
-  that API output is part of SIS. The commercial clause is not among the
-  conditions Open Data Act art. 15 ust. 1 allows (see also arts. 14 ust. 1, 16
-  and 17), so whether it binds is doubtful. As a precaution, the requested source
-  note: Źródłem tym jest System Informacyjny Sejmu.
+- **SIS terms and credit.** The Regulamin Sejmu places interpellations, replies and written
+  questions in the System Informacyjny Sejmu (SIS; arts. 192 ust. 7, 193 ust. 2,
+  195 ust. 2). The terms page of SIS, read on 2026-10-19, asks that material taken from
+  www.sejm.gov.pl name its source: "Źródłem tym jest System Informacyjny Sejmu". No terms
+  were found on api.sejm.gov.pl, in its documentation or in a sampled body, and no source
+  says that API output is part of SIS. As a precaution we give the credit:
+
+  > Źródło: System Informacyjny Sejmu (Kancelaria Sejmu RP)
+
+  The same page says that SIS material, in particular live streams and archive material
+  produced by iTV Sejm, "nie mogą być elementem komercyjnej oferty żadnej agencji, stacji
+  telewizyjnej, portalu ani innego podmiotu". We report that clause as information only.
+  It is not a licence term of this dataset, and we have not verified whether it reaches
+  these texts or binds a re-user. Our reading is that it is not among the conditions Open
+  Data Act art. 15 ust. 1 allows (see also arts. 14 ust. 1, 16 and 17), so whether it binds
+  is doubtful. A dated copy of the page (SHA-256 `cb4d21a44f5b09d50cdf95518aad77632b2750b5df6535c1d8aa894152b80469`) is kept in
+  polish-dynaword-v2 (`evidence/sis_copyright_2026-10-19.*`, pull request 121); the root
+  `NOTICE.md` has the details.
 - **Replies** are written by ministries and other bodies (named in `author`),
   not by the Kancelaria Sejmu.
 - **Third-party quotations.** In the rights audit's 3,900-document sample, 2.2%
@@ -59,11 +75,25 @@ interpellations through 2019).
 
 ## Provenance and reproducibility
 
+- Route: the API directly, no intermediary. `src/fetch_sejm_interpellations.py` reads the
+  HTML `/body` endpoints of api.sejm.gov.pl (Kancelaria Sejmu RP); this repository names no
+  copy of the data held by a third party.
+- Acquired: the fetch date is not recorded. The raw output file
+  `~/speakleash/sejm_interpellations.jsonl.zst` (26,503 lines, SHA-256
+  `cc06156352220b653cdab20a694560bb1e9e958af576526395ffcf10d7c14a09`) has the file time
+  2026-09-05 19:42 CEST, so the fetch ended on or before that day; the latest record is dated
+  2026-09-03, so it ended on or after that day. The shard's `added` date, 2026-09-05, is the
+  registry's date, not a measured one.
+
 ```bash
-python3 src/fetch_sejm_interpellations.py --out ~/speakleash --terms 9,10 --workers 4
+python3 src/fetch_sejm_interpellations.py --out ~/speakleash --terms 10
 python3 src/build_dynaword.py --sources sejm_interpellations --speakleash-dir ~/speakleash --out .
+python3 src/build_sejm_interpellations_attribution.py --raw ~/speakleash/sejm_interpellations.jsonl.zst
 ```
 
+A new fetch returns what the API serves on the day, so it does not reproduce this shard byte
+for byte; the raw file used here is not in the repository.
+
 `src/fetch_sejm_interpellations.py` pulls HTML `/body` endpoints, strips
 header chrome (nr / recipient / title / signatory / date) into `meta`, then
 runs pattern PII redaction (the `scrub_pii` pass from #20 at build time —
@@ -130,6 +160,24 @@ w sprawie Instytutu Polskiego w Szwajcarii, uprzejmie informuję, co
 następuje. […]
 ```
 
+## Attribution sidecar
+
+`sejm_interpellations.attribution.jsonl` has one line per Parquet row, in row order (25,950
+lines): `id`, `source_url` (the API document the text came from), `term`, `num`, `kind`
+(`interpellation`, `written_question`, `interpellation_reply` or `written_question_reply`),
+`date` (the API's `receiptDate`), `reply_key` (replies only), `text_sha1` (SHA-1 of the
+stored text) and, when other API documents have exactly the same text, `identical_text_urls`
+(their URLs, in raw order). The build kept one document per distinct text: 129 rows have such
+duplicates, 553 dropped documents in all. The title and the author are not repeated: the
+title is header chrome kept out of the text and can name private persons (the NERGAL pass is
+pending), and the author is already a column.
+
+The shard does not record which document of a duplicate group survived. The builder
+recovers it from the raw file without a new fetch: the order of the shard's rows gives the
+order in which the build's worker chunks arrived, the dedup is replayed in that order and
+must reproduce the shard's sequence of texts exactly, and the author on each survivor must
+equal the shard's author. Any mismatch stops the build; nothing is guessed.
+
 ## Privacy and limitations
 
 Regex PII scrub at fetch time is not a guarantee of zero personal data.

src/build_sejm_interpellations_attribution.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Rebuild the per-record attribution sidecar of the sejm_interpellations shard (v2#107).
+
+The shard was built by `build_dynaword.py` from the raw fetch output of `fetch_sejm_interpellations.py`
+(`sejm_interpellations.jsonl.zst`, one JSON object per line: `text` plus `meta`). The build dropped the
+`meta` and kept one row per distinct stripped text, so the shard alone does not say which API document
+a row came from. This script recovers that from the raw file without a new fetch.
+
+Which document survived a duplicate text is decided by the build, not by the text: it cuts the raw
+lines into chunks of 2000, processes them in a pool with `imap_unordered` (arrival order is not
+deterministic), and keeps the first row of a text it sees, so the survivor is the row from the chunk that
+arrived first and, inside a chunk, the lowest line. The arrival order is not stored. It is recovered
+from the shard itself: the kept rows of a chunk are contiguous in the Parquet, in line order, so the
+order in which the chunks first appear among the rows whose text occurs once in the raw file is the
+arrival order. The dedup is then replayed over the raw chunks in that order, and the replay must give
+exactly the shard's sequence of texts; any difference raises. A chunk that cannot be placed (all its
+rows share a text with another chunk) raises as well. Nothing is guessed.
+
+Sidecar line (sorted keys, one per Parquet row, same order): `id`, `source_url` (the API document the
+row came from), `term`, `num`, `kind`, `date` (the document's date), `reply_key` (replies only),
+`text_sha1` (SHA-1 of the stored text), `identical_text_urls` (other API documents with the same text, in
+raw order; only when there are any). The title and the author are not written: the title is
+header chrome kept out of the text and can name private persons (the NERGAL pass is pending), and the
+author is already a Parquet column. The author is used as a cross-check, and a mismatch raises.
+
+Usage:
+  python3 src/build_sejm_interpellations_attribution.py \\
+      --raw ~/speakleash/sejm_interpellations.jsonl.zst
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import shutil
+import subprocess
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SOURCE = "sejm_interpellations"
+PARQUET = ROOT / "data" / SOURCE / f"{SOURCE}.parquet"
+SIDECAR = ROOT / "data" / SOURCE / f"{SOURCE}.attribution.jsonl"
+# build_dynaword.py: `_chunks(line_iter, 2000)`; test_sejm_interpellations_attribution.py keeps this in sync.
+CHUNK_LINES = 2000
+
+
+def sha1_hex(text: str) -> str:
+    return hashlib.sha1(text.encode("utf-8")).hexdigest()
+
+
+def read_raw_lines(path: Path):
+    """Non-blank lines of the .jsonl.zst, as `build_dynaword.build_source` reads them (`zstd -dc` or zstandard)."""
+    executable = shutil.which("zstd")
+    if executable:
+        proc = subprocess.Popen([executable, "-dc", str(path)], stdout=subprocess.PIPE, bufsize=1 << 22)
+        try:
+            for raw in proc.stdout:
+                line = raw.decode("utf-8")
+                if line.strip():
+                    yield line
+        finally:
+            proc.stdout.close()
+            if proc.wait() != 0:
+                raise RuntimeError(f"zstd -dc failed on {path}")
+        return
+    try:
+        import zstandard
+    except ImportError as exc:
+        raise RuntimeError("reading .zst requires zstd or Python zstandard: pip install zstandard") from exc
+    with path.open("rb") as handle:
+        for line in io.TextIOWrapper(zstandard.ZstdDecompressor().stream_reader(handle), encoding="utf-8"):
+            if line.strip():
+                yield line
+
+
+def parse_raw(lines) -> list[dict | None]:
+    """One entry per non-blank line, in order (the chunk index is the line index // CHUNK_LINES).
+
+    A line that is not JSON, or has no `text`/`meta`, is None: the build skips such a line but still
+    counts it in its chunk, so the position is kept.
+    """
+    rows: list[dict | None] = []
+    for line in lines:
+        try:
+            row = json.loads(line)
+            text = (row.get("text") or "").strip()
+            meta = row["meta"]
+        except Exception:
+            rows.append(None)
+            continue
+        rows.append({"key": sha1_hex(text), "meta": meta})
+    return rows
+
+
+def resolve(raw: list[dict | None], shard: list[dict], chunk_lines: int = CHUNK_LINES) -> list[dict]:
+    """For every shard row (`id`, `text`, `author`, in order) return its survivor and its duplicates.
+
+    Returns dicts `{"id", "key", "survivor": raw index, "others": [raw indices]}`. Raises ValueError on
+    any inconsistency between the raw file and the shard.
+    """
+    by_key: dict[str, list[int]] = defaultdict(list)
+    for index, row in enumerate(raw):
+        if row is not None:
+            by_key[row["key"]].append(index)
+
+    keys = []
+    for row in shard:
+        if row["text"] != row["text"].strip():
+            raise ValueError(f"{row['id']}: stored text is not stripped, so it is not what the build kept")
+        keys.append(sha1_hex(row["text"]))
+    if len(set(keys)) != len(keys):
+        raise ValueError("the shard repeats a text, so it is not the output of the exact dedup")
+    absent = [row["id"] for row, key in zip(shard, keys) if key not in by_key]
+    if absent:
+        raise ValueError(f"{len(absent)} shard rows have no raw line with their text (first: {absent[0]}); "
+                         "this is not the raw file the shard was built from")
+
+    # Arrival order of the chunks: first appearance among the rows whose text occurs on one raw line.
+    order = list(dict.fromkeys(by_key[key][0] // chunk_lines for key in keys if len(by_key[key]) == 1))
+    placed = set(order)
+    for key in keys:
+        for index in by_key[key]:
+            if index // chunk_lines not in placed:
+                raise ValueError(f"chunk {index // chunk_lines} holds a kept text but no text that occurs only "
+                                 "once, so its arrival order cannot be recovered")
+
+    # Replay the build's dedup over the raw chunks in that order. A raw line whose text is not in the shard
+    # was dropped by a gate (length, language) before the dedup and never entered `seen`.
+    kept = set(keys)
+    seen: set[str] = set()
+    survivors: list[int] = []
+    for chunk in order:
+        for index in range(chunk * chunk_lines, min((chunk + 1) * chunk_lines, len(raw))):
+            row = raw[index]
+            if row is None or row["key"] not in kept or row["key"] in seen:
+                continue
+            seen.add(row["key"])
+            survivors.append(index)
+    replay = [raw[index]["key"] for index in survivors]
+    if replay != keys:
+        position = next((i for i, (a, b) in enumerate(zip(replay, keys)) if a != b), min(len(replay), len(keys)))
+        raise ValueError(f"the replayed dedup differs from the shard at row {position} "
+                         f"(replay has {len(replay)} rows, shard {len(keys)})")
+
+    return [{"id": row["id"], "key": key, "survivor": survivor,
+             "others": [i for i in by_key[key] if i != survivor]}
+            for row, key, survivor in zip(shard, keys, survivors)]
+
+
+def sidecar_lines(raw: list[dict | None], shard: list[dict], chunk_lines: int = CHUNK_LINES) -> list[str]:
+    resolved = resolve(raw, shard, chunk_lines)
+    lines = []
+    for row, hit in zip(shard, resolved):
+        meta = raw[hit["survivor"]]["meta"]
+        if (meta.get("author") or "").strip() != (row["author"] or "").strip():
+            raise ValueError(f"{row['id']}: author {row['author']!r} in the shard, {meta.get('author')!r} on the "
+                             f"survivor {meta.get('url')}")
+        record = {"id": row["id"], "source_url": meta["url"], "term": meta["term"], "num": meta["num"],
+                  "kind": meta["kind"], "date": meta["date"], "text_sha1": hit["key"]}
+        if meta.get("reply_key"):
+            record["reply_key"] = meta["reply_key"]
+        others = [raw[i]["meta"]["url"] for i in hit["others"]]
+        if others:
+            record["identical_text_urls"] = others
+        lines.append(json.dumps(record, ensure_ascii=False, sort_keys=True))
+    return lines
+
+
+def read_shard(path: Path) -> list[dict]:
+    import pyarrow.parquet as pq
+    table = pq.read_table(path, columns=["id", "text", "author"])
+    return [{"id": i, "text": t, "author": a} for i, t, a in
+            zip(table["id"].to_pylist(), table["text"].to_pylist(), table["author"].to_pylist())]
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("--raw", required=True, type=Path, help="sejm_interpellations.jsonl.zst from fetch_sejm_interpellations.py")
+    ap.add_argument("--parquet", type=Path, default=PARQUET)
+    ap.add_argument("--out", type=Path, default=SIDECAR)
+    args = ap.parse_args(argv)
+    raw = parse_raw(read_raw_lines(args.raw.expanduser()))
+    shard = read_shard(args.parquet)
+    lines = sidecar_lines(raw, shard)
+    args.out.write_text("".join(line + "\n" for line in lines), encoding="utf-8")
+    duplicates = sum(1 for line in lines if '"identical_text_urls"' in line)
+    print(f"{args.out}: {len(lines):,} rows from {len(raw):,} raw lines; {duplicates:,} rows have identical-text duplicates")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/test_sejm_interpellations_attribution.py

@@ -0,0 +1,266 @@
+"""Tests for the sejm_interpellations attribution sidecar builder (v2#107)."""
+import io
+import json
+import random
+import re
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import build_sejm_interpellations_attribution as B
+
+ROOT = Path(__file__).resolve().parent.parent
+DATA = ROOT / "data" / "sejm_interpellations"
+PARQUET = DATA / "sejm_interpellations.parquet"
+SIDECAR = DATA / "sejm_interpellations.attribution.jsonl"
+STATS = DATA / "sejm_interpellations.stats.json"
+SOURCE_CODE = Path(__file__).resolve().parent / "build_dynaword.py"
+
+
+def meta(num, author="A", kind="interpellation", reply_key=None, date="2024-01-01"):
+    suffix = f"/reply/{reply_key}/body" if reply_key else "/body"
+    m = {"url": f"https://api.sejm.gov.pl/sejm/term10/interpellations/{num}{suffix}", "term": 10, "num": num,
+         "kind": kind, "title": f"title {num}", "date": date, "author": author}
+    if reply_key:
+        m["reply_key"] = reply_key
+    return m
+
+
+def raw_rows(spec):
+    """spec: list of (text, num) or (text, num, extra-meta dict); None for an unparseable line."""
+    rows = []
+    for item in spec:
+        if item is None:
+            rows.append(None)
+            continue
+        text, num, *extra = item
+        rows.append({"key": B.sha1_hex(text.strip()), "meta": meta(num, **(extra[0] if extra else {}))})
+    return rows
+
+
+def simulate_build(texts, authors, order, chunk_lines):
+    """The shard `build_source` writes when its chunks arrive in `order`: global `seen`, a chunk's rows in line order."""
+    seen, shard = set(), []
+    for chunk in order:
+        for i in range(chunk * chunk_lines, min((chunk + 1) * chunk_lines, len(texts))):
+            text = texts[i]
+            if text is None or B.sha1_hex(text) in seen:
+                continue
+            seen.add(B.sha1_hex(text))
+            shard.append({"id": f"s_{len(shard)}", "text": text, "author": authors[i], "line": i})
+    return shard
+
+
+class ResolveTest(unittest.TestCase):
+    def test_no_duplicates_every_row_is_its_own_survivor(self):
+        raw = raw_rows([("a", 1), ("b", 2), ("c", 3), ("d", 4)])
+        shard = [{"id": f"s{i}", "text": t, "author": "A"} for i, t in enumerate("abcd")]
+        out = B.resolve(raw, shard, chunk_lines=2)
+        self.assertEqual([h["survivor"] for h in out], [0, 1, 2, 3])
+        self.assertTrue(all(h["others"] == [] for h in out))
+
+    def test_arrival_order_decides_which_duplicate_survives(self):
+        # chunk 0 = [x, u1], chunk 1 = [x, u2]; x is on lines 0 and 2
+        raw = raw_rows([("x", 1), ("u1", 2), ("x", 3), ("u2", 4)])
+        first = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "u1", "author": "A"},
+                 {"id": "s2", "text": "u2", "author": "A"}]
+        self.assertEqual([h["survivor"] for h in B.resolve(raw, first, chunk_lines=2)], [0, 1, 3])
+        second = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "u2", "author": "A"},
+                  {"id": "s2", "text": "u1", "author": "A"}]
+        # chunk 1 arrived first: its x (line 2) survives, and its rows come before chunk 0's
+        out = B.resolve(raw, second, chunk_lines=2)
+        self.assertEqual([h["survivor"] for h in out], [2, 3, 1])
+        self.assertEqual(out[0]["others"], [0])
+
+    def test_duplicate_inside_one_chunk_keeps_the_lowest_line(self):
+        raw = raw_rows([("x", 1), ("x", 2), ("y", 3), ("z", 4)])
+        shard = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "y", "author": "A"},
+                 {"id": "s2", "text": "z", "author": "A"}]
+        out = B.resolve(raw, shard, chunk_lines=4)
+        self.assertEqual([h["survivor"] for h in out], [0, 2, 3])
+        self.assertEqual(out[0]["others"], [1])
+
+    def test_texts_are_compared_stripped(self):
+        raw = raw_rows([("  x\n", 1), ("x", 2), ("y", 3), ("z", 4)])
+        shard = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "y", "author": "A"},
+                 {"id": "s2", "text": "z", "author": "A"}]
+        out = B.resolve(raw, shard, chunk_lines=4)
+        self.assertEqual((out[0]["survivor"], out[0]["others"]), (0, [1]))
+
+    def test_gated_raw_line_is_ignored(self):
+        # "tiny" never reached the dedup (a gate dropped it): it is not in the shard and changes nothing
+        raw = raw_rows([("x", 1), ("tiny", 2), ("y", 3), ("x", 4), ("z", 5), ("w", 6)])
+        shard = [{"id": f"s{i}", "text": t, "author": "A"} for i, t in enumerate("xyzw")]
+        out = B.resolve(raw, shard, chunk_lines=3)
+        self.assertEqual([h["survivor"] for h in out], [0, 2, 4, 5])
+        self.assertEqual(out[0]["others"], [3])
+
+    def test_unparseable_line_keeps_its_position_in_the_chunk(self):
+        raw = raw_rows([("x", 1), None, ("y", 3), ("z", 4)])
+        shard = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "y", "author": "A"},
+                 {"id": "s2", "text": "z", "author": "A"}]
+        # chunks of 2: [x, None] [y, z]; arrival order is read off x then y
+        self.assertEqual([h["survivor"] for h in B.resolve(raw, shard, chunk_lines=2)], [0, 2, 3])
+
+    def test_chunk_that_cannot_be_placed_raises(self):
+        # chunk 1 = [x, y] repeats the texts of chunk 0 = [x, y]: no text occurs once there, so its place is unknown
+        raw = raw_rows([("x", 1), ("y", 2), ("x", 3), ("y", 4), ("z", 5), ("w", 6)])
+        shard = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "y", "author": "A"},
+                 {"id": "s2", "text": "z", "author": "A"}, {"id": "s3", "text": "w", "author": "A"}]
+        with self.assertRaisesRegex(ValueError, "arrival order cannot be recovered"):
+            B.resolve(raw, shard, chunk_lines=2)
+
+    def test_shard_that_the_replay_cannot_reproduce_raises(self):
+        raw = raw_rows([("x", 1), ("y", 2), ("z", 3), ("w", 4)])
+        swapped = [{"id": "s0", "text": "y", "author": "A"}, {"id": "s1", "text": "x", "author": "A"},
+                   {"id": "s2", "text": "z", "author": "A"}, {"id": "s3", "text": "w", "author": "A"}]
+        with self.assertRaisesRegex(ValueError, "replayed dedup differs from the shard at row 0"):
+            B.resolve(raw, swapped, chunk_lines=2)
+
+    def test_text_not_in_the_raw_file_raises(self):
+        raw = raw_rows([("x", 1), ("y", 2)])
+        shard = [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "other", "author": "A"}]
+        with self.assertRaisesRegex(ValueError, "not the raw file"):
+            B.resolve(raw, shard, chunk_lines=2)
+
+    def test_unstripped_or_repeated_shard_text_raises(self):
+        raw = raw_rows([("x", 1), ("y", 2)])
+        with self.assertRaisesRegex(ValueError, "not stripped"):
+            B.resolve(raw, [{"id": "s0", "text": "x ", "author": "A"}], chunk_lines=2)
+        with self.assertRaisesRegex(ValueError, "repeats a text"):
+            B.resolve(raw, [{"id": "s0", "text": "x", "author": "A"}, {"id": "s1", "text": "x", "author": "A"}],
+                      chunk_lines=2)
+
+    def test_random_builds_are_recovered_for_every_arrival_order(self):
+        rng = random.Random(20261019)
+        for trial in range(200):
+            chunk_lines = rng.choice([2, 3, 5])
+            n = rng.randint(6, 30)
+            pool = [f"text {k}" for k in range(rng.randint(3, n))]
+            texts = [rng.choice(pool) for _ in range(n)]
+            authors = [f"author {i}" for i in range(n)]
+            n_chunks = -(-n // chunk_lines)
+            order = list(range(n_chunks))
+            rng.shuffle(order)
+            shard = simulate_build(texts, authors, order, chunk_lines)
+            raw = raw_rows([(t, i, {"author": authors[i]}) for i, t in enumerate(texts)])
+            try:
+                out = B.resolve(raw, [{k: v for k, v in r.items() if k != "line"} for r in shard], chunk_lines)
+            except ValueError as exc:
+                # the only allowed failure: a chunk whose texts all occur in other chunks too
+                self.assertIn("arrival order cannot be recovered", str(exc), (trial, texts, order))
+                continue
+            self.assertEqual([h["survivor"] for h in out], [r["line"] for r in shard], (trial, texts, order))
+
+
+class SidecarLinesTest(unittest.TestCase):
+    def setUp(self):
+        self.raw = raw_rows([
+            ("question text", 1, {"author": "Poseł", "kind": "interpellation", "date": "2024-01-02"}),
+            ("reply text", 2, {"author": "Minister", "kind": "interpellation_reply", "reply_key": "R1",
+                               "date": "2024-02-03"}),
+            ("question text", 9, {"author": "Poseł 2", "kind": "interpellation"}),
+        ])
+        self.shard = [{"id": "s0", "text": "question text", "author": "Poseł"},
+                      {"id": "s1", "text": "reply text", "author": "Minister"}]
+
+    def test_fields_and_order(self):
+        lines = B.sidecar_lines(self.raw, self.shard, chunk_lines=3)
+        first, second = [json.loads(line) for line in lines]
+        self.assertEqual(first, {
+            "id": "s0", "source_url": "https://api.sejm.gov.pl/sejm/term10/interpellations/1/body", "term": 10,
+            "num": 1, "kind": "interpellation", "date": "2024-01-02", "text_sha1": B.sha1_hex("question text"),
+            "identical_text_urls": ["https://api.sejm.gov.pl/sejm/term10/interpellations/9/body"]})
+        self.assertEqual(second["reply_key"], "R1")
+        self.assertNotIn("identical_text_urls", second)
+        self.assertEqual(list(first), sorted(first))  # keys sorted
+        for record in (first, second):
+            self.assertNotIn("title", record)
+            self.assertNotIn("author", record)
+
+    def test_author_mismatch_raises(self):
+        self.shard[0]["author"] = "Someone else"
+        with self.assertRaisesRegex(ValueError, "s0: author"):
+            B.sidecar_lines(self.raw, self.shard, chunk_lines=3)
+
+    def test_author_comparison_ignores_surrounding_whitespace(self):
+        self.shard[0]["author"] = " Poseł "
+        self.assertEqual(len(B.sidecar_lines(self.raw, self.shard, chunk_lines=3)), 2)
+
+
+class ParseRawTest(unittest.TestCase):
+    def test_bad_lines_become_none_and_keep_their_position(self):
+        rows = B.parse_raw(['{"text": " a ", "meta": {"url": "u"}}\n', "not json\n", '{"text": "b"}\n',
+                            '{"text": null, "meta": {}}\n'])
+        self.assertEqual(rows[0], {"key": B.sha1_hex("a"), "meta": {"url": "u"}})
+        self.assertIsNone(rows[1])
+        self.assertIsNone(rows[2])  # no meta
+        self.assertEqual(rows[3], {"key": B.sha1_hex(""), "meta": {}})
+
+    def test_read_raw_lines_skips_blank_lines(self):
+        payload = b'{"text": "a", "meta": {}}\n\n   \n{"text": "b", "meta": {}}\n'
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "x.jsonl.zst"
+            try:
+                import zstandard
+                path.write_bytes(zstandard.ZstdCompressor().compress(payload))
+            except ImportError:
+                if not shutil.which("zstd"):
+                    self.skipTest("no zstandard and no zstd binary")
+                import subprocess
+                path.write_bytes(subprocess.run(["zstd", "-c"], input=payload, capture_output=True, check=True).stdout)
+            self.assertEqual(len(list(B.read_raw_lines(path))), 2)
+
+
+class ChunkSizeTest(unittest.TestCase):
+    def test_chunk_size_matches_build_dynaword(self):
+        self.assertIn(f"_chunks(line_iter, {B.CHUNK_LINES})", SOURCE_CODE.read_text(encoding="utf-8"))
+
+
+@unittest.skipUnless(SIDECAR.is_file() and PARQUET.is_file(), "sidecar not built")
+class ShippedSidecarTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        import pyarrow.parquet as pq
+        cls.table = pq.read_table(PARQUET, columns=["id", "text"])
+        cls.lines = [json.loads(line) for line in SIDECAR.read_text(encoding="utf-8").splitlines()]
+        cls.stats = json.loads(STATS.read_text(encoding="utf-8"))
+
+    def test_one_line_per_row_in_parquet_order(self):
+        self.assertEqual([r["id"] for r in self.lines], self.table["id"].to_pylist())
+
+    def test_text_sha1_matches_the_stored_text(self):
+        for record, text in zip(self.lines, self.table["text"].to_pylist()):
+            self.assertEqual(record["text_sha1"], B.sha1_hex(text), record["id"])
+
+    def test_every_raw_document_is_accounted_for_once(self):
+        urls = [r["source_url"] for r in self.lines] + [u for r in self.lines for u in r.get("identical_text_urls", [])]
+        self.assertEqual(len(urls), len(set(urls)))
+        self.assertEqual(len(urls), self.stats["read"] - self.stats["drop_short"] - self.stats["drop_lang"]
+                         - self.stats["drop_ocr"])
+        self.assertEqual(sum(len(r.get("identical_text_urls", [])) for r in self.lines), self.stats["drop_dup"])
+
+    def test_urls_agree_with_their_fields(self):
+        pattern = re.compile(r"^https://api\.sejm\.gov\.pl/sejm/term(\d+)/(interpellations|writtenQuestions)/(\d+)"
+                             r"(?:/reply/([A-Z0-9]+))?/body$")
+        collection = {"interpellation": "interpellations", "interpellation_reply": "interpellations",
+                      "written_question": "writtenQuestions", "written_question_reply": "writtenQuestions"}
+        for record in self.lines:
+            for url in [record["source_url"]] + record.get("identical_text_urls", []):
+                self.assertRegex(url, pattern)
+            term, coll, num, key = pattern.match(record["source_url"]).groups()
+            self.assertEqual((int(term), int(num), key), (record["term"], record["num"], record.get("reply_key")))
+            self.assertEqual(coll, collection[record["kind"]], record["id"])
+            self.assertEqual(record["kind"].endswith("_reply"), key is not None, record["id"])
+            self.assertRegex(record["date"], r"^\d{4}-\d{2}-\d{2}$")
+
+    def test_no_title_or_author_is_shipped(self):
+        self.assertFalse({"title", "author"} & {k for r in self.lines for k in r})
+
+
+if __name__ == "__main__":
+    unittest.main()

src/test_sejm_interpellations_contract.py

@@ -186,6 +186,25 @@ class SejmInterpellationsRecordsTest(unittest.TestCase):
         self.assertEqual(self.evidence["sis_terms"]["quotes"]["source_note_wording"], sis_note)
         self.assertIn(EVIDENCE.name, self.card)
 
+    def test_card_credits_sis_and_keeps_the_label_descriptive(self):
+        # v2#107: credit line, clause as information only, no licence claim, route and sidecar named
+        self.assertIn("Źródło: System Informacyjny Sejmu (Kancelaria Sejmu RP)", self.card)
+        self.assertIn("komercyjnej oferty", self.card)
+        self.assertIn("information only", self.card)
+        self.assertIn("not a licence", self.card)
+        self.assertIn("Art. 4 pkt 2 of the Polish Copyright Act", self.card)
+        self.assertIn("the API directly, no intermediary", self.card)
+        self.assertIn("sejm_interpellations.attribution.jsonl", self.card)
+        self.assertNotIn("--workers", self.card)
+
+    def test_evidence_records_the_live_capture_of_the_sis_page(self):
+        live = self.evidence["sis_terms"]["live_capture"]
+        self.assertEqual(live["retrieved"], "2026-10-19")
+        self.assertRegex(live["sha256_of_content_html"], r"^[0-9a-f]{64}$")
+        self.assertIn(live["sha256_of_content_html"], self.card)
+        self.assertTrue(live["source_note_present"])
+        self.assertTrue(live["commercial_offer_clause_present"])
+
 
 if __name__ == "__main__":
     unittest.main()