fix(ontology): version Sejm build protocol

Align PR #18 with the Slayer Research Ontology v0.1 without changing the
published speech records.

The update versions the filtering protocol by content digest and immutable
commit URI. A follow-up metadata commit adds the complete Object, Version,
Relation, Protocol, Run, Evidence, Claim and Actor graph, plus contract tests
for references, acyclicity, immutable payload URIs and artifact checksums.

The data Parquet and attribution sidecar are reproduced from the pinned source
and must retain their previously published SHA-256 digests.

src/fetch_sejm_api_2011_2022.py

@@ -7,10 +7,13 @@ import argparse
 import collections
 import datetime as dt
 import hashlib
+import importlib.metadata
 import json
 import pathlib
+import platform
 import re
 import shutil
+import sys
 from typing import Any
 
 
@@ -90,7 +93,14 @@ def registry_entry() -> str:
 
 def update_registry(registry: str) -> str:
     if re.search(rf'^\s{{4}}["\']{SOURCE_NAME}["\']\s*:', registry, re.MULTILINE):
-        raise BuildError(f"{SOURCE_NAME} already exists in the target registry")
+        required = (
+            '"file_key": "sejm_api_2011_2022"',
+            '"license_spdx": "LicenseRef-Polish-Official-Documents"',
+            '"upstream": "https://api.sejm.gov.pl/"',
+        )
+        if not all(value in registry for value in required):
+            raise BuildError(f"existing {SOURCE_NAME} registry entry differs from the contract")
+        return registry
     marker = '    "sejm_api": {'
     if registry.count(marker) != 1:
         raise BuildError("cannot locate the accepted sejm_api registry entry")
@@ -193,14 +203,25 @@ third-party rights and provider-specific limitations.
 def contract_test() -> str:
     return f'''"""Contract checks for the {SOURCE_NAME} contribution."""
 
+import hashlib
 import json
 import pathlib
+import re
 
 import pyarrow.parquet as pq
 
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 DATA = ROOT / "data" / "{SOURCE_NAME}"
+MANIFEST = ROOT / "artifacts" / "{SOURCE_NAME}_ontology_manifest.json"
+
+
+def sha256_file(path):
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
 
 
 def test_artifacts_and_schema():
@@ -223,14 +244,114 @@ def test_attribution_count_and_legal_evidence():
     legal = json.loads((DATA / "{SOURCE_NAME}.license-evidence.json").read_text(encoding="utf-8"))
     assert legal["status"] == "reviewed-open-official-materials"
     assert legal["pinned_source"].endswith(stats["source_revision"])
+
+
+def test_ontology_kernel_and_references():
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    required = {{
+        "object", "version", "protocol", "run", "relations", "evidence",
+        "claims", "claim_evidence", "actors", "attestations",
+    }}
+    assert required <= set(manifest)
+    assert manifest["ontology_version"] == "slayer.ai/research-ontology/v0.1"
+
+    actor_ids = {{item["id"] for item in manifest["actors"]}}
+    assert manifest["run"]["actor_id"] in actor_ids
+    assert manifest["version"]["object_id"] == manifest["object"]["id"]
+    assert manifest["version"]["created_by"] in actor_ids
+    assert re.fullmatch(r"sha256:[0-9a-f]{{64}}", manifest["version"]["digest"])
+    assert re.search(r"@[0-9a-f]{{40}}/", manifest["version"]["payload_uri"])
+
+    protocol = manifest["protocol"]
+    protocol_version = protocol["version"]
+    assert protocol_version["object_id"] == protocol["id"]
+    assert manifest["run"]["protocol_version_id"] == protocol_version["id"]
+    assert re.fullmatch(r"sha256:[0-9a-f]{{64}}", protocol_version["digest"])
+    assert re.search(r"@[0-9a-f]{{40}}/", protocol_version["payload_uri"])
+    script = ROOT / protocol["specification"]["source_path"]
+    assert sha256_file(script) == protocol_version["code_sha256"]
+
+    run = manifest["run"]
+    assert run["started_at"] <= run["finished_at"]
+    assert run["git_commit"] in protocol_version["payload_uri"]
+    assert {{"python", "platform", "machine", "packages", "determinism"}} <= set(run["environment"])
+
+    evidence_ids = {{item["id"] for item in manifest["evidence"]}}
+    assert len(evidence_ids) == len(manifest["evidence"])
+    for item in manifest["evidence"]:
+        assert item["run_id"] == run["id"]
+        assert item["subject_version"] == manifest["version"]["id"]
+        assert re.search(r"@sha256:[0-9a-f]{{64}}$", item["id"])
+
+    claim_ids = {{item["id"] for item in manifest["claims"]}}
+    assert len(claim_ids) == len(manifest["claims"])
+    for item in manifest["claims"]:
+        assert item["scope"] == manifest["version"]["id"]
+        assert item["asserted_by"] in actor_ids
+        assert item["supported_by"]
+        assert set(item["supported_by"]) <= evidence_ids
+        assert item["falsification_condition"]
+
+    for link in manifest["claim_evidence"]:
+        assert link["claim_id"] in claim_ids
+        assert link["evidence_id"] in evidence_ids
+        assert link["relation"] in {{"SUPPORTS", "REFUTES", "QUALIFIES"}}
+
+    edges = {{}}
+    for relation in manifest["relations"]:
+        source = relation["source_version_id"]
+        target = relation["target_version_id"]
+        assert source != target
+        assert relation["introduced_by_run"] == run["id"]
+        if target.startswith("slayer://version/"):
+            edges.setdefault(source, set()).add(target)
+
+    visiting, visited = set(), set()
+    def visit(node):
+        assert node not in visiting, "version lineage must be acyclic"
+        if node in visited:
+            return
+        visiting.add(node)
+        for target in edges.get(node, ()):
+            visit(target)
+        visiting.remove(node)
+        visited.add(node)
+    for node in edges:
+        visit(node)
+
+    for attestation in manifest["attestations"]:
+        assert attestation["actor_id"] in actor_ids
+        assert attestation["subject_version"] == manifest["version"]["id"]
+        assert attestation["supported_by"]
+        assert set(attestation["supported_by"]) <= evidence_ids
+
+
+def test_manifest_artifact_checksums():
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    checksums = next(
+        item["payload"] for item in manifest["evidence"]
+        if item["observation_type"] == "artifact_checksums"
+    )
+    paths = {{
+        "parquet_sha256": DATA / "{SOURCE_NAME}.parquet",
+        "attribution_sha256": DATA / "{SOURCE_NAME}.attribution.jsonl",
+        "stats_sha256": DATA / "{SOURCE_NAME}.stats.json",
+        "legal_evidence_sha256": DATA / "{SOURCE_NAME}.license-evidence.json",
+    }}
+    assert {{name: sha256_file(path) for name, path in paths.items()}} == checksums
 '''
 
 
 def build(args: argparse.Namespace) -> dict[str, Any]:
+    run_started_at = dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z")
     if not COMMIT_PATTERN.fullmatch(args.source_revision):
         raise BuildError("source revision must be a 40-character commit")
     if not COMMIT_PATTERN.fullmatch(args.target_revision):
         raise BuildError("target revision must be a 40-character commit")
+    if not COMMIT_PATTERN.fullmatch(args.dataset_payload_commit):
+        raise BuildError("dataset payload commit must be a 40-character commit")
+    if not COMMIT_PATTERN.fullmatch(args.protocol_payload_commit):
+        raise BuildError("protocol payload commit must be a 40-character commit")
     if not args.target_registry.is_file():
         raise BuildError("target sources.py is missing")
 
@@ -358,33 +479,250 @@ def build(args: argparse.Namespace) -> dict[str, Any]:
         "stats_sha256": sha256_file(stats_path),
         "legal_evidence_sha256": sha256_file(legal_path),
     }
+    expected_digests = {
+        "parquet_sha256": args.expected_parquet_sha256,
+        "attribution_sha256": args.expected_attribution_sha256,
+    }
+    supplied_expected = {key: value for key, value in expected_digests.items() if value}
+    mismatches = {
+        key: {"expected": expected, "actual": artifact_digests[key]}
+        for key, expected in supplied_expected.items()
+        if artifact_digests[key] != expected
+    }
+    if mismatches:
+        raise BuildError(f"reproduction digest mismatch: {mismatches}")
+
     version_digest = canonical_sha256({
         "source_revision": args.source_revision, "target_revision": args.target_revision,
         "range": [START_DATE, END_DATE], "artifacts": artifact_digests,
     })
+    object_id = f"slayer://object/dataset-source/{SOURCE_NAME}"
     version_id = f"slayer://version/dataset-source/{SOURCE_NAME}@sha256:{version_digest}"
+    protocol_object_id = f"slayer://object/protocol/{SOURCE_NAME}-filter"
+    protocol_configuration = {
+        "date_range": [START_DATE, END_DATE],
+        "deduplication": {"algorithm": "sha1", "field": "text", "scope": "within_source"},
+        "id_generation": {"algorithm": "sha256", "fields": ["date", "term", "speaker", "text"]},
+        "minimum_text_characters": 200,
+        "parquet": {"compression": "zstd", "write_batch_size": 1024},
+        "source_splits": ["train", "validation"],
+        "speaker_required": True,
+        "tokenizer": "cl100k_base",
+    }
+    protocol_specification = {
+        "entrypoint": "python src/fetch_sejm_api_2011_2022.py",
+        "source_path": "src/fetch_sejm_api_2011_2022.py",
+        "summary": "Deterministic date filtering, exact-text deduplication, attribution preservation and DynaWord projection.",
+        "configuration": protocol_configuration,
+        "required_inputs": ["pinned source Parquet splits", "pinned target sources.py"],
+        "outputs": ["DynaWord Parquet", "attribution sidecar", "stats", "legal evidence", "ontology manifest"],
+    }
+    protocol_code_digest = sha256_file(pathlib.Path(__file__).resolve())
+    protocol_digest = canonical_sha256({
+        "object_id": protocol_object_id,
+        "code_sha256": protocol_code_digest,
+        "specification": protocol_specification,
+    })
+    protocol_version_id = f"slayer://version/protocol/{SOURCE_NAME}-filter@sha256:{protocol_digest}"
+    source_version_id = f"hf://datasets/{SOURCE_REPOSITORY}@{args.source_revision}"
+    target_version_id = f"hf://datasets/{TARGET_REPOSITORY}@{args.target_revision}"
+    run_finished_at = dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z")
+    environment = {
+        "python": sys.version,
+        "python_executable": sys.executable,
+        "platform": platform.platform(),
+        "machine": platform.machine(),
+        "packages": {
+            "pyarrow": pa.__version__,
+            "tiktoken": importlib.metadata.version("tiktoken"),
+        },
+        "container_image": None,
+        "environment_limitation": "No container image was used; material runtime and package versions are recorded.",
+        "determinism": {"sampling": "none", "seed": None, "input_order": ["train", "validation"]},
+    }
+
+    def evidence(observation_type: str, payload: Any) -> dict[str, Any]:
+        evidence_digest = canonical_sha256({
+            "run_id": args.run_id,
+            "subject_version": version_id,
+            "observation_type": observation_type,
+            "payload": payload,
+        })
+        return {
+            "id": f"slayer://evidence/{SOURCE_NAME}/{observation_type}@sha256:{evidence_digest}",
+            "run_id": args.run_id,
+            "subject_version": version_id,
+            "observation_type": observation_type,
+            "payload": payload,
+            "observed_at": run_finished_at,
+        }
+
+    evidence_items = [
+        evidence("dataset_record_counts", stats),
+        evidence("speaker_attribution_coverage", {
+            "records": counter["kept"], "non_empty_authors": counter["authors_with_value"],
+            "coverage": counter["authors_with_value"] / counter["kept"],
+        }),
+        evidence("known_temporal_overlap", {
+            "parliamentary_registered_range": "1991-2019",
+            "parlamint_pl_registered_range": "2015-2022",
+            "novelty_claimed": False,
+        }),
+        evidence("artifact_checksums", artifact_digests),
+        evidence("legal_provenance_review", {
+            "status": "reviewed-open-official-materials",
+            "artifact": f"data/{SOURCE_NAME}/{SOURCE_NAME}.license-evidence.json",
+            "sha256": artifact_digests["legal_evidence_sha256"],
+            "limitations_retained": True,
+        }),
+        evidence("schema_validation", {
+            "schema": list(EXPECTED_FIELDS), "records": counter["kept"], "valid": True,
+        }),
+        evidence("pinned_input_reproduction", {
+            "expected": supplied_expected,
+            "actual": {key: artifact_digests[key] for key in supplied_expected},
+            "matches": bool(supplied_expected) and not mismatches,
+        }),
+    ]
+    evidence_by_type = {item["observation_type"]: item["id"] for item in evidence_items}
+
+    def claim(statement: str, falsification_condition: str, supported_by: list[str]) -> dict[str, Any]:
+        claim_digest = canonical_sha256({
+            "scope": version_id,
+            "statement": statement,
+            "falsification_condition": falsification_condition,
+        })
+        return {
+            "id": f"slayer://claim/{SOURCE_NAME}@sha256:{claim_digest}",
+            "scope": version_id,
+            "statement": statement,
+            "asserted_by": args.actor,
+            "supported_by": supported_by,
+            "falsification_condition": falsification_condition,
+        }
+
+    claims = [
+        claim(
+            "All retained records from the pinned source dated 2011-2022 are included after exact within-source deduplication.",
+            "A qualifying pinned-source record is absent without a recorded drop reason.",
+            [evidence_by_type["dataset_record_counts"]],
+        ),
+        claim(
+            "Every contributed document has non-empty speaker attribution.",
+            "Any contributed author field is empty.",
+            [evidence_by_type["speaker_attribution_coverage"]],
+        ),
+        claim(
+            "The contribution does not establish temporal novelty relative to every target source because registered ranges overlap.",
+            "The cited target-source ranges do not overlap 2011-2022.",
+            [evidence_by_type["known_temporal_overlap"]],
+        ),
+        claim(
+            "The contributed records are official Sejm materials documented for statutory reuse, subject to retained privacy and third-party limitations.",
+            "The records are not official materials or the cited legal basis and provider conditions contradict the documented reuse status.",
+            [evidence_by_type["legal_provenance_review"]],
+        ),
+        claim(
+            "The generated artifact set conforms to the DynaWord source schema and recorded checksums.",
+            "A contract field is missing, a row violates the schema, or a recorded artifact checksum differs.",
+            [evidence_by_type["schema_validation"], evidence_by_type["artifact_checksums"]],
+        ),
+    ]
+    if supplied_expected:
+        claims.append(claim(
+            "Rebuilding from pinned inputs reproduced the expected Parquet and attribution-sidecar digests.",
+            "A rebuilt Parquet or attribution-sidecar digest differs from the expected digest.",
+            [evidence_by_type["pinned_input_reproduction"]],
+        ))
+
+    claim_evidence = [
+        {
+            "claim_id": item["id"], "evidence_id": evidence_id,
+            "relation": "SUPPORTS", "introduced_by_run": args.run_id,
+        }
+        for item in claims for evidence_id in item["supported_by"]
+    ]
+
+    def attestation(attestation_type: str, value: Any, supported_by: list[str]) -> dict[str, Any]:
+        attestation_digest = canonical_sha256({
+            "type": attestation_type, "value": value, "actor_id": args.actor,
+            "subject_version": version_id, "supported_by": supported_by,
+        })
+        return {
+            "id": f"slayer://attestation/{SOURCE_NAME}/{attestation_type}@sha256:{attestation_digest}",
+            "type": attestation_type,
+            "value": value,
+            "actor_id": args.actor,
+            "subject_version": version_id,
+            "supported_by": supported_by,
+            "created_at": run_finished_at,
+        }
+
     manifest = {
         "schema_version": "slayer.ai/dataset-source-contribution/v1",
-        "object": {"id": f"slayer://object/dataset-source/{SOURCE_NAME}", "kind": "dataset_source", "name": SOURCE_NAME},
-        "version": {"id": version_id, "digest": f"sha256:{version_digest}"},
-        "protocol": {"entrypoint": "python src/fetch_sejm_api_2011_2022.py", "configuration": {"start_date": START_DATE, "end_date": END_DATE, "tokenizer": "cl100k_base"}},
-        "run": {"id": args.run_id, "actor_id": args.actor, "inputs": [
-            {"role": "source", "version_id": f"hf://datasets/{SOURCE_REPOSITORY}@{args.source_revision}"},
-            {"role": "target_base", "version_id": f"hf://datasets/{TARGET_REPOSITORY}@{args.target_revision}"},
-        ], "outputs": [{"role": "dataset_source", "version_id": version_id}]},
-        "evidence": [
-            {"observation_type": "dataset_record_counts", "payload": stats},
-            {"observation_type": "known_temporal_overlap", "payload": {"parliamentary": "1991-2019", "parlamint_pl_registered": "2015-2022", "novelty_claimed": False}},
-            {"observation_type": "artifact_checksums", "payload": artifact_digests},
-        ],
-        "claims": [
-            {"statement": "All retained records from the pinned source dated 2011-2022 are included after exact within-source deduplication.", "falsification_condition": "A qualifying pinned-source record is absent without a recorded drop reason."},
-            {"statement": "Every contributed document has non-empty speaker attribution.", "falsification_condition": "Any contributed author field is empty."},
+        "ontology_version": "slayer.ai/research-ontology/v0.1",
+        "object": {
+            "id": object_id, "kind": "dataset_source", "name": SOURCE_NAME,
+            "metadata": {"language": "pl", "domain": "political/spoken", "provider": "Kancelaria Sejmu RP"},
+        },
+        "version": {
+            "id": version_id,
+            "object_id": object_id,
+            "digest": f"sha256:{version_digest}",
+            "schema_version": "slayer.ai/dataset-source/v1",
+            "payload_uri": f"hf://datasets/{TARGET_REPOSITORY}@{args.dataset_payload_commit}/data/{SOURCE_NAME}/{SOURCE_NAME}.parquet",
+            "created_at": args.version_created_at,
+            "created_by": args.actor,
+        },
+        "protocol": {
+            "id": protocol_object_id,
+            "kind": "dataset_filtering",
+            "name": f"{SOURCE_NAME}-filter",
+            "version": {
+                "id": protocol_version_id,
+                "object_id": protocol_object_id,
+                "digest": f"sha256:{protocol_digest}",
+                "code_sha256": protocol_code_digest,
+                "schema_version": "slayer.ai/protocol/v1",
+                "payload_uri": f"hf://datasets/{TARGET_REPOSITORY}@{args.protocol_payload_commit}/src/fetch_sejm_api_2011_2022.py",
+                "created_at": run_finished_at,
+                "created_by": args.actor,
+            },
+            "specification": protocol_specification,
+        },
+        "run": {
+            "id": args.run_id,
+            "protocol_version_id": protocol_version_id,
+            "actor_id": args.actor,
+            "git_commit": args.protocol_payload_commit,
+            "started_at": run_started_at,
+            "finished_at": run_finished_at,
+            "config": protocol_configuration,
+            "environment": environment,
+            "inputs": [
+                {"role": "source", "version_id": source_version_id},
+                {"role": "target_base", "version_id": target_version_id},
+            ],
+            "outputs": [{"role": "dataset_source", "version_id": version_id}],
+        },
+        "relations": [
+            {"source_version_id": version_id, "predicate": "DERIVED_FROM", "target_version_id": source_version_id, "introduced_by_run": args.run_id},
+            {"source_version_id": version_id, "predicate": "COMPATIBLE_WITH", "target_version_id": target_version_id, "introduced_by_run": args.run_id},
+            {"source_version_id": version_id, "predicate": "FILTERED_BY", "target_version_id": protocol_version_id, "introduced_by_run": args.run_id},
         ],
+        "evidence": evidence_items,
+        "claims": claims,
+        "claim_evidence": claim_evidence,
+        "actors": [{
+            "id": args.actor, "kind": "human", "identity": "Piotr Sty\u0142a",
+            "identifiers": {"hugging_face": "PiotrSty", "github": "PiotrStyla"},
+        }],
         "attestations": [
-            {"type": "schema_valid", "value": True, "fields": list(EXPECTED_FIELDS)},
-            {"type": "temporal_overlap", "value": "known_and_disclosed"},
-            {"type": "speaker_attribution", "value": "100_percent"},
+            attestation("schema_valid", True, [evidence_by_type["schema_validation"], evidence_by_type["artifact_checksums"]]),
+            attestation("temporal_overlap", "known_and_disclosed", [evidence_by_type["known_temporal_overlap"]]),
+            attestation("speaker_attribution", "100_percent", [evidence_by_type["speaker_attribution_coverage"]]),
+            attestation("legal_status", "documented_open_official_materials_with_limitations", [evidence_by_type["legal_provenance_review"]]),
+            attestation("pinned_input_reproduction", bool(supplied_expected), [evidence_by_type["pinned_input_reproduction"]]),
         ],
     }
     write_json(artifact_dir / f"{SOURCE_NAME}_ontology_manifest.json", manifest)
@@ -403,6 +741,11 @@ def main() -> int:
     parser.add_argument("--output", type=pathlib.Path, required=True)
     parser.add_argument("--source-revision", required=True)
     parser.add_argument("--target-revision", required=True)
+    parser.add_argument("--dataset-payload-commit", required=True)
+    parser.add_argument("--protocol-payload-commit", required=True)
+    parser.add_argument("--version-created-at", default="2026-08-31T09:59:00Z")
+    parser.add_argument("--expected-parquet-sha256")
+    parser.add_argument("--expected-attribution-sha256")
     parser.add_argument("--added-date", default=dt.datetime.now(dt.timezone.utc).date().isoformat())
     parser.add_argument("--actor", default="hf:PiotrSty")
     parser.add_argument("--run-id", default=f"sejm-api-2011-2022-{dt.datetime.now(dt.timezone.utc).strftime('%Y%m%dT%H%M%SZ')}")