psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/check_rq_framing_patterns.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Calibration checker for the #257 Socratic wording-pattern advisory.
+
+The detector is intentionally lexical and conservative. It is not a novelty
+model and does not judge research quality; it only checks whether a proposed RQ
+uses one of the common surface shells documented in the Socratic mentor prompts.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import string
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_GOLD_SET = REPO_ROOT / "evals/gold/rq_framing_patterns/gold_set.json"
+POSITIVE_LABEL = "wording_cliche"
+NEGATIVE_LABEL = "domain_native"
+
+_PUNCT_TRANSLATION = str.maketrans({c: " " for c in string.punctuation})
+
+
+@dataclass(frozen=True)
+class PatternSpec:
+    pattern_id: str
+    label: str
+    regex: re.Pattern[str]
+
+
+def _rx(pattern: str) -> re.Pattern[str]:
+    return re.compile(pattern, re.IGNORECASE)
+
+
+REFERENCE_PATTERNS: tuple[PatternSpec, ...] = (
+    PatternSpec("WP01", "impact/effect frame", _rx(r"\b(?:explor\w*|investigat\w*|examin\w*|analyz\w*|study\w*)\s+(?:the\s+)?(?:impact|effect)s?\s+of\b.+\bon\b")),
+    PatternSpec("WP02", "relationship frame", _rx(r"\b(?:investigat\w*|examin\w*|explor\w*)?\s*(?:the\s+)?(?:relationship|association|correlation)\s+between\b")),
+    PatternSpec("WP03", "role frame", _rx(r"\b(?:understand\w*|examin\w*|investigat\w*|explor\w*|analyz\w*|assess\w*)\s+(?:the\s+)?role\s+of\b.+\bin\b")),
+    PatternSpec("WP04", "influence frame", _rx(r"\b(?:analyz\w*|investigat\w*|examin\w*|explor\w*)\s+how\b.+\b(?:influences?|affects?)\b")),
+    PatternSpec("WP05", "generic factors frame", _rx(r"\b(?:explor\w*|investigat\w*|examin\w*|analyz\w*)?\s*factors\s+(?:influencing|affecting|that\s+influence|that\s+affect)\b")),
+    PatternSpec("WP06", "bare study-of frame", _rx(r"^(?:a|an|the)\s+(?:\w+\s+)?study\s+of\b")),
+    PatternSpec("WP07", "impact case-study frame", _rx(r"\bimpact\s+of\b.+\bon\b.+\bcase\s+study\b|\bcase\s+study\b.+\bimpact\s+of\b")),
+    PatternSpec("WP08", "challenges/opportunities pair", _rx(r"\bchallenges\s+and\s+opportunities\s+of\b")),
+    PatternSpec("WP09", "perception/attitude survey frame", _rx(r"\b(?:perceptions|attitudes)\s+(?:of\b.+\s+)?(?:toward|towards|about)\b")),
+    PatternSpec("WP10", "performance/achievement effect frame", _rx(r"\b(?:the\s+)?effect\s+of\b.+\bon\b.+\b(?:performance|achievement|satisfaction|outcomes?)\b")),
+    PatternSpec("WP11", "achievement relationship frame", _rx(r"\brelationship\s+between\b.+\band\b.+\b(?:performance|achievement|outcomes?)\b")),
+    PatternSpec("WP12", "generic use/application frame", _rx(r"\b(?:explor\w*|investigat\w*|examin\w*|analyz\w*|assess\w*)\s+(?:the\s+)?(?:use|application|implementation)\s+of\b.+\bin\b")),
+    PatternSpec("WP13", "effectiveness frame", _rx(r"\b(?:investigat\w*|examin\w*|evaluat\w*)?\s*(?:the\s+)?effectiveness\s+of\b.+\b(?:for|in|on)\b")),
+    PatternSpec("WP14", "mediator/moderator template", _rx(r"\b(?:mediating|moderating)\s+role\s+of\b")),
+    PatternSpec("WP15", "adoption/intention/satisfaction factors", _rx(r"\bfactors\s+affecting\b.+\b(?:adoption|intention|satisfaction)\b")),
+    PatternSpec("WP16", "barriers/facilitators pair", _rx(r"\bbarriers\s+and\s+facilitators\s+to\b")),
+    PatternSpec("WP17", "comparative-study shell", _rx(r"\bcomparative\s+study\s+of\b")),
+    PatternSpec("WP18", "framework/model shell", _rx(r"\btowards?\s+a\s+(?:framework|model)\s+for\b")),
+    PatternSpec("WP19", "technology-enhancement shell", _rx(r"\brole\s+of\s+(?:technology|ai|artificial\s+intelligence|digital\s+tools)\b.+\benhanc\w*\b")),
+    PatternSpec("WP20", "experience-of frame", _rx(r"\b(?:explor\w*|investigat\w*|examin\w*)?\s*(?:the\s+)?experiences\s+of\b.+\b(?:in|with|during)\b")),
+)
+
+
+def normalize(text: str) -> str:
+    return " ".join(text.lower().translate(_PUNCT_TRANSLATION).split())
+
+
+def analyze_framing(text: str) -> dict[str, Any]:
+    normalized = normalize(text)
+    matches = [spec for spec in REFERENCE_PATTERNS if spec.regex.search(normalized)]
+    return {
+        "trigger_advisory": bool(matches),
+        "matched_pattern_ids": [spec.pattern_id for spec in matches],
+        "matched_pattern_labels": [spec.label for spec in matches],
+    }
+
+
+def _load_gold_set(path: Path) -> list[dict[str, Any]]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    items = data.get("items")
+    if not isinstance(items, list):
+        raise ValueError("gold set must contain an items[] list")
+    return items
+
+
+def evaluate_items(items: list[dict[str, Any]]) -> dict[str, Any]:
+    tp = tn = fp = fn = 0
+    item_results: list[dict[str, Any]] = []
+    errors: list[str] = []
+
+    for item in items:
+        item_id = item.get("id", "<missing-id>")
+        label = item.get("label")
+        if label not in {POSITIVE_LABEL, NEGATIVE_LABEL}:
+            errors.append(f"{item_id}: invalid label {label!r}")
+            continue
+        text = item.get("text")
+        if not isinstance(text, str) or not text.strip():
+            errors.append(f"{item_id}: missing non-empty text")
+            continue
+        analysis = analyze_framing(text)
+        predicted_positive = analysis["trigger_advisory"]
+        actual_positive = label == POSITIVE_LABEL
+        expected_pattern_ids = item.get("expected_pattern_ids", [])
+        if not isinstance(expected_pattern_ids, list):
+            errors.append(f"{item_id}: expected_pattern_ids must be a list")
+            continue
+
+        matched = set(analysis["matched_pattern_ids"])
+        missing_expected = sorted(set(expected_pattern_ids) - matched)
+        if actual_positive and missing_expected:
+            errors.append(f"{item_id}: expected patterns not matched: {missing_expected}")
+        if not actual_positive and matched:
+            errors.append(f"{item_id}: domain-native item matched unexpected patterns: {sorted(matched)}")
+
+        if predicted_positive and actual_positive:
+            tp += 1
+        elif predicted_positive and not actual_positive:
+            fp += 1
+        elif not predicted_positive and actual_positive:
+            fn += 1
+        else:
+            tn += 1
+
+        item_results.append({
+            "id": item_id,
+            "label": label,
+            "predicted_positive": predicted_positive,
+            **analysis,
+        })
+
+    positives = tp + fn
+    negatives = tn + fp
+    fnr = fn / positives if positives else 0.0
+    fpr = fp / negatives if negatives else 0.0
+    tpr = tp / positives if positives else 0.0
+    tnr = tn / negatives if negatives else 0.0
+    balanced_accuracy = (tpr + tnr) / 2 if positives and negatives else 0.0
+
+    if len(items) != 40:
+        errors.append(f"sample_n must be 40, got {len(items)}")
+    if positives != 20 or negatives != 20:
+        errors.append(f"gold set must be balanced 20/20, got positives={positives}, negatives={negatives}")
+    if fnr >= 0.30:
+        errors.append(f"FNR {fnr:.3f} must be < 0.30")
+    if fpr >= 0.20:
+        errors.append(f"FPR {fpr:.3f} must be < 0.20")
+    if balanced_accuracy < 0.75:
+        errors.append(f"balanced accuracy {balanced_accuracy:.3f} must be >= 0.75")
+
+    return {
+        "counts": {"tp": tp, "tn": tn, "fp": fp, "fn": fn, "positives": positives, "negatives": negatives},
+        "metrics": {"fnr": fnr, "fpr": fpr, "balanced_accuracy": balanced_accuracy},
+        "item_results": item_results,
+        "errors": errors,
+    }
+
+
+def validate_gold_set(path: Path = DEFAULT_GOLD_SET) -> dict[str, Any]:
+    return evaluate_items(_load_gold_set(path))
+
+
+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)
+
+    result = validate_gold_set(args.gold_set)
+    counts = result["counts"]
+    metrics = result["metrics"]
+    print(
+        "rq_framing_patterns: "
+        f"tp={counts['tp']} tn={counts['tn']} fp={counts['fp']} fn={counts['fn']} "
+        f"fnr={metrics['fnr']:.3f} fpr={metrics['fpr']:.3f} "
+        f"balanced_accuracy={metrics['balanced_accuracy']:.3f}"
+    )
+    if result["errors"]:
+        for error in result["errors"]:
+            print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/ars/scripts/check_rubric_weight_consistency.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Compatibility entrypoint for the retired rubric-weight lint.
+
+Reviewer weights and aggregate scores no longer exist. Keep this filename so
+older CI invocations fail closed through the replacement honesty contract.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from check_reviewer_scoring_honesty import check
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--root", type=Path, default=Path(__file__).resolve().parents[1]
+    )
+    args = parser.parse_args(argv)
+    errors, missing = check(args.root)
+    if errors:
+        for error in errors:
+            print(f"FAIL: {error}", file=sys.stderr)
+        return 2 if missing else 1
+    print("rubric-weight compatibility check: retired; reviewer scoring honesty OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/ars/scripts/check_seeded_defect_fixtures.py

@@ -0,0 +1,425 @@
+#!/usr/bin/env python3
+"""Integrity lint for evals/heldout/reviewer_seeded_defects/ (#574/#610 v0.2).
+
+Structure-only fixture gate (the field_norm_severity precedent): it validates
+that the ground-truth manifests and manuscripts agree, so a drifted fixture
+cannot silently corrupt a baseline/acceptance run. It measures nothing about
+reviewer behavior.
+
+Invariants:
+  1. Every manifest parses, carries the required top-level keys, and its
+     `manuscript` path exists.
+  2. `defect_count == len(defects)`.
+  3. Every defect row carries all required fields; `class`, `expected_severity`,
+     and `expected_detector` come from the closed enums; `defect_id` values are
+     unique within a manifest.
+  4. Every `anchor_quote` (8-25 words) appears VERBATIM exactly once in its
+     manuscript.
+  5. The clean control manuscript exists and no manifest points at it.
+  6. The manifest set is exactly the expected fixture inventory (a deleted
+     manifest cannot silently shrink the acceptance set), and every
+     `*_defective.md` manuscript is covered by a manifest.
+  7. Every statistical defect carries one closed `statistical_kind`; the
+     exact v0.2 kind/defect projection is pinned so reporting-only defects do
+     not silently enter the #610 recomputation denominator.
+  8. Every GRIMMER defect carries a small, structured integer-scale oracle
+     whose expected inconsistency is recomputed by this checker.
+
+Run: python3 scripts/check_seeded_defect_fixtures.py
+Exit 0 on pass; 1 with per-invariant messages on failure.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from decimal import Decimal, InvalidOperation, ROUND_HALF_UP, localcontext
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+ROOT = REPO / "evals" / "heldout" / "reviewer_seeded_defects"
+MANIFESTS = ROOT / "manifests"
+CLEAN_CONTROL = ROOT / "manuscripts" / "ms00_clean_control.md"
+
+# Expected inventory — update deliberately when fixtures/defects are
+# added/retired. Values are the EXACT defect-ID sets: a coordinated
+# row-deletion + defect_count decrement (or an SD-* rename that would orphan
+# per_defect run records) must fail CI, not shrink the denominator silently.
+EXPECTED_FIXTURE_VERSION = "0.2"
+EXPECTED_DEFECT_IDS = {
+    "ms01_quant": {f"SD-{i:02d}" for i in range(1, 12)},
+    "ms02_qual": {f"SD-{i:02d}" for i in range(1, 10)},
+}
+EXPECTED_FIXTURES = set(EXPECTED_DEFECT_IDS)
+EXPECTED_STATISTICAL_KINDS = {
+    "ms01_quant": {
+        "SD-01": "grim",
+        "SD-02": "n_from_df",
+        "SD-03": "p_from_test_statistic",
+        "SD-11": "grimmer",
+    },
+    "ms02_qual": {"SD-07": "reporting_only"},
+}
+
+REQUIRED_TOP = {
+    "fixture_id",
+    "fixture_version",
+    "manuscript",
+    "defect_count",
+    "defects",
+}
+REQUIRED_DEFECT = {
+    "defect_id",
+    "class",
+    "expected_severity",
+    "section",
+    "anchor_quote",
+    "description",
+    "expected_detector",
+}
+CLASSES = {
+    "statistical",
+    "inference",
+    "citation_claim_mismatch",
+    "methods",
+    "ethics",
+    "internal_consistency",
+    "overclaim",
+    "qual_rigor",
+}
+SEVERITIES = {"critical", "major", "minor"}
+DETECTORS = {
+    "methodology",
+    "statistics",
+    "domain",
+    "ethics",
+    "internal_consistency",
+    "any",
+}
+STATISTICAL_KINDS = {
+    "grim",
+    "grimmer",
+    "n_from_df",
+    "p_from_test_statistic",
+    "reporting_only",
+}
+RECOMPUTE_ORACLE_FIELDS = {
+    "type",
+    "n",
+    "scale_min",
+    "scale_max",
+    "reported_mean",
+    "reported_sd",
+    "sd_convention",
+    "rounding",
+    "expected_consistent",
+}
+
+
+def _reported_quantum(value: str) -> tuple[Decimal, Decimal]:
+    """Return a finite reported decimal and its explicit precision quantum."""
+    if not isinstance(value, str):
+        raise ValueError("reported values must be strings that preserve precision")
+    try:
+        parsed = Decimal(value)
+    except InvalidOperation as exc:
+        raise ValueError(f"invalid decimal {value!r}") from exc
+    if not parsed.is_finite():
+        raise ValueError(f"reported decimal must be finite, got {value!r}")
+    exponent = parsed.as_tuple().exponent
+    quantum = Decimal(1).scaleb(exponent if exponent < 0 else 0)
+    return parsed, quantum
+
+
+def integer_scale_mean_sd_reachability(oracle: dict) -> tuple[bool, bool]:
+    """Return rounded-mean and joint mean/SD reachability.
+
+    This is a fixture oracle, not the future production GRIMMER engine. Its
+    deliberately small bounds keep CI deterministic while independently
+    proving that a planted prospective defect is arithmetically impossible.
+    """
+    if not isinstance(oracle, dict):
+        raise ValueError("recompute_oracle must be an object")
+    if set(oracle) != RECOMPUTE_ORACLE_FIELDS:
+        missing = sorted(RECOMPUTE_ORACLE_FIELDS - set(oracle))
+        extra = sorted(set(oracle) - RECOMPUTE_ORACLE_FIELDS)
+        raise ValueError(f"oracle fields differ (missing={missing}, extra={extra})")
+    if oracle["type"] != "integer_scale_mean_sd":
+        raise ValueError(f"unsupported oracle type {oracle['type']!r}")
+    n = oracle["n"]
+    scale_min = oracle["scale_min"]
+    scale_max = oracle["scale_max"]
+    if (
+        isinstance(n, bool)
+        or not isinstance(n, int)
+        or not 2 <= n <= 30
+    ):
+        raise ValueError("oracle n must be an integer between 2 and 30")
+    if any(
+        isinstance(value, bool) or not isinstance(value, int)
+        for value in (scale_min, scale_max)
+    ):
+        raise ValueError("oracle scale bounds must be integers")
+    if scale_min >= scale_max or scale_max - scale_min > 10:
+        raise ValueError("oracle scale must be increasing with width at most 10")
+    if oracle["sd_convention"] not in {"sample", "population"}:
+        raise ValueError("sd_convention must be sample or population")
+    if oracle["rounding"] != "half_up":
+        raise ValueError("only half_up rounding is supported by the v0.2 oracle")
+    if not isinstance(oracle["expected_consistent"], bool):
+        raise ValueError("expected_consistent must be Boolean")
+
+    reported_mean, mean_quantum = _reported_quantum(oracle["reported_mean"])
+    reported_sd, sd_quantum = _reported_quantum(oracle["reported_sd"])
+    if reported_sd < 0:
+        raise ValueError("reported_sd cannot be negative")
+
+    states = {(0, 0)}
+    for _ in range(n):
+        states = {
+            (total + value, total_sq + value * value)
+            for total, total_sq in states
+            for value in range(scale_min, scale_max + 1)
+        }
+
+    mean_reachable = False
+    with localcontext() as context:
+        context.prec = 50
+        decimal_n = Decimal(n)
+        for total, total_sq in states:
+            mean = Decimal(total) / decimal_n
+            if mean.quantize(mean_quantum, rounding=ROUND_HALF_UP) != reported_mean:
+                continue
+            mean_reachable = True
+            variance_numerator = n * total_sq - total * total
+            variance_denominator = (
+                n * (n - 1)
+                if oracle["sd_convention"] == "sample"
+                else n * n
+            )
+            sd = (
+                Decimal(variance_numerator) / Decimal(variance_denominator)
+            ).sqrt()
+            if sd.quantize(sd_quantum, rounding=ROUND_HALF_UP) == reported_sd:
+                return True, True
+    return mean_reachable, False
+
+
+def integer_scale_mean_sd_consistent(oracle: dict) -> bool:
+    """Compatibility wrapper returning joint mean/SD reachability only."""
+    return integer_scale_mean_sd_reachability(oracle)[1]
+
+
+def canonical_recompute_oracle_anchor(oracle: dict) -> str:
+    """Bind every oracle input to one unambiguous manuscript anchor."""
+    return (
+        "the reported secondary-item values were "
+        f"N={oracle['n']}; M={oracle['reported_mean']}; "
+        f"{oracle['sd_convention']} SD={oracle['reported_sd']}; "
+        f"integer scale={oracle['scale_min']}-{oracle['scale_max']}"
+    )
+
+
+def check_recompute_oracle(path: Path, row: dict, errors: list[str]) -> None:
+    rid = row.get("defect_id", "<missing id>")
+    oracle = row.get("recompute_oracle")
+    try:
+        mean_reachable, joint_reachable = integer_scale_mean_sd_reachability(
+            oracle
+        )
+    except (ValueError, ArithmeticError) as exc:
+        errors.append(f"inv8 {path.name} {rid}: invalid recompute_oracle ({exc})")
+        return
+    # A defect cannot make a reachable replacement self-validating by changing
+    # the expectation beside it. GRIMMER rows in this held-out manifest are,
+    # by definition, planted inconsistencies.
+    if oracle["expected_consistent"] is not False:
+        errors.append(
+            f"inv8 {path.name} {rid}: a grimmer defect must set "
+            "expected_consistent=false"
+        )
+    if not mean_reachable:
+        errors.append(
+            f"inv8 {path.name} {rid}: GRIMMER prerequisite mean is unreachable"
+        )
+    if joint_reachable:
+        errors.append(
+            f"inv8 {path.name} {rid}: planted grimmer values are reachable"
+        )
+    expected_anchor = canonical_recompute_oracle_anchor(oracle)
+    if row.get("anchor_quote") != expected_anchor:
+        errors.append(
+            f"inv8 {path.name} {rid}: oracle anchor must exactly equal "
+            f"{expected_anchor!r}"
+        )
+
+
+def check_manifest(path: Path, errors: list[str]) -> None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        errors.append(f"inv1 {path.name}: unreadable/invalid JSON ({exc})")
+        return
+
+    missing = REQUIRED_TOP - data.keys()
+    if missing:
+        errors.append(f"inv1 {path.name}: missing top-level keys {sorted(missing)}")
+        return
+    if data["fixture_version"] != EXPECTED_FIXTURE_VERSION:
+        errors.append(
+            f"inv1 {path.name}: fixture_version={data['fixture_version']!r}, "
+            f"expected {EXPECTED_FIXTURE_VERSION!r}"
+        )
+
+    ms_path = ROOT / data["manuscript"]
+    if not ms_path.is_file():
+        errors.append(f"inv1 {path.name}: manuscript not found: {data['manuscript']}")
+        return
+    if ms_path.resolve() == CLEAN_CONTROL.resolve():
+        errors.append(f"inv5 {path.name}: manifest points at the clean control")
+        return
+    text = ms_path.read_text(encoding="utf-8")
+
+    defects = data["defects"]
+    if data["defect_count"] != len(defects):
+        errors.append(
+            f"inv2 {path.name}: defect_count={data['defect_count']} but "
+            f"{len(defects)} defect rows"
+        )
+
+    seen_ids: set[str] = set()
+    for row in defects:
+        rid = row.get("defect_id", "<missing id>")
+        missing_fields = REQUIRED_DEFECT - row.keys()
+        if missing_fields:
+            errors.append(f"inv3 {path.name} {rid}: missing {sorted(missing_fields)}")
+            continue
+        if rid in seen_ids:
+            errors.append(f"inv3 {path.name} {rid}: duplicate defect_id")
+        seen_ids.add(rid)
+        if row["class"] not in CLASSES:
+            errors.append(f"inv3 {path.name} {rid}: unknown class {row['class']!r}")
+        kind = row.get("statistical_kind")
+        if row["class"] == "statistical":
+            if kind not in STATISTICAL_KINDS:
+                errors.append(
+                    f"inv7 {path.name} {rid}: statistical_kind must be one of "
+                    f"{sorted(STATISTICAL_KINDS)}, got {kind!r}"
+                )
+            if kind == "grimmer":
+                check_recompute_oracle(path, row, errors)
+            elif "recompute_oracle" in row:
+                errors.append(
+                    f"inv8 {path.name} {rid}: only grimmer rows may carry "
+                    "recompute_oracle"
+                )
+        elif "statistical_kind" in row:
+            errors.append(
+                f"inv7 {path.name} {rid}: non-statistical row must not carry "
+                "statistical_kind"
+            )
+        elif "recompute_oracle" in row:
+            errors.append(
+                f"inv8 {path.name} {rid}: non-GRIMMER row must not carry "
+                "recompute_oracle"
+            )
+        if row["expected_severity"] not in SEVERITIES:
+            errors.append(
+                f"inv3 {path.name} {rid}: unknown severity "
+                f"{row['expected_severity']!r}"
+            )
+        if row["expected_detector"] not in DETECTORS:
+            errors.append(
+                f"inv3 {path.name} {rid}: unknown detector "
+                f"{row['expected_detector']!r}"
+            )
+        anchor = row["anchor_quote"]
+        n_words = len(anchor.split())
+        if not 8 <= n_words <= 25:
+            errors.append(
+                f"inv4 {path.name} {rid}: anchor_quote is {n_words} words "
+                f"(bound: 8-25)"
+            )
+        occurrences = text.count(anchor)
+        if occurrences != 1:
+            errors.append(
+                f"inv4 {path.name} {rid}: anchor_quote occurs {occurrences}x "
+                f"in {data['manuscript']} (must be exactly 1)"
+            )
+
+
+def main() -> int:
+    errors: list[str] = []
+    manifest_paths = sorted(MANIFESTS.glob("*.defects.json"))
+    if not manifest_paths:
+        errors.append(f"inv1: no manifests found under {MANIFESTS}")
+    seen_fixture_ids: list[str] = []
+    manifested_manuscripts: set[str] = set()
+    for path in manifest_paths:
+        check_manifest(path, errors)
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            seen_fixture_ids.append(data.get("fixture_id", ""))
+            manifested_manuscripts.add(data.get("manuscript", ""))
+        except (OSError, json.JSONDecodeError):
+            pass  # already reported by check_manifest
+    for path in manifest_paths:
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue  # already reported
+        fid = data.get("fixture_id", "")
+        expected_ids = EXPECTED_DEFECT_IDS.get(fid)
+        if expected_ids is None:
+            continue  # unknown fixture_id handled by the set-equality check
+        actual_ids = {
+            row.get("defect_id", "") for row in data.get("defects", [])
+        }
+        if actual_ids != expected_ids:
+            errors.append(
+                f"inv6 {path.name}: defect ids {sorted(actual_ids)} != expected "
+                f"{sorted(expected_ids)} — deleting/renaming a defect must be a "
+                f"deliberate EXPECTED_DEFECT_IDS update, never a silent shrink"
+            )
+        actual_kinds = {
+            row.get("defect_id", ""): row.get("statistical_kind")
+            for row in data.get("defects", [])
+            if row.get("class") == "statistical"
+        }
+        expected_kinds = EXPECTED_STATISTICAL_KINDS.get(fid, {})
+        if actual_kinds != expected_kinds:
+            errors.append(
+                f"inv7 {path.name}: statistical projection {actual_kinds} != "
+                f"expected {expected_kinds} — recompute and reporting-only "
+                "denominators are versioned inventory"
+            )
+    if len(seen_fixture_ids) != len(set(seen_fixture_ids)):
+        errors.append(
+            "inv6: duplicate fixture_id across manifests — an extra manifest "
+            "reusing an expected id would corrupt or double-count the inventory"
+        )
+    if set(seen_fixture_ids) != EXPECTED_FIXTURES:
+        errors.append(
+            f"inv6: manifest fixture_ids {sorted(set(seen_fixture_ids))} != expected "
+            f"{sorted(EXPECTED_FIXTURES)} — a missing manifest silently shrinks "
+            f"the acceptance set; update EXPECTED_FIXTURES deliberately instead"
+        )
+    for ms in sorted((ROOT / "manuscripts").glob("*_defective.md")):
+        rel = f"manuscripts/{ms.name}"
+        if rel not in manifested_manuscripts:
+            errors.append(f"inv6: defective manuscript {rel} has no manifest")
+    if not CLEAN_CONTROL.is_file():
+        errors.append(f"inv5: clean control missing: {CLEAN_CONTROL}")
+
+    if errors:
+        for e in errors:
+            print(f"FAIL {e}", file=sys.stderr)
+        return 1
+    print(
+        f"PASSED: check_seeded_defect_fixtures — {len(manifest_paths)} manifests, "
+        f"clean control present"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())