psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/uncited_assertion_detector.py

@@ -0,0 +1,254 @@
+"""D4-c uncited-assertion token-rule detector.
+
+Implements the three-condition rule pinned in
+`academic-pipeline/agents/claim_ref_alignment_audit_agent.md`
+§"Uncited-assertion detector (D4-c)" and exercised by
+`scripts/test_uncited_assertion.py` (T-U1..T-U5).
+
+A sentence becomes an `uncited_assertion` candidate iff ALL THREE hold:
+
+  1. Quantifier-or-empirical-verb present
+     (numbers `42 participants`, percentages `50%`, explicit quantifiers
+     `most`/`several`/`two-thirds`, empirical verbs `showed`/`demonstrated`/
+     `observed`/`proved`/`confirmed`). Bare-number matches are filtered by
+     a guard pass that rejects years, version triples, and section numbers.
+  2. No `<!--ref:slug-->` marker on the sentence.
+  3. Not a definitional sentence (`refers to`/`is defined as`/`we define`/
+     `for the purposes of`).
+
+D4-c last paragraph: manifest membership does NOT exempt a sentence.
+The wrapper `detect_uncited_assertions` preserves caller-supplied
+`manifest_claim_id` / `scoped_manifest_id` on every finding so the
+downstream pipeline can populate U-INV-4 cross-array integrity.
+
+Cross-sentence / adjacent-clause check (Step 9 closure): the wrapper
+`detect_uncited_assertions` accepts an optional `adjacent_text` field
+on each sentence dict. When supplied, that surrounding-clause window
+is scanned for a `<!--ref:slug-->` marker via the same condition-2
+regex; if found, the candidate is filtered out. Callers supply the
+window during the Step 9 e2e wiring (see
+`scripts/test_e2e_claim_audit.py`). Without `adjacent_text` the
+wrapper preserves the v3.8 Step 6 single-sentence behavior.
+
+Detector outputs feed into the existing pipeline routing in
+`scripts/claim_audit_pipeline.py::run_audit_pipeline`'s
+`uncited_sentences` parameter — this module is the pre-processing
+layer that turns raw draft sentences into the dicts the pipeline
+expects.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Iterable
+
+from scripts._claim_audit_constants import (
+    RE_BARE_NUMERIC_YEAR,
+    RE_DOTTED_PAIR,
+    RE_DOTTED_TRIPLE_OR_MORE,
+    RE_NUMERIC_LEFT_ATTACHED,
+    RE_NUMERIC_QUANTIFIER,
+    RE_REF_MARKER,
+    RE_SECTION_CUE,
+    RE_VERSION_PREFIX,
+    UNCITED_DEFINITION_PHRASES,
+    UNCITED_EMPIRICAL_VERBS,
+    UNCITED_FUZZY_QUANTIFIERS,
+)
+
+# Whole-word splitter for condition 1 fuzzy / verb matching. Strips
+# punctuation so `"showed."` and `"showed,"` both match.
+_RE_WORD = re.compile(r"[A-Za-z][A-Za-z-]*")
+
+# Left-context window length for guard pass cue detection. 24 chars covers
+# `cf. Section ` and `as shown in Figure ` while avoiding catching cue
+# words from a previous clause separated by punctuation.
+_GUARD_LEFT_WINDOW = 24
+
+
+def _is_year_or_version_or_section(
+    sentence: str, match_text: str, match_start: int
+) -> bool:
+    """Guard pass: return True when a bare-number match is NOT a quantifier.
+
+    Four disqualifying shapes:
+      1. 4-digit year in plausible academic range (1900-2099).
+      2. Dotted X.Y.Z[.W...] form — version triple OR deep section number.
+      3. Bare integer OR dotted X.Y form preceded by a section cue
+         (`section`, `figure`, `chapter`, `table`, `fig.`, `tbl.`,
+         `step`, `appendix`, `§`) — covers `Table 2`, `Section 5`,
+         `Figure 3` (bare-integer cue refs) AND `Section 3.1`,
+         `Figure 3.2` (dotted-pair cue refs). The bare-integer arm was
+         missing in R3 and surfaced as codex R4 P2-NEW-C.
+      3b. Dotted X.Y form preceded by `v` (version literal) — distinct
+          from the section cue because a bare integer after `v ` is
+          ambiguous (`v 5 participants` is gibberish in academic prose,
+          so the version-prefix-bare-integer combination is not common
+          enough to warrant a guard arm; the dotted-pair branch keeps
+          `v3.7` rejection.
+      4. Any match (bare or dotted) whose immediate left neighbour is a
+         dotted-number suffix like `3.` — handles the case where Python's
+         `\\b` does not fire between a letter and a digit (e.g. `v3.7.3`
+         has no \\b between `v` and `3`, so RE_NUMERIC_QUANTIFIER starts
+         from the SECOND segment `7.3`; this branch reattaches the prefix
+         and classifies the full token as a version/section reference).
+
+    Percent (`50%`) and `N of M` matches never reach this guard — the
+    caller is responsible for routing only bare-number matches through.
+    """
+    if RE_BARE_NUMERIC_YEAR.match(match_text):
+        return True
+    if RE_DOTTED_TRIPLE_OR_MORE.match(match_text):
+        # Three-or-more-segment dotted forms are unambiguously version
+        # triples or deep section numbers; no quantitative claim ever
+        # writes "50.3.1 of participants".
+        return True
+    # Branch 3: section cue applies to both bare integers and dotted pairs
+    # (`Table 2` and `Section 3.1` are both section refs); the version
+    # prefix applies only to dotted pairs (`v3.7` is a version literal,
+    # but bare `v 5` is uncommon enough that the false-negative cost
+    # outweighs the false-positive risk).
+    left = sentence[max(0, match_start - _GUARD_LEFT_WINDOW) : match_start]
+    if RE_SECTION_CUE.search(left):
+        return True
+    if RE_DOTTED_PAIR.match(match_text) and RE_VERSION_PREFIX.search(left):
+        return True
+    # Branch 4: reattach a left-side dotted-number prefix that Python's \b
+    # failed to separate. RE_NUMERIC_QUANTIFIER consumed every dotted
+    # segment to the right of the prefix already, so the only token that
+    # can sit immediately before match_start and still belong to the same
+    # logical version/section literal is `\d+\.`.
+    #
+    # Two reattachment shapes:
+    #   (i)  Immediate (no whitespace between prefix and match): the
+    #        canonical `v3.7.3` shape where the regex starts at `7.3`
+    #        because Python's \b cannot separate `v` and `3`.
+    #   (ii) Line-wrapped (whitespace between prefix and match): the
+    #        codex R2 P1-NEW shape `v3.\n7.3`.
+    #
+    # Shape (ii) is restricted to dotted matches only — a bare integer
+    # after whitespace after a period belongs to the NEXT sentence, not
+    # the version triple. `"v3. 7 participants withdrew."` is two
+    # statements: a version reference (the `v3.` is a section end) and
+    # a quantitative claim about 7 participants. Without this restriction
+    # branch 4 swallowed the legitimate 7-participant count (codex R3
+    # P2-NEW-B).
+    if match_start > 0:
+        # Shape (i) — immediate left `.` always reattaches.
+        if sentence[match_start - 1] == ".":
+            left_search_start = max(0, match_start - _GUARD_LEFT_WINDOW)
+            left = sentence[left_search_start:match_start]
+            if RE_NUMERIC_LEFT_ATTACHED.search(left):
+                return True
+        # Shape (ii) — whitespace-separated only for dotted right tails.
+        elif "." in match_text and sentence[match_start - 1].isspace():
+            scan_idx = match_start - 1
+            while scan_idx > 0 and sentence[scan_idx].isspace():
+                scan_idx -= 1
+            if sentence[scan_idx] == ".":
+                left_search_start = max(0, scan_idx + 1 - _GUARD_LEFT_WINDOW)
+                left = sentence[left_search_start : scan_idx + 1]
+                if RE_NUMERIC_LEFT_ATTACHED.search(left):
+                    return True
+    return False
+
+
+def detect_uncited(sentence: str) -> tuple[bool, list[str]]:
+    """Return `(is_candidate, trigger_tokens)` for one sentence.
+
+    Trigger tokens are returned in document order (left-to-right in the
+    source sentence) so passport diffs and human review stay aligned with
+    reader expectations. Duplicates are dropped via order-preserving
+    dedup so `"showed ... showed ... showed"` produces one token.
+    """
+    # Condition 3 fires first — if the sentence is definitional we never
+    # need to inspect quantifier tokens.
+    lowered = sentence.lower()
+    if any(phrase in lowered for phrase in UNCITED_DEFINITION_PHRASES):
+        return False, []
+
+    # Condition 2 — ref marker present means the sentence is properly
+    # cited under v3.7.3 Three-Layer Citation Emission.
+    if RE_REF_MARKER.search(sentence):
+        return False, []
+
+    # Condition 1 — collect every quantifier / verb match with its byte
+    # offset so the final token list reflects document order regardless
+    # of which regex / pass produced it.
+    matches: list[tuple[int, str]] = []
+    for m in RE_NUMERIC_QUANTIFIER.finditer(sentence):
+        text = m.group(0)
+        # Percent and `N of M` matches always pass through; only bare-
+        # number matches need the year/version/section guard. The two
+        # qualified shapes are distinguishable by character content:
+        # percent ends with `%`, `N of M` contains ` of `.
+        if "%" not in text and " of " not in text:
+            if _is_year_or_version_or_section(sentence, text, m.start()):
+                continue
+        matches.append((m.start(), text))
+
+    # Fuzzy quantifiers + empirical verbs match on lower-cased whole words.
+    triggers = UNCITED_FUZZY_QUANTIFIERS | UNCITED_EMPIRICAL_VERBS
+    for m in _RE_WORD.finditer(sentence):
+        token = m.group(0).lower()
+        if token in triggers:
+            matches.append((m.start(), token))
+
+    # Sort by source offset, then dedup preserving first occurrence.
+    matches.sort(key=lambda pair: pair[0])
+    trigger_tokens = list(dict.fromkeys(token for _, token in matches))
+    return (bool(trigger_tokens), trigger_tokens)
+
+
+def detect_uncited_assertions(
+    sentences: Iterable[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Filter raw draft sentences down to D4-c candidates.
+
+    Each input dict MUST carry a non-empty string `sentence_text`. Missing
+    or non-string `sentence_text` raises `ValueError` — silently treating
+    bad input as empty would let upstream bugs masquerade as
+    "no findings", which is the worst possible failure mode for an audit
+    pipeline.
+
+    Optional fields (`section_path`, `manifest_claim_id`,
+    `scoped_manifest_id`, `upstream_owner_agent`) pass through unchanged.
+    The detector enriches the candidate dict with `trigger_tokens`
+    (non-empty per U-INV-2) and drops sentences that fail any of the
+    three D4-c conditions.
+
+    The wrapper does NOT mint `finding_id` / `detected_at` / `rule_version`
+    — those are owned by `claim_audit_pipeline._uncited_assertion_entry`
+    so the passport-write side stays the single point of authority over
+    schema-required fields.
+    """
+    candidates: list[dict[str, Any]] = []
+    for index, raw in enumerate(sentences):
+        if "sentence_text" not in raw:
+            raise ValueError(
+                f"detect_uncited_assertions: sentences[{index}] missing "
+                "required 'sentence_text' key"
+            )
+        sentence_text = raw["sentence_text"]
+        if not isinstance(sentence_text, str):
+            raise ValueError(
+                f"detect_uncited_assertions: sentences[{index}]['sentence_text'] "
+                f"must be str, got {type(sentence_text).__name__}"
+            )
+        is_candidate, tokens = detect_uncited(sentence_text)
+        if not is_candidate:
+            continue
+        # Step-9 adjacent-clause filter. When the caller supplies an
+        # `adjacent_text` window (the surrounding clause / preceding +
+        # following sentence text per spec line 251), a ref marker inside
+        # it owns the citation and the candidate is suppressed. Empty /
+        # missing windows preserve v3.8 Step-6 single-sentence behavior.
+        adjacent_text = raw.get("adjacent_text")
+        if isinstance(adjacent_text, str) and RE_REF_MARKER.search(adjacent_text):
+            continue
+        enriched = dict(raw)
+        enriched["trigger_tokens"] = tokens
+        candidates.append(enriched)
+    return candidates
+
+
+__all__ = ["detect_uncited", "detect_uncited_assertions"]

package/vendor/ars/scripts/v3_6_7_inversion_manifest.json

@@ -0,0 +1,9 @@
+{
+  "scope": "v3.6.7-only",
+  "rationale_doc": "docs/design/2026-04-30-ars-v3.6.7-step-6-orchestrator-hooks-spec.md#6-partial-inversion-rule-downstream-agent-prompt-edits",
+  "files": [
+    "deep-research/agents/synthesis_agent.md",
+    "deep-research/agents/research_architect_agent.md",
+    "deep-research/agents/report_compiler_agent.md"
+  ]
+}

package/vendor/ars/scripts/v3_6_8_inversion_manifest.json

@@ -0,0 +1,10 @@
+{
+  "scope": "v3.6.8-only",
+  "rationale_doc": "docs/design/2026-04-30-ars-v3.6.8-trust-provenance-and-drift-transparency-spec.md#step-3a--agent-two-layer-citation-emission-uniform-across-all-modes",
+  "_note_pr1": "Step 0 created this manifest with empty `files`. Step 3a populates with the three downstream agents that emit citations: synthesis_agent (deep-research), draft_writer_agent (academic-paper), report_compiler_agent (deep-research). Each carries the canonical `## Two-Layer Citation Emission (v3.7.1)` H2 block, OUTSIDE the v3.6.7 PATTERN PROTECTION block, with invariants enforced by `check_v3_6_8_pattern_protection.py`.",
+  "files": [
+    "deep-research/agents/synthesis_agent.md",
+    "academic-paper/agents/draft_writer_agent.md",
+    "deep-research/agents/report_compiler_agent.md"
+  ]
+}

package/vendor/ars/scripts/validate_claim_standing_stance_assets.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""Offline validator for the #655 claim-standing stance seed set.
+
+Validates `evals/heldout/claim_standing_probe/heldout_stance_set.json` against
+its closed schema and the structural invariants below. File-only; no network,
+model, retrieval, or dispatch surface.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import json
+from pathlib import Path
+from typing import Any
+
+from jsonschema import Draft202012Validator
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SUITE_ROOT = REPO_ROOT / "evals" / "heldout" / "claim_standing_probe"
+SET_PATH = SUITE_ROOT / "heldout_stance_set.json"
+SET_SCHEMA = SUITE_ROOT / "heldout_stance_set.schema.json"
+EXPERT_SCHEMA = SUITE_ROOT / "expert_label.schema.json"
+SUITE_REGISTRY = SUITE_ROOT.parent / "suite_registry.json"
+
+EXPECTED_SLOTS = {
+    "support": 2,
+    "contradict": 2,
+    "mixed": 2,
+    "notaddr": 2,
+    "insuff": 2,
+    "ambig": 2,
+    "absmiss": 1,
+    "metaonly": 1,
+    "irrel": 1,
+    "fulltext": 1,
+}
+SLOT_STANCE = {
+    "support": "support",
+    "contradict": "contradict",
+    "mixed": "mixed",
+    "notaddr": "not_addressed",
+    "insuff": "INSUFFICIENT_EVIDENCE",
+    "ambig": "AMBIGUOUS",
+    "fulltext": "support",
+}
+SLOT_COVERAGE = {"fulltext": "session_held_full_text", "metaonly": "metadata_only"}
+# Heuristic screen only: a curated list of characters that are simplified-only
+# in ordinary academic prose. A hit is a likely defect, not proof; characters
+# with common Traditional readings (e.g. 后, 云, 从) are deliberately excluded.
+SIMPLIFIED_CHARS = set(
+    "们会学习语记观认证论试变对关发体历礼国广边办应问题网络电产农动传"
+    "亚区医药币岁苏软热顾风龙买卖读书写这为么样点让还时实现"
+)
+
+
+class AssetError(RuntimeError):
+    pass
+
+
+def _fail(message: str) -> None:
+    raise AssetError(message)
+
+
+def _reject_pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    value: dict[str, Any] = {}
+    for key, item in pairs:
+        if key in value:
+            raise ValueError(f"duplicate JSON key {key!r}")
+        value[key] = item
+    return value
+
+
+def _strict_loads(raw: bytes, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(
+            raw.decode("utf-8"),
+            object_pairs_hook=_reject_pairs,
+            parse_constant=lambda token: (_ for _ in ()).throw(
+                ValueError(f"non-finite JSON value {token!r}")
+            ),
+        )
+    except (UnicodeError, ValueError) as exc:
+        _fail(f"{label}: invalid strict JSON: {exc}")
+    if not isinstance(value, dict):
+        _fail(f"{label}: JSON root must be an object")
+    return value
+
+
+def load_set() -> dict[str, Any]:
+    return _strict_loads(SET_PATH.read_bytes(), "seed set")
+
+
+def _slot(item_id: str) -> str:
+    return item_id.split("-")[2]
+
+
+def validate_set(value: dict[str, Any]) -> None:
+    schema = json.loads(SET_SCHEMA.read_bytes())
+    errors = sorted(
+        Draft202012Validator(schema).iter_errors(value), key=lambda e: str(e.path)
+    )
+    if errors:
+        first = errors[0]
+        _fail(f"schema: {list(first.path)!r}: {first.message}")
+
+    items = value["items"]
+    ids = [item["item_id"] for item in items]
+    if len(set(ids)) != len(ids):
+        _fail("item ids must be unique")
+
+    for prefix, language in (("csp-en-", "en"), ("csp-zh-", "zh-TW")):
+        subset = [item for item in items if item["item_id"].startswith(prefix)]
+        if len(subset) != sum(EXPECTED_SLOTS.values()):
+            _fail(
+                f"language block {language} must contain exactly "
+                f"{sum(EXPECTED_SLOTS.values())} items"
+            )
+        for item in subset:
+            if item["language"] != language:
+                _fail(f"{item['item_id']}: id prefix and language field disagree")
+        slots = Counter(_slot(item["item_id"]) for item in subset)
+        if slots != EXPECTED_SLOTS:
+            _fail(
+                f"language block {language} design-slot coverage is not exact: "
+                f"{dict(slots)!r}"
+            )
+        disciplines = [item["discipline"] for item in subset]
+        if len(set(disciplines)) != len(disciplines):
+            _fail(f"language block {language} disciplines must be distinct")
+
+    for item in items:
+        item_id = item["item_id"]
+        slot = _slot(item_id)
+        candidate = item["candidate"]
+        target = item["design_target"]
+        if candidate["doi"] != f"10.99999/{item_id}":
+            _fail(f"{item_id}: doi must be 10.99999/{item_id}")
+        if candidate["work_family_id"] != f"wf-{item_id}":
+            _fail(f"{item_id}: work_family_id must be wf-{item_id}")
+
+        if slot in SLOT_STANCE:
+            if (
+                item["relevance_design"] != "relevant"
+                or candidate["coverage"] != SLOT_COVERAGE.get(slot, "abstract")
+                or candidate["content_state"] != "available"
+                or target
+                != {
+                    "check_state": "performed",
+                    "stance": SLOT_STANCE[slot],
+                    "failure_state": None,
+                }
+            ):
+                _fail(f"{item_id}: does not realize its design slot ({slot})")
+        elif slot in ("absmiss", "metaonly"):
+            if (
+                item["relevance_design"] != "relevant"
+                or candidate["coverage"] != SLOT_COVERAGE.get(slot, "abstract")
+                or candidate["content_state"] != "abstract_missing"
+                or candidate["evidence_text"] is not None
+                or target
+                != {
+                    "check_state": "not_checked",
+                    "stance": None,
+                    "failure_state": "abstract_missing",
+                }
+            ):
+                _fail(
+                    f"{item_id}: missing-evidence slot must target "
+                    "not_checked with failure_state abstract_missing"
+                )
+        else:
+            # The slot table is exact, so only "irrel" can reach here.
+            if item["relevance_design"] != "not_relevant":
+                _fail(f"{item_id}: the irrelevant-candidate slot must be not_relevant")
+            if target != {
+                "check_state": "not_checked",
+                "stance": None,
+                "failure_state": None,
+            }:
+                _fail(f"{item_id}: not_relevant target is not_checked with null failure")
+
+        if item["language"] == "zh-TW":
+            text = "".join(
+                [
+                    item["claim_text"],
+                    item["discipline"],
+                    candidate["title"],
+                    candidate["venue"],
+                    candidate["evidence_text"] or "",
+                ]
+            )
+            hits = sorted(set(text) & SIMPLIFIED_CHARS)
+            if hits:
+                _fail(f"{item_id}: simplified-Chinese characters present: {hits!r}")
+
+    registry = _strict_loads(SUITE_REGISTRY.read_bytes(), "suite registry")
+    if value["suite"] in registry:
+        _fail(
+            "the seed set is unmeasured: claim_standing_probe must not be "
+            "registered in suite_registry.json until the implementation PR "
+            "carries a valid baseline row"
+        )
+
+
+def validate_expert_file(value: dict[str, Any], set_value: dict[str, Any]) -> None:
+    schema = json.loads(EXPERT_SCHEMA.read_bytes())
+    errors = sorted(
+        Draft202012Validator(schema).iter_errors(value), key=lambda e: str(e.path)
+    )
+    if errors:
+        first = errors[0]
+        _fail(f"expert file schema: {list(first.path)!r}: {first.message}")
+    labeled = [row["item_id"] for row in value["labels"]]
+    if len(set(labeled)) != len(labeled):
+        _fail("expert file labels the same item more than once")
+    set_ids = {item["item_id"] for item in set_value["items"]}
+    if set(labeled) != set_ids:
+        _fail("expert file must label exactly the seed set's 32 distinct items")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("validate-assets", help="validate the shipped seed set")
+    expert_parser = subparsers.add_parser(
+        "validate-expert-file",
+        help="validate one expert label file against the seed set",
+    )
+    expert_parser.add_argument("--expert-file", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        set_value = load_set()
+        if args.command == "validate-expert-file":
+            validate_expert_file(
+                _strict_loads(args.expert_file.read_bytes(), "expert file"),
+                set_value,
+            )
+            print("expert label file: complete distinct coverage of the seed set")
+            return 0
+        validate_set(set_value)
+    except AssetError as exc:
+        print(str(exc))
+        return 1
+    print("claim-standing stance seed set: all invariants hold (32 items)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/ars/scripts/validate_compliance_fixtures.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Validate all compliance_report YAML fixtures against Schema 12.
+
+Loads each examples/compliance/fixture_*.yaml in-process and runs it
+through scripts.check_compliance_report.validate(). Exits 0 if every
+fixture validates; exits 1 on first failure or if no fixtures are found.
+
+Usage:
+  python scripts/validate_compliance_fixtures.py [fixture_dir]
+
+Default fixture_dir: examples/compliance (relative to repo root).
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import yaml
+
+from check_compliance_report import validate
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_DIR = REPO_ROOT / "examples" / "compliance"
+
+
+def validate_fixture(yaml_path: Path) -> list[str]:
+    data = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+    return validate(data)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("fixture_dir", type=Path, nargs="?", default=DEFAULT_DIR)
+    args = parser.parse_args()
+
+    fixtures = sorted(args.fixture_dir.glob("fixture_*.yaml"))
+    if not fixtures:
+        print(f"ERROR: no fixture_*.yaml files in {args.fixture_dir}", file=sys.stderr)
+        return 1
+
+    failed = 0
+    for fx in fixtures:
+        errors = validate_fixture(fx)
+        if errors:
+            print(f"[FAIL] {fx.name}:")
+            for e in errors:
+                print(f"  {e}")
+            failed += 1
+        else:
+            print(f"[OK] {fx.name}")
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())