psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/check_evidence_row_integration.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""Static integration guard for the #656 shared evidence-row contract.
+
+The executable runtime owns dynamic row validation and rendering.  This guard
+owns the cross-file pointers and non-goals that could otherwise drift while the
+runtime tests remain green: one schema/state/label vocabulary, the Schema-5 and
+Phase-E producer/consumer wiring, no display-time retrieval imports, no human-read
+fields, and no accidental opt-in claim-audit adoption.
+
+Exit codes: 0 pass, 1 one or more integration errors, 2 invocation error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+SCHEMA_REL = "shared/contracts/evidence/evidence_row.schema.json"
+RUNTIME_REL = "scripts/evidence_rows.py"
+
+EXPECTED_STATES = {
+    "verified_exact_match",
+    "agent_extracted",
+    "unconfirmed_anchor",
+    "not_checked",
+    "source_missing",
+    "access_failed",
+    "retrieval_failed",
+    "anchorless",
+}
+
+EXPECTED_LABELS = {
+    "verified_exact_match": "VERIFIED EXACT MATCH",
+    "agent_extracted": "AGENT-EXTRACTED — NOT AUTHORITATIVE",
+    "unconfirmed_anchor": "UNCONFIRMED ANCHOR",
+    "not_checked": "NOT CHECKED",
+    "source_missing": "SOURCE NOT HELD",
+    "access_failed": "ACCESS FAILED",
+    "retrieval_failed": "RETRIEVAL FAILED",
+    "anchorless": "ANCHORLESS — NO EXCERPT",
+}
+
+REQUIRED_POINTERS = {
+    "shared/contracts/README.md": (
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "evidence-row/1.0",
+        "phase_e_claim_verification",
+        "--allow-legacy-absence",
+    ),
+    "shared/handoff_schemas.md": (
+        "phases.E_claims.evidence_rows[]",
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "LEGACY — EVIDENCE ROWS UNAVAILABLE",
+        "--allow-legacy-absence",
+    ),
+    "shared/references/evidence_row_protocol.md": (
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "evidence-row/1.0",
+        "phase_e_claim_verification",
+        "human-read",
+        "--allow-legacy-absence",
+    ),
+    "academic-pipeline/references/claim_verification_protocol.md": (
+        "phases.E_claims.evidence_rows[]",
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "LEGACY — EVIDENCE ROWS UNAVAILABLE",
+        "--allow-legacy-absence",
+    ),
+    "academic-pipeline/agents/integrity_verification_agent.md": (
+        "phases.E_claims.evidence_rows[]",
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "build(...)",
+        "validate(...)",
+        "human_read_log",
+        "--allow-legacy-absence",
+    ),
+    "academic-pipeline/agents/pipeline_orchestrator_agent.md": (
+        "phases.E_claims.evidence_rows[]",
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "LEGACY — EVIDENCE ROWS UNAVAILABLE",
+        "requested page",
+        "--allow-legacy-absence",
+    ),
+    "docs/design/2026-08-09-656-shared-evidence-row-contract-spec.md": (
+        SCHEMA_REL,
+        RUNTIME_REL,
+        "evidence-row/1.0",
+        "phase_e_claim_verification",
+        "claim_audit_results[]",
+        "--allow-legacy-absence",
+    ),
+}
+
+OUT_OF_SCOPE = (
+    "shared/contracts/passport/claim_audit_result.schema.json",
+    "scripts/claim_audit_pipeline.py",
+    "scripts/claim_audit_finalizer.py",
+    "scripts/check_claim_audit_consistency.py",
+    "academic-pipeline/agents/claim_ref_alignment_audit_agent.md",
+    "academic-paper/agents/formatter_agent.md",
+)
+
+FORBIDDEN_IMPORT_ROOTS = {
+    "anthropic",
+    "http",
+    "openai",
+    "os",
+    "requests",
+    "socket",
+    "subprocess",
+}
+
+# ``urllib.parse`` is the runtime's strict once-decode substrate.  Retrieval
+# siblings are forbidden even though they share that allowed top-level package.
+FORBIDDEN_IMPORT_PREFIXES = {
+    "urllib.error",
+    "urllib.request",
+    "urllib3",
+}
+
+RENDER_ROOTS = {"paginate", "render_html", "render_markdown"}
+FORBIDDEN_RENDER_CALLS = {
+    "Popen",
+    "check_call",
+    "check_output",
+    "connect",
+    "create_connection",
+    "open",
+    "read_bytes",
+    "read_text",
+    "run",
+    "system",
+    "urlopen",
+    "write_bytes",
+    "write_text",
+}
+
+FORBIDDEN_SCHEMA_FIELDS = {
+    "abstract",
+    "full_text",
+    "human_read_at",
+    "human_read_source",
+    "marked_at",
+    "read_scope",
+    "source_bytes",
+    "source_pointer",
+    "user_notes",
+}
+
+
+class DuplicateKeyError(ValueError):
+    pass
+
+
+def _pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise DuplicateKeyError(f"duplicate JSON key {key!r}")
+        result[key] = value
+    return result
+
+
+def _load_json(path: Path) -> Any:
+    return json.loads(
+        path.read_text(encoding="utf-8"),
+        object_pairs_hook=_pairs,
+        parse_constant=lambda token: (_ for _ in ()).throw(
+            ValueError(f"non-finite number {token!r}")
+        ),
+    )
+
+
+def _assignment(tree: ast.Module, name: str) -> Any:
+    for node in tree.body:
+        if isinstance(node, (ast.Assign, ast.AnnAssign)):
+            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+            if any(isinstance(target, ast.Name) and target.id == name for target in targets):
+                value = node.value
+                if value is None:
+                    break
+                if (
+                    isinstance(value, ast.Call)
+                    and isinstance(value.func, ast.Name)
+                    and value.func.id in {"frozenset", "set"}
+                    and len(value.args) == 1
+                    and not value.keywords
+                ):
+                    return set(ast.literal_eval(value.args[0]))
+                return ast.literal_eval(value)
+    raise KeyError(name)
+
+
+def _runtime_checks(path: Path) -> list[str]:
+    errors: list[str] = []
+    try:
+        text = path.read_text(encoding="utf-8")
+        tree = ast.parse(text, filename=str(path))
+    except (OSError, UnicodeError, SyntaxError) as exc:
+        return [f"{RUNTIME_REL}: cannot parse runtime: {exc}"]
+
+    for name, expected in (
+        ("SCHEMA_VERSION", "evidence-row/1.0"),
+        ("SURFACE", "phase_e_claim_verification"),
+        ("DEFAULT_PAGE_SIZE", 25),
+        ("MAX_PAGE_SIZE", 25),
+        ("LEGACY_UNAVAILABLE_LABEL", "LEGACY — EVIDENCE ROWS UNAVAILABLE"),
+    ):
+        try:
+            actual = _assignment(tree, name)
+        except (KeyError, ValueError) as exc:
+            errors.append(f"{RUNTIME_REL}: missing literal {name}: {exc}")
+        else:
+            if actual != expected:
+                errors.append(f"{RUNTIME_REL}: {name}={actual!r}, expected {expected!r}")
+
+    if "--allow-legacy-absence" not in text:
+        errors.append(
+            f"{RUNTIME_REL}: missing explicit --allow-legacy-absence compatibility gate"
+        )
+
+    try:
+        states = set(_assignment(tree, "EXCERPT_STATES"))
+    except (KeyError, ValueError) as exc:
+        errors.append(f"{RUNTIME_REL}: cannot read EXCERPT_STATES: {exc}")
+    else:
+        if states != EXPECTED_STATES:
+            errors.append(
+                f"{RUNTIME_REL}: excerpt-state vocabulary drift: "
+                f"missing={sorted(EXPECTED_STATES - states)}, extra={sorted(states - EXPECTED_STATES)}"
+            )
+
+    try:
+        labels = _assignment(tree, "STATE_LABELS")
+    except (KeyError, ValueError) as exc:
+        errors.append(f"{RUNTIME_REL}: cannot read STATE_LABELS: {exc}")
+    else:
+        if labels != EXPECTED_LABELS:
+            errors.append(f"{RUNTIME_REL}: canonical rendering vocabulary drift")
+
+    for node in ast.walk(tree):
+        imported: list[str] = []
+        if isinstance(node, ast.Import):
+            imported = [alias.name for alias in node.names]
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imported = [node.module]
+        for module in imported:
+            if (
+                module.split(".", 1)[0] in FORBIDDEN_IMPORT_ROOTS
+                or any(
+                    module == prefix or module.startswith(prefix + ".")
+                    for prefix in FORBIDDEN_IMPORT_PREFIXES
+                )
+            ):
+                errors.append(f"{RUNTIME_REL}:{node.lineno}: forbidden retrieval/model/system import {module!r}")
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
+            if node.func.attr == "add_argument" and node.args:
+                try:
+                    option = ast.literal_eval(node.args[0])
+                except (ValueError, TypeError):
+                    option = None
+                if option == "--all":
+                    errors.append(f"{RUNTIME_REL}:{node.lineno}: resource-unbounded --all option is forbidden")
+
+    functions = {
+        node.name: node
+        for node in tree.body
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    }
+    pending = [name for name in sorted(RENDER_ROOTS) if name in functions]
+    reachable: set[str] = set()
+    while pending:
+        name = pending.pop()
+        if name in reachable:
+            continue
+        reachable.add(name)
+        for node in ast.walk(functions[name]):
+            if not isinstance(node, ast.Call):
+                continue
+            called_name: str | None
+            if isinstance(node.func, ast.Name):
+                called_name = node.func.id
+            elif isinstance(node.func, ast.Attribute):
+                called_name = node.func.attr
+            else:
+                called_name = None
+            if called_name in functions and called_name not in reachable:
+                pending.append(called_name)
+            if called_name in FORBIDDEN_RENDER_CALLS:
+                errors.append(
+                    f"{RUNTIME_REL}:{node.lineno}: renderer-reachable ambient I/O/process call "
+                    f"{called_name!r} is forbidden"
+                )
+    return errors
+
+
+def run_checks(root: Path = REPO_ROOT) -> list[str]:
+    errors: list[str] = []
+    schema_path = root / SCHEMA_REL
+    runtime_path = root / RUNTIME_REL
+    try:
+        schema = _load_json(schema_path)
+    except (OSError, UnicodeError, json.JSONDecodeError, ValueError) as exc:
+        errors.append(f"{SCHEMA_REL}: cannot load strict JSON: {exc}")
+        schema = None
+
+    if isinstance(schema, dict):
+        if schema.get("additionalProperties") is not False:
+            errors.append(f"{SCHEMA_REL}: root must remain closed")
+        properties = schema.get("properties", {})
+        if properties.get("schema_version", {}).get("const") != "evidence-row/1.0":
+            errors.append(f"{SCHEMA_REL}: schema_version const drift")
+        if properties.get("surface", {}).get("const") != "phase_e_claim_verification":
+            errors.append(f"{SCHEMA_REL}: V1 surface const drift")
+        states = set(
+            properties.get("excerpt", {}).get("properties", {}).get("state", {}).get("enum", [])
+        )
+        if states != EXPECTED_STATES:
+            errors.append(
+                f"{SCHEMA_REL}: excerpt-state vocabulary drift: "
+                f"missing={sorted(EXPECTED_STATES - states)}, extra={sorted(states - EXPECTED_STATES)}"
+            )
+        source_fields = set(properties.get("source", {}).get("properties", {}))
+        forbidden = source_fields & FORBIDDEN_SCHEMA_FIELDS
+        if forbidden:
+            errors.append(f"{SCHEMA_REL}: forbidden source/private/read fields: {sorted(forbidden)}")
+        schema_text = json.dumps(schema, ensure_ascii=False, sort_keys=True)
+        leaked = sorted(field for field in FORBIDDEN_SCHEMA_FIELDS if f'"{field}"' in schema_text)
+        if leaked:
+            errors.append(f"{SCHEMA_REL}: forbidden persisted fields anywhere in schema: {leaked}")
+
+    errors.extend(_runtime_checks(runtime_path))
+
+    for rel, required in REQUIRED_POINTERS.items():
+        path = root / rel
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError) as exc:
+            errors.append(f"{rel}: cannot read: {exc}")
+            continue
+        for token in required:
+            if token not in text:
+                errors.append(f"{rel}: missing #656 pointer/contract token {token!r}")
+
+    adoption_tokens = (SCHEMA_REL, RUNTIME_REL, "evidence-row/1.0")
+    for rel in OUT_OF_SCOPE:
+        path = root / rel
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError) as exc:
+            errors.append(f"{rel}: cannot read out-of-scope boundary file: {exc}")
+            continue
+        found = [token for token in adoption_tokens if token in text]
+        if found:
+            errors.append(
+                f"{rel}: opt-in claim-audit/formatter V1 boundary crossed by {found!r}"
+            )
+    return errors
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=REPO_ROOT)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    try:
+        args = _parser().parse_args(argv)
+        errors = run_checks(args.root.resolve())
+    except (OSError, ValueError) as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 2
+    if errors:
+        for error in errors:
+            print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+    print("PASS: #656 shared evidence-row integration")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/ars/scripts/check_experiment_provenance.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Validate a Material Passport YAML's `experiment_provenance[]` entry SHAPE (#260).
+
+Usage: python scripts/check_experiment_provenance.py path/to/passport.yaml
+
+Standalone shape-only validator, mirroring scripts/check_repro_lock.py. It
+validates each experiment_provenance[] entry against
+shared/contracts/passport/experiment_provenance_entry.schema.json — which
+encodes the D6 well-formedness rules including the absent-key rule
+(negative_results / known_limitations MUST be present, value MAY be []; an
+absent key is malformed).
+
+This script does NOT run the cross-array EP/EA invariants (EP-INV-1..4,
+EA-INV-1..2 — experiment_id uniqueness, planned_experiment_ids resolution,
+declaration symmetry, alignment reference resolution). Those span multiple
+aggregates and live in scripts/check_claim_audit_consistency.py. The two
+scripts deliberately do not duplicate invariant logic.
+
+- Missing `experiment_provenance` key: OK, exit 0 (optional aggregate; a
+  passport may legitimately carry none). The cross-array consistency lint owns
+  the declaration<->provenance symmetry check (EP-INV-4), not this shape gate.
+- `experiment_provenance: null` or `[]`: OK, exit 0 (nothing to shape-check).
+- Any entry failing the schema: ERROR, exit 1.
+
+Exit codes:
+    0   no shape violations
+    1   one or more entries fail the entry schema
+    2   internal error (file not found / malformed YAML / schema missing)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import yaml
+from jsonschema import Draft202012Validator
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+ENTRY_SCHEMA = (
+    REPO_ROOT / "shared/contracts/passport/experiment_provenance_entry.schema.json"
+)
+
+
+def _validator() -> Draft202012Validator:
+    schema = json.loads(ENTRY_SCHEMA.read_text(encoding="utf-8"))
+    Draft202012Validator.check_schema(schema)
+    return Draft202012Validator(
+        schema, format_checker=Draft202012Validator.FORMAT_CHECKER
+    )
+
+
+def validate_provenance(entries: object) -> list[str]:
+    """Validate each experiment_provenance[] entry against the entry schema.
+
+    Returns a list of human-readable error strings (empty == clean).
+    """
+    errors: list[str] = []
+    if entries is None:
+        return errors  # explicit null opt-out — nothing to shape-check
+    if not isinstance(entries, list):
+        return [
+            f"experiment_provenance must be a list (or absent/null); got {type(entries).__name__}"
+        ]
+
+    validator = _validator()
+    for i, entry in enumerate(entries):
+        if not isinstance(entry, dict):
+            errors.append(f"experiment_provenance[{i}]: entry must be a mapping; got {type(entry).__name__}")
+            continue
+        for err in sorted(validator.iter_errors(entry), key=lambda e: list(e.absolute_path)):
+            loc = ".".join(str(p) for p in err.absolute_path) or "<root>"
+            errors.append(f"experiment_provenance[{i}] {loc}: {err.message}")
+
+    return errors
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("passport", type=Path)
+    args = parser.parse_args(argv)
+
+    try:
+        doc = yaml.safe_load(args.passport.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        print(f"ERROR: passport not found: {args.passport}", file=sys.stderr)
+        return 2
+    except Exception as exc:
+        print(f"ERROR: failed to load {args.passport}: {exc}", file=sys.stderr)
+        return 2
+
+    if not isinstance(doc, dict):
+        print(f"ERROR: {args.passport}: top-level must be a mapping", file=sys.stderr)
+        return 2
+
+    if "experiment_provenance" not in doc:
+        print("OK: no experiment_provenance[] aggregate (optional).")
+        return 0
+
+    errors = validate_provenance(doc["experiment_provenance"])
+    if errors:
+        for e in errors:
+            print(f"ERROR: {e}")
+        print(
+            f"\n{len(errors)} shape violation(s). See "
+            f"shared/contracts/passport/experiment_provenance_entry.schema.json.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print("OK: experiment_provenance[] entries are well-formed.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/ars/scripts/check_field_norm_severity.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Integrity + provenance validator for the #215 field-norm severity gold set.
+
+This gold set is a first-party REGRESSION FIXTURE, not a detector calibration set.
+There is no deterministic predictor for "field-norm severity miscalibration" — it
+requires domain judgment — so this validator deliberately does NOT compute FNR/FPR
+or pretend to be a detector (that would be fluent-wrongness: a calibration ritual
+with no predictor behind it). Instead it enforces that every case is structurally
+complete and carries stable first-party provenance back to the source paper, so the
+fixture stays traceable and cannot silently drift into fabricated cases.
+
+Usage:
+    python -m scripts.check_field_norm_severity [gold_set.json]
+
+Exit 0 = clean, 1 = violations (printed one per line to stderr).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_GOLD_SET = REPO_ROOT / "evals/gold/field_norm_severity/gold_set.json"
+
+VALID_SUBTYPES = {"field_norm_boundary", "significance_boundary"}
+REQUIRED_PROVENANCE_KEYS = ("section", "paper_citation", "verbatim_anchor")
+# An id ending in this suffix declares itself a contextual exception case (the SAR
+# 11.7T case the paper marks ambiguous). The flag must then actually be set — otherwise
+# the case silently reverts to a clean positive, the exact fidelity error this guards.
+EXCEPTION_ID_SUFFIX = "-exception"
+# The fixture must self-identify as a regression fixture (codex review P2): with n=10
+# and no deterministic predictor, it must not claim distributional calibration.
+REQUIRED_TASK_TYPE = "regression-fixture"
+
+
+def validate(data: dict[str, Any]) -> list[str]:
+    """Return a list of violation messages. Empty list = clean."""
+    errors: list[str] = []
+
+    metadata = data.get("metadata")
+    if not isinstance(metadata, dict):
+        errors.append("metadata: missing or not an object")
+        metadata = {}
+    task_type = metadata.get("task_type")
+    if task_type != REQUIRED_TASK_TYPE:
+        errors.append(
+            f"metadata.task_type={task_type!r} must be {REQUIRED_TASK_TYPE!r} "
+            f"(this is a regression fixture, not a calibrated threshold set)"
+        )
+
+    items = data.get("items")
+    if not isinstance(items, list) or not items:
+        errors.append("items: missing or empty list")
+        return errors
+
+    seen_ids: set[str] = set()
+    for idx, item in enumerate(items):
+        item_id = item.get("id")
+        where = item_id if isinstance(item_id, str) and item_id.strip() else f"<index {idx}>"
+
+        if not isinstance(item_id, str) or not item_id.strip():
+            errors.append(f"{where}: missing non-empty id")
+        elif item_id in seen_ids:
+            errors.append(f"{where}: duplicate id {item_id!r}")
+        else:
+            seen_ids.add(item_id)
+
+        if item.get("severity_miscalibration") is not True:
+            errors.append(
+                f"{where}: severity_miscalibration must be true "
+                f"(every gold case is a documented miscalibration)"
+            )
+
+        subtype = item.get("subtype")
+        if subtype not in VALID_SUBTYPES:
+            errors.append(
+                f"{where}: subtype={subtype!r} not in {sorted(VALID_SUBTYPES)}"
+            )
+
+        field_norm = item.get("field_norm")
+        if not isinstance(field_norm, str) or not field_norm.strip():
+            errors.append(f"{where}: missing non-empty field_norm")
+
+        prov = item.get("provenance")
+        if not isinstance(prov, dict):
+            errors.append(f"{where}: missing provenance object")
+        else:
+            for key in REQUIRED_PROVENANCE_KEYS:
+                val = prov.get(key)
+                if not isinstance(val, str) or not val.strip():
+                    errors.append(
+                        f"{where}: provenance.{key} missing or empty "
+                        f"(first-party provenance is required; no untraceable cases)"
+                    )
+
+        # exception flag <-> exception_reason must be paired both ways: a contextual
+        # case (SAR) must explain why it is non-clean; a clean case must not carry a
+        # stray reason that implies it is contextual.
+        is_exception = item.get("exception") is True
+        has_reason = bool(str(item.get("exception_reason", "")).strip())
+        if is_exception and not has_reason:
+            errors.append(
+                f"{where}: exception=true but exception_reason missing/empty"
+            )
+        if not is_exception and has_reason:
+            errors.append(
+                f"{where}: exception_reason present but exception is not true"
+            )
+
+        # An id that declares itself an exception case MUST carry exception=true. Without
+        # this an exception item that loses BOTH its flag and reason passes the paired
+        # check above (both branches false) and silently reverts to a clean positive —
+        # the SAR fidelity error this fixture exists to prevent.
+        if isinstance(item_id, str) and item_id.endswith(EXCEPTION_ID_SUFFIX) and not is_exception:
+            errors.append(
+                f"{where}: id ends in {EXCEPTION_ID_SUFFIX!r} but exception is not true "
+                f"(a declared exception case must stay marked contextual)"
+            )
+
+    return errors
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("gold_set", nargs="?", type=Path, default=DEFAULT_GOLD_SET)
+    args = parser.parse_args(argv)
+
+    data = json.loads(args.gold_set.read_text(encoding="utf-8"))
+    errors = validate(data)
+    if errors:
+        for error in errors:
+            print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+    n = len(data.get("items", []))
+    print(f"field_norm_severity: {n} cases, all integrity/provenance invariants pass")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())