psyclaw 0.27.23 → 0.28.1

package/vendor/ars/scripts/test_check_reviewer_finding_contract.py

@@ -0,0 +1,1107 @@
+#!/usr/bin/env python3
+"""Mutation test for check_reviewer_finding_contract.py (#574 behavior batch).
+
+Each retired drift class, re-introduced, must make the lint FAIL: quota
+restoration (A1), receipt/contract gutting (A1), anchor vocabulary loss (A2),
+severity re-derivation surfaces (A3), base-rate anchors (B1), and the P0-3
+overlap-prohibition residue. Positive control confirms the unmutated tree
+PASSES.
+
+Run:
+    python -m pytest scripts/test_check_reviewer_finding_contract.py
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CHECKER = REPO_ROOT / "scripts" / "check_reviewer_finding_contract.py"
+
+SCORING_AGENTS = (
+    "academic-paper-reviewer/agents/eic_agent.md",
+    "academic-paper-reviewer/agents/methodology_reviewer_agent.md",
+    "academic-paper-reviewer/agents/domain_reviewer_agent.md",
+    "academic-paper-reviewer/agents/perspective_reviewer_agent.md",
+)
+DA_REL = "academic-paper-reviewer/agents/devils_advocate_reviewer_agent.md"
+SYNTH_REL = "academic-paper-reviewer/agents/editorial_synthesizer_agent.md"
+TEMPLATE_REL = "academic-paper-reviewer/templates/peer_review_report_template.md"
+DECISION_TEMPLATE_REL = "academic-paper-reviewer/templates/editorial_decision_template.md"
+STANDARDS_REL = "academic-paper-reviewer/references/editorial_decision_standards.md"
+SKILL_REL = "academic-paper-reviewer/SKILL.md"
+SCHEMAS_REL = "shared/handoff_schemas.md"
+CALIBRATION_REL = "academic-paper-reviewer/references/calibration_mode_protocol.md"
+GUIDED_REL = "academic-paper-reviewer/references/guided_mode_protocol.md"
+RQT_REL = "academic-paper-reviewer/references/review_quality_thinking.md"
+RESPONSE_TEMPLATE_REL = "academic-paper-reviewer/templates/revision_response_template.md"
+STATS_REL = "academic-paper-reviewer/references/statistical_reporting_standards.md"
+RCF_REL = "academic-paper-reviewer/references/review_criteria_framework.md"
+XM_REL = "shared/cross_model_verification.md"
+FIELD_ANALYST_REL = "academic-paper-reviewer/agents/field_analyst_agent.md"
+DOMAIN_REL = SCORING_AGENTS[2]
+
+ALL_FILES = SCORING_AGENTS + (
+    DA_REL, SYNTH_REL, TEMPLATE_REL, DECISION_TEMPLATE_REL, STANDARDS_REL,
+    SKILL_REL, SCHEMAS_REL, CALIBRATION_REL, GUIDED_REL, RQT_REL,
+    RESPONSE_TEMPLATE_REL, STATS_REL, RCF_REL, XM_REL, FIELD_ANALYST_REL,
+)
+
+
+def _run2(root: Path):
+    proc = subprocess.run(
+        [sys.executable, str(CHECKER), "--root", str(root)],
+        capture_output=True, text=True,
+    )
+    return proc.returncode, proc.stderr
+
+
+def _run(root: Path) -> int:
+    return _run2(root)[0]
+
+
+def _mirror(tmp_path: Path) -> Path:
+    root = tmp_path / "repo"
+    for rel in ALL_FILES:
+        dst = root / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(REPO_ROOT / rel, dst)
+    return root
+
+
+def _edit(root: Path, rel: str, transform) -> None:
+    p = root / rel
+    p.write_text(transform(p.read_text(encoding="utf-8")), encoding="utf-8")
+
+
+# --- positive control ---------------------------------------------------------
+
+def test_unmutated_tree_passes(tmp_path):
+    root = _mirror(tmp_path)
+    code, err = _run2(root)
+    assert code == 0, f"baseline tree should PASS, stderr:\n{err}"
+
+
+def test_b1_band_anchor_mutation_fails(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(
+        root, SCORING_AGENTS[0],
+        lambda text: text.replace(
+            "if a defect needs sibling findings to reach rejection-level "
+            "impact, it is not Critical alone.",
+            "clusters may promote each member to Critical.",
+            1,
+        ),
+    )
+    code, err = _run2(root)
+    assert code == 1
+    assert "B1 band anchors missing" in err
+
+
+def test_template_b1_anti_bundling_mutation_fails(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(
+        root, TEMPLATE_REL,
+        lambda text: text.replace(
+            "A finding never inherits a higher band from siblings",
+            "A finding may inherit a higher band from siblings",
+            1,
+        ),
+    )
+    code, err = _run2(root)
+    assert code == 1
+    assert "expanded B1" in err
+
+
+# --- A1: quotas + receipt + contract block --------------------------------------
+
+def test_m1_quota_restored_in_agent(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n", "### Weaknesses (3-5 items)\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m2_finding_contract_body_gutted(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("Do not manufacture findings to fill a quota; do not "
+                              "omit real ones to seem agreeable.",
+                              "Use your judgment."))
+    code, err = _run2(root)
+    assert code == 1
+    assert "Finding Contract body missing" in err
+
+
+def test_m3_weakness_field_line_dropped(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[2],
+          lambda t: t.replace(
+              "   - **Severity**: [Critical / Major / Minor] | **Evidence Anchor**: "
+              "[`<type>: <locator>`] | **Confidence**: [1-5 — competence basis]\n", ""))
+    code, err = _run2(root)
+    assert code == 1
+    assert "per-weakness field line" in err
+
+
+def test_m4_coverage_receipt_skeleton_dropped(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[3],
+          lambda t: t.replace(
+              "### Coverage Receipt (only when Strengths or Weaknesses is empty)",
+              "### Notes"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "coverage-receipt skeleton" in err
+
+
+def test_m5_every_scoring_agent_is_pinned(tmp_path):
+    """Gutting the Finding Contract heading in EACH scoring agent individually
+    must fail."""
+    for rel in SCORING_AGENTS:
+        root = _mirror(tmp_path / rel.replace("/", "_"))
+        _edit(root, rel,
+              lambda t: t.replace("**Finding Contract (#574 A1/A2/A3)** — governs",
+                                  "**Notes** — governs"))
+        assert _run(root) == 1, f"removing Finding Contract heading in {rel} must fail"
+
+
+def test_m6_template_quota_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, TEMPLATE_REL,
+          lambda t: t.replace("List every weakness you actually found",
+                              "List 3-5 weaknesses of the paper. List every weakness you actually found"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m7_template_receipt_section_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, TEMPLATE_REL,
+          lambda t: t.replace("## Coverage Receipt (conditional *)", "## Extra Notes"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "coverage-receipt section" in err
+
+
+# --- A2: anchor vocabulary -------------------------------------------------------
+
+def test_m8_template_absence_row_removed(tmp_path):
+    root = _mirror(tmp_path)
+    def drop_absence_row(t: str) -> str:
+        return "\n".join(l for l in t.splitlines() if not l.startswith("| `absence` |")) + "\n"
+    _edit(root, TEMPLATE_REL, drop_absence_row)
+    code, err = _run2(root)
+    assert code == 1
+    assert "anchor vocabulary missing type row" in err
+
+
+def test_m9_template_must_anchor_weakened(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, TEMPLATE_REL,
+          lambda t: t.replace("**Critical/Major findings MUST carry an adequate anchor",
+                              "**Critical/Major findings should carry an anchor"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "MUST-anchor rule" in err
+
+
+def test_m10_da_table_loses_anchor_column(tmp_path):
+    root = _mirror(tmp_path)
+    def strip_critical_anchor_col(t: str) -> str:
+        return t.replace(
+            "| # | Dimension | Issue Description | Evidence Anchor | Confidence | "
+            "Field-Norm Boundary | Evidence-Crossing Rationale |",
+            "| # | Dimension | Issue Description | Location | "
+            "Field-Norm Boundary | Evidence-Crossing Rationale |", 1)
+    _edit(root, DA_REL, strip_critical_anchor_col)
+    code, err = _run2(root)
+    assert code == 1
+    assert "CRITICAL table: missing column" in err
+
+
+# --- A3: severity single source + transport ---------------------------------------
+
+def test_m11_schema6_canonical_sentence_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCHEMAS_REL,
+          lambda t: t.replace("the CANONICAL single source for finding severity "
+                              "across the reviewer stack (#574 A3)",
+                              "a severity value"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "canonical-severity sentence" in err
+
+
+def test_m12_synth_severity_fallback_tag_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace("[SEVERITY-SOURCE: letter-fallback]", "a note"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "severity fallback tag" in err
+
+
+def test_m13_da_band_consistency_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("the same defect class with the same decision impact "
+                              "lands in the same band every time",
+                              "severity is a judgment call"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "band-consistency" in err
+
+
+def test_m14_standards_severity_column_restored(tmp_path):
+    """Re-adding a Severity column to the cross-dimension table recreates the
+    second severity-assignment path — must fail."""
+    root = _mirror(tmp_path)
+    _edit(root, STANDARDS_REL,
+          lambda t: t.replace("| Situation | Decision impact |",
+                              "| Situation | Severity | Decision impact |"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("severity-assignment column regression" in err
+            or "decision-impact table header" in err)
+
+
+# --- B1: base rates + symmetry ------------------------------------------------------
+
+def test_m15_synth_base_rate_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace(
+              "Granted whenever the criteria are met — the decision follows the "
+              "evidence against `references/editorial_decision_standards.md`, never "
+              "a base rate or target distribution (#574 B1)",
+              "Rare — most papers don't pass on the first round"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "B1 accept rule" in err or "base-rate anchor regression" in err
+
+
+def test_m16_standards_b1_principle_gutted(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, STANDARDS_REL,
+          lambda t: t.replace("**Register is independent of severity.**",
+                              "Politeness matters."))
+    code, err = _run2(root)
+    assert code == 1
+    assert "B1 principle" in err
+
+
+def test_m17_standards_base_rate_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, STANDARDS_REL,
+          lambda t: t.replace("the decision follows the criteria, never a frequency "
+                              "expectation (#574 B1: no base-rate anchoring, "
+                              "qualitative or numeric)",
+                              "rare (< 5% of submissions at top-tier journals)"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("base-rate anchor regression" in err
+            or "frequency-free first-pass acceptance" in err)
+
+
+def test_m18_eic_acceptance_rate_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace(
+              "never from acceptance-rate base rates",
+              "based on journal tier (Q1 journal acceptance rate ~10-15%)"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "venue-criteria rule" in err or "acceptance-rate anchor regression" in err
+
+
+def test_m21_schema6_anchor_enum_renamed(tmp_path):
+    """Renaming one anchor_type enum value in Schema 6 desyncs the machine-facing
+    contract from the template vocabulary — must fail."""
+    root = _mirror(tmp_path)
+    _edit(root, SCHEMAS_REL, lambda t: t.replace('"dataset"', '"data"'))
+    code, err = _run2(root)
+    assert code == 1
+    assert "anchor_type enum" in err
+
+
+def test_m22_da_anchor_list_partially_edited(tmp_path):
+    """Dropping one type from ONE of the DA's two six-type spellings (footnote vs
+    discipline rule) must fail — both copies are pinned to ANCHOR_TYPES."""
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("`text` / `table` / `figure` / `equation` / `dataset` / `absence`",
+                              "`text` / `table` / `figure` / `equation` / `dataset`", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "six-type anchor vocabulary" in err
+
+
+def test_m23_schema6_confidence_row_deleted(tmp_path):
+    """Deleting the Schema 6 confidence row must fail — the A3 transport
+    contract's machine-facing field (codex round-1 P1: it was unpinned)."""
+    root = _mirror(tmp_path)
+    def drop_row(t: str) -> str:
+        return "\n".join(l for l in t.splitlines()
+                         if not l.startswith("| `confidence` | integer |")) + "\n"
+    _edit(root, SCHEMAS_REL, drop_row)
+    code, err = _run2(root)
+    assert code == 1
+    assert "Schema 6 weakness field row" in err
+
+
+def test_m24_da_minor_header_renamed(tmp_path):
+    """Renaming the MINOR table's Evidence Anchor column must fail even though
+    the shared footnote below still mentions 'Evidence Anchor' (codex round-1
+    P2: subsection-wide search was masked by the footnote)."""
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("| # | Dimension | Issue Description | Evidence Anchor | Confidence |\n"
+                              "|---|-----------|-------------------|-----------------|------------|",
+                              "| # | Dimension | Issue Description | Location | Confidence |\n"
+                              "|---|-----------|-------------------|----------|------------|"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "MINOR table: missing column" in err
+
+
+def test_m25_reworded_quota_caught(tmp_path):
+    """A quota re-introduced in different words than the retired literals must
+    still fail (codex round-1 P2: literal-only patterns were fail-open)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nYou must include at least 3 weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m26_skill_fake_diversity_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SKILL_REL,
+          lambda t: t.replace("**Overlap suppression**", "**Duplicate criticisms across reviewers**")
+                     .replace("unexecutable under blindness (Iron Rule #2) and destroys the corroboration signal",
+                              "R1/R2/R3 raise identical points = fake diversity"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("overlap-prohibition regression" in err
+            or "overlap-suppression anti-pattern row" in err)
+
+
+def test_m27_synth_mandatory_merit_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace("Point out genuine merits where the reviewer cards found them — "
+                              "never manufacture praise to soften a Reject (#574 A1/B1)",
+                              "Point out the paper's merits (they always exist)"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("mandatory-merit regression" in err or "genuine-merits rule" in err)
+
+
+def test_m28_da_critical_band_reverted(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("Fatal flaw in core argument or methodology that blocks acceptance "
+                              "until fixed — the same decision-impact bar as the canonical Critical "
+                              "(template § Severity Levels); state explicitly when you judge it "
+                              "unfixable by revision",
+                              "Fatal flaw in core argument or methodology that cannot be rescued by revision"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("DA CRITICAL decision-impact definition" in err
+            or "unfixable-only definition" in err)
+
+
+def test_m30_contract_relocated_outside_phase2(tmp_path):
+    """Contract kept verbatim but moved out of the delivered Phase 2 subsection
+    (appended at end of file) — sprint calls would never receive it (codex
+    round-2 P1). Must fail."""
+    root = _mirror(tmp_path)
+    rel = SCORING_AGENTS[0]
+    def relocate(t: str) -> str:
+        start = t.index("**Finding Contract (#574 A1/A2/A3)**")
+        end = t.index("  - **Confidence**: 1-5 plus a one-phrase competence basis.", start)
+        end = t.index("\n", end) + 1
+        block = t[start:end]
+        return t.replace(block, "") + "\n---\n\n" + block
+    _edit(root, rel, relocate)
+    code, err = _run2(root)
+    assert code == 1
+    assert "OUTSIDE the delivered Phase 2" in err
+
+
+def test_m31_minimum_of_quota_caught(tmp_path):
+    """'a minimum of 3 weaknesses' — the round-2 fail-open rewording — must fail."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[2],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nYou must include a minimum of 3 weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m32_da_header_superset_rename(tmp_path):
+    """Renaming CRITICAL columns to supersets ('Evidence Anchor Note') defeats
+    substring membership — exact cell compare must fail it (round-2 P2)."""
+    root = _mirror(tmp_path)
+    def rename(t: str) -> str:
+        idx = t.index("#### CRITICAL")
+        head, tail = t[:idx], t[idx:]
+        tail = tail.replace("| Evidence Anchor | Confidence |",
+                            "| Evidence Anchor Note | Confidence Basis |", 1)
+        return head + tail
+    _edit(root, DA_REL, rename)
+    code, err = _run2(root)
+    assert code == 1
+    assert "CRITICAL table: missing column" in err
+
+
+def test_m33_synth_split_prior_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace(
+              "the divergence is signal about a genuinely weak dimension — decide "
+              "from the criteria against that dimension (commonly Major Revision, "
+              "because a real weak dimension needs fixing), never from a strictness "
+              "prior (#574 B1)",
+              "lean toward Major Revision"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("directional split prior regression" in err
+            or "divergence-weighting edge case" in err)
+
+
+def test_m34_decision_template_conservative_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, DECISION_TEMPLATE_REL,
+          lambda t: t.replace("unresolved-dissent principle (#574 B1)", "conservative principle"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("asymmetric arbitration regression" in err
+            or "arbitration rationale vocabulary" in err)
+
+
+def test_m35_guided_mandatory_opener_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, GUIDED_REL,
+          lambda t: t.replace(
+              "First acknowledges the paper's genuine core strengths (1-2, when "
+              "they exist — never manufactured praise, #574 A1/B1)",
+              "First points out 1-2 core strengths of the paper (building confidence)"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("mandatory-strength opener regression" in err
+            or "guided-mode conditional-strengths opener" in err)
+
+
+def test_m36_rqt_minimum_strength_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, RQT_REL,
+          lambda t: t.replace(
+              "Did I acknowledge every genuine strength I found — and manufacture "
+              "none? (Evidence-driven balance check, #574 A1/B1)",
+              "Did I identify at least one genuine strength? (Balance check)"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("minimum-strength check regression" in err
+            or "review-quality balance check" in err)
+
+
+def test_m37_domain_advisory_disposition_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, DOMAIN_REL,
+          lambda t: t.replace(
+              "down-rate the finding's severity to **Minor** — the canonical enum "
+              "has no off-enum \"advisory\" tier (#574 A3) — and label it",
+              "down-rate the finding to advisory and label it"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("off-enum severity disposition regression" in err
+            or "field-norm enum disposition" in err)
+
+
+def test_m38_strength_anchor_bullet_gutted(tmp_path):
+    """Removing the strengths-anchor bullet from the delivered contract lets
+    sprint reviews emit unanchored positive findings (round-3 P1)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("- Every strength carries a typed Evidence Anchor too "
+                              "(the same six-type vocabulary; a section-level locator "
+                              "suffices for a strength, and a `text` anchor still "
+                              "carries its short verbatim quote — the Schema 6 "
+                              "conditional member applies to both polarities) — A2's "
+                              "every-finding rule covers strengths and weaknesses "
+                              "alike.\n", ""))
+    code, err = _run2(root)
+    assert code == 1
+    assert "Finding Contract body missing" in err
+
+
+def test_m39_response_template_bounded_again(tmp_path):
+    """Restoring the W1-W5 bound in the response template can drop W6+ author
+    responses (round-3 P1)."""
+    root = _mirror(tmp_path)
+    _edit(root, RESPONSE_TEMPLATE_REL,
+          lambda t: t.replace("W1..Wn (every emitted weakness, unbounded — #574 A1)",
+                              "W1-W5"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("bounded W-range mirror regression" in err
+            or "unbounded W1..Wn witness" in err)
+
+
+def test_m40_three_to_five_quota_caught(tmp_path):
+    """'three to five weaknesses' — a worded range quota — must fail (round-3 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[3],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nProvide three to five weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m41_plus_form_quota_caught(tmp_path):
+    """'3+ weaknesses' must fail (round-3 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nAim for 3+ weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m42_da_decoy_table_before_output_format(tmp_path):
+    """A correctly-shaped decoy CRITICAL table BEFORE ## Output Format must not
+    satisfy the column check when the real table loses its columns (round-3 P2)."""
+    root = _mirror(tmp_path)
+    def decoy(t: str) -> str:
+        decoy_block = ("\n#### CRITICAL\n"
+                       "| # | Dimension | Issue Description | Evidence Anchor | Confidence | Field-Norm Boundary | Evidence-Crossing Rationale |\n"
+                       "|---|-----------|-------------------|-----------------|------------|---------------------|-----------------------------|\n\n")
+        t = t.replace("## Severity Classification", decoy_block + "## Severity Classification", 1)
+        idx = t.index("## Output Format")
+        head, tail = t[:idx], t[idx:]
+        tail = tail.replace("| Evidence Anchor | Confidence |", "| Location | Notes |", 1)
+        return head + tail
+    _edit(root, DA_REL, decoy)
+    code, err = _run2(root)
+    assert code == 1
+    assert "CRITICAL table: missing column" in err
+
+
+def test_m43_perspective_assumption_quota_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[3],
+          lambda t: t.replace(
+              "Assumption audit was actually performed; implicit assumptions "
+              "identified where they exist (an all-explicit paper legitimately "
+              "yields none — do not manufacture one, #574 A1)",
+              "Assumption audit has identified at least 1 implicit assumption"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("assumption-audit quota regression" in err
+            or "conditional assumption-audit gate" in err)
+
+
+def test_m44_rqt_base_rate_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, RQT_REL,
+          lambda t: t.replace(
+              "Check the manuscript's claimed scope of generalization against its "
+              "sampling frame — a criterion-only comparison, never an "
+              "author-population base rate (#574 B1).",
+              "Most authors overstate generalizability."))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("author-population base-rate regression" in err
+            or "criterion-only generalizability heuristic" in err)
+
+
+def test_m45_da_concession_bridge_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("a dispositive score-5 rebuttal always prevails "
+                              "regardless of sequence", "the ladder applies"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "concession-ladder B1 bridge" in err
+
+
+def test_m46_noun_first_quota_caught(tmp_path):
+    """'### Weaknesses (at least 3)' — noun-first heading quota — must fail
+    (round-4 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n", "### Weaknesses (at least 3)\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m47_single_mirror_rebounded(tmp_path):
+    """Rebounding ONLY the R3 mirror (W1–W4, en dash) must fail even though R2
+    keeps the unbounded witness (round-4 P2)."""
+    root = _mirror(tmp_path)
+    def rebound_r3(t: str) -> str:
+        idx = t.index("## Response to Reviewer 3")
+        head, tail = t[:idx], t[idx:]
+        tail = tail.replace("W1..Wn (every emitted weakness, unbounded — #574 A1)",
+                            "W1–W4", 1)
+        return head + tail
+    _edit(root, RESPONSE_TEMPLATE_REL, rebound_r3)
+    code, err = _run2(root)
+    assert code == 1
+    assert ("unbounded W1..Wn witness" in err or "bounded W-range mirror regression" in err)
+
+
+def test_m48_stats_triage_note_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, STATS_REL,
+          lambda t: t.replace("**Triage levels, not finding severities (#574 A3).**",
+                              "**Severity legend.**"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "red-flag triage note" in err
+
+
+def test_m49_synth_lone_major_escalation_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace(
+              "Conditions: a validated — or genuinely unresolved — Major issue "
+              "exists, or multiple Minor items accumulate to Major. A lone Major "
+              "recommendation goes through arbitration FIRST (One-Outlier "
+              "handling, `references/editorial_decision_standards.md`): an "
+              "outlier whose rationale arbitration finds insufficient does not "
+              "escalate the decision by itself (#574 B1)",
+              "Conditions: Any reviewer recommends Major Revision, or multiple "
+              "Minor items accumulate to Major"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("lone-Major arbitration rule" in err
+            or "unconditional lone-Major escalation regression" in err)
+
+
+def test_m50_rcf_affirm_first_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, RCF_REL,
+          lambda t: t.replace("Acknowledge genuine strengths, distinguish decision-bearing "
+                              "findings from copyediting, and avoid finding quotas.",
+                              "List weaknesses only."))
+    code, err = _run2(root)
+    assert code == 1
+    assert "conditional hypercriticism guidance" in err
+
+
+def test_m51_schema6_strengths_destructured(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SCHEMAS_REL,
+          lambda t: t.replace("Strength objects `{description: string, "
+                              "evidence_anchor: object}`",
+                              "bare strings"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "structured strengths" in err
+
+
+def test_m52_direct_count_quota_caught(tmp_path):
+    """'List 3 weaknesses' — an imperative direct count — must fail (round-5 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("### Weaknesses\n", "### Weaknesses\nList 3 weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m53_maximum_quota_caught(tmp_path):
+    """'no more than 5 findings' — an upper bound — must fail (round-5 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nReport no more than 5 findings.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m54_mirror_duplicated_and_deleted(tmp_path):
+    """Duplicating the unbounded witness in R2 while deleting it from R3 keeps
+    the file-wide count at 2 — the per-mirror check must still fail (round-5 P2)."""
+    root = _mirror(tmp_path)
+    w = "W1..Wn (every emitted weakness, unbounded — #574 A1)"
+    def shuffle(t: str) -> str:
+        r3 = t.index("## Response to Reviewer 3")
+        head, tail = t[:r3], t[r3:]
+        head = head.replace(w, w + " / " + w, 1)   # R2 now carries it twice
+        tail = tail.replace(w, "all weaknesses", 1)  # R3 loses it
+        return head + tail
+    _edit(root, RESPONSE_TEMPLATE_REL, shuffle)
+    code, err = _run2(root)
+    assert code == 1
+    assert "exactly once" in err
+
+
+def test_m55_wide_bounded_range_caught(tmp_path):
+    """'W1-W10' (multi-digit endpoint) must fail (round-5 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, RESPONSE_TEMPLATE_REL,
+          lambda t: t.replace("W1..Wn (every emitted weakness, unbounded — #574 A1)",
+                              "W1-W10", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("bounded W-range mirror regression" in err or "exactly once" in err)
+
+
+def test_m56_schema6_row_migrated_to_schema7(tmp_path):
+    """Moving the confidence row OUT of Schema 6 (re-adding it under Schema 7)
+    keeps a file-wide search green — the Schema-6-scoped check must fail
+    (round-5 P2)."""
+    root = _mirror(tmp_path)
+    def migrate(t: str) -> str:
+        row = next(l for l in t.splitlines() if l.startswith("| `confidence` | integer |"))
+        t = t.replace(row + "\n", "")
+        return t.replace("## Schema 7: Revision Roadmap (reviewer -> academic-paper revision)",
+                         "## Schema 7: Revision Roadmap (reviewer -> academic-paper revision)\n\n" + row)
+    _edit(root, SCHEMAS_REL, migrate)
+    code, err = _run2(root)
+    assert code == 1
+    assert "Schema 6 weakness field row" in err
+
+
+def test_m57_up_to_maximum_quota_caught(tmp_path):
+    """'Report up to five findings' — an accidental maximum — must fail
+    (round-6 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[2],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nReport up to five findings.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m58_legit_question_count_does_not_false_fire(tmp_path):
+    """'### Questions (2-4 items)' is a NON-finding count and must PASS —
+    the lint must not block legitimate prompt edits (round-6 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("### Questions for Authors\n",
+                              "### Questions for Authors (2-4 items)\n", 1))
+    code, err = _run2(root)
+    assert code == 0, f"legitimate question count false-fired:\n{err}"
+
+
+def test_m59_legit_between_prose_does_not_false_fire(tmp_path):
+    """'Distinguish between major and minor issues' is ordinary prose and must
+    PASS (round-6 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nDistinguish between major and minor issues.\n", 1))
+    code, err = _run2(root)
+    assert code == 0, f"legitimate prose false-fired:\n{err}"
+
+
+def test_m60_subclaim_severity_inheritance_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace("All sub-claims decomposed from one parent share "
+                              "the parent's transported severity",
+                              "Sub-claims may be re-rated individually"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "sub-claim severity inheritance" in err
+
+
+def test_m61_cross_model_da_quota_restored(tmp_path):
+    """Restoring 'Find the 3 most serious weaknesses' in the cross-model DA
+    prompt must fail (round-7 P1)."""
+    root = _mirror(tmp_path)
+    _edit(root, XM_REL,
+          lambda t: t.replace(
+              "Find the most serious weaknesses — every one the evidence supports,\n"
+              "   ranked most severe first; no fixed count, and do not pad to reach one\n"
+              "   (#574 A1).",
+              "Find the 3 most serious weaknesses."))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("cross-model DA fixed-count regression" in err
+            or "cross-model DA no-quota prompt" in err)
+
+
+def test_m62_synth_roadmap_severity_column_dropped(tmp_path):
+    """Dropping the Severity column from a roadmap table lets transported
+    metadata die in the working inventory (round-7 P1)."""
+    root = _mirror(tmp_path)
+    _edit(root, SYNTH_REL,
+          lambda t: t.replace(
+              "| Transport ref | Revision Item | Sub-Claim(s) | Severity | Evidence Anchor | Confidence | Source | Obligation class | Cost scope | Bounded consequence |",
+              "| Transport ref | Revision Item | Sub-Claim(s) | Source | Obligation class | Cost scope | Bounded consequence |", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "transported-metadata columns" in err
+
+
+def test_m63_skill_unconditional_veto_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SKILL_REL,
+              lambda t: t.replace(
+                  "Every Devil's Advocate CRITICAL issue is adjudicated visibly in the "
+                  "Editorial Decision — a validated or genuinely unresolved one blocks "
+                  "silent Accept finalization; under a sprint contract the mechanical "
+                  "Accept remains unchanged and `[DA-CRITICAL-VS-ACCEPT: <n> "
+                  "validated/unresolved]` escalates to the user. One the Journal-Fit Reviewer adjudicates "
+                  "and rejects is recorded with its "
+                  "rejection rationale and does not veto by itself (#574 B1: an "
+                  "unvalidated negative claim carries the same evidence burden as a "
+                  "positive one). Silently bypassing a DA CRITICAL is never allowed.",
+              "If the Devil's Advocate finds CRITICAL issues, the Editorial "
+              "Decision cannot be Accept."))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("unconditional DA-CRITICAL veto regression" in err
+            or "adjudication wording missing" in err)
+
+
+def test_m64_da_delivered_contract_weakened(tmp_path):
+    """Weakening the DA's delivered contract modality (require → may use) must
+    fail even though stronger rules survive in undelivered sections (round-7 P1)."""
+    root = _mirror(tmp_path)
+    _edit(root, DA_REL,
+          lambda t: t.replace("CRITICAL/MAJOR require an adequate, applicable one",
+                              "CRITICAL/MAJOR may use one", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "does not match the canonical verbatim block" in err
+
+
+def test_m65_modifier_quota_caught(tmp_path):
+    """'Identify 3 major issues' — count + modifier + noun — must fail (round-7 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[3],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nIdentify 3 major issues.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m66_scoring_points_do_not_false_fire(tmp_path):
+    """'Award at most 5 points for clarity' is scoring language, not a finding
+    quota — must PASS (round-7 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nAward at most 5 points for clarity.\n", 1))
+    code, err = _run2(root)
+    assert code == 0, f"scoring points false-fired:\n{err}"
+
+
+def test_m67_limit_cap_quota_caught(tmp_path):
+    """'Limit findings to five' / 'Cap weaknesses at 5' must fail (round-8 P2)."""
+    for phrase in ("Limit findings to five.", "Cap weaknesses at 5."):
+        root = _mirror(tmp_path / phrase[:4].strip().lower())
+        _edit(root, SCORING_AGENTS[1],
+              lambda t, ph=phrase: t.replace("### Weaknesses\n", f"### Weaknesses\n{ph}\n", 1))
+        code, err = _run2(root)
+        assert code == 1, f"{phrase!r} passed the lint"
+        assert "finding-quota regression" in err
+
+
+def test_m68_schema7_severity_field_deleted(tmp_path):
+    """Deleting the Schema 7 RoadmapItem severity row breaks the machine
+    handoff of transported metadata (round-8 P1)."""
+    root = _mirror(tmp_path)
+    def drop(t: str) -> str:
+        return "\n".join(l for l in t.splitlines()
+                         if "Transported Schema 6 finding severity" not in l) + "\n"
+    _edit(root, SCHEMAS_REL, drop)
+    code, err = _run2(root)
+    assert code == 1
+    assert "Schema 7 RoadmapItem transported-field row" in err
+
+
+def test_m69_template_suggested_columns_dropped(tmp_path):
+    """The decision template's Suggested table losing its transported columns
+    must fail (round-8 P1: the template mirror, not only the synthesizer)."""
+    root = _mirror(tmp_path)
+    _edit(root, DECISION_TEMPLATE_REL,
+          lambda t: t.replace(
+              "| Transport ref | Revision Item | Sub-Claim(s) | Severity | Evidence Anchor | Confidence | Source Reviewer | Obligation class | Cost scope | Bounded consequence |",
+              "| Transport ref | Revision Item | Sub-Claim(s) | Source Reviewer | Obligation class | Cost scope | Bounded consequence |"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "transported-metadata columns" in err
+
+
+def test_m70_standards_qualitative_base_rate_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, STANDARDS_REL,
+          lambda t: t.replace("never a frequency expectation",
+                              "uncommon in practice, but judged on the criteria"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("qualitative base-rate cue regression" in err
+            or "frequency-free first-pass acceptance" in err)
+
+
+def test_m71_schema7_anchor_row_deleted(tmp_path):
+    """Deleting the Schema 7 evidence_anchor row must fail — round-9 P1: a
+    severity-only witness left the other transported fields deletable."""
+    root = _mirror(tmp_path)
+    def drop(t: str) -> str:
+        keep = []
+        in_s7 = False
+        for l in t.splitlines():
+            if l.startswith("## Schema 7:"):
+                in_s7 = True
+            elif l.startswith("## Schema 8:"):
+                in_s7 = False
+            if in_s7 and l.startswith("| `evidence_anchor` | object |"):
+                continue
+            keep.append(l)
+        return "\n".join(keep) + "\n"
+    _edit(root, SCHEMAS_REL, drop)
+    code, err = _run2(root)
+    assert code == 1
+    assert "Schema 7 RoadmapItem transported-field row" in err
+
+
+def test_m72_xm_prompt_quota_added(tmp_path):
+    """A quota added to the cross-model DA prompt while the canonical
+    no-fixed-count sentence survives must fail (round-9 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, XM_REL,
+          lambda t: t.replace("   - What the weakness is",
+                              "   Report up to five findings.\n   - What the weakness is", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression in the cross-model DA prompt" in err
+
+
+def test_m73_between_range_with_modifier_caught(tmp_path):
+    """'Provide between three and five major weaknesses' must fail (round-9 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[0],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nProvide between three and five major weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m74_da_minor_confidence_dropped(tmp_path):
+    """The DA MINOR table losing its Confidence column must fail (round-9 P2:
+    a MINOR issue that becomes a Suggested Revision transports confidence)."""
+    root = _mirror(tmp_path)
+    def strip(t: str) -> str:
+        return t.replace("| # | Dimension | Issue Description | Evidence Anchor | Confidence |\n"
+                         "|---|-----------|-------------------|-----------------|------------|",
+                         "| # | Dimension | Issue Description | Evidence Anchor |\n"
+                         "|---|-----------|-------------------|-----------------|", 1)
+    _edit(root, DA_REL, strip)
+    code, err = _run2(root)
+    assert code == 1
+    assert "MINOR table: missing column" in err
+
+
+def test_m75_top_n_quota_caught(tmp_path):
+    """'Report the top 3 weaknesses' — a fixed selection count — must fail
+    (round-10 P2: the exact retired cross-model wording class, now caught on
+    every scanned surface)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[2],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nReport the top 3 weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m76_field_analyst_register_softening_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, FIELD_ANALYST_REL,
+          lambda t: t.replace(
+              '- Suggest reviewers adopt "developmental feedback" as the REGISTER — '
+              "the recommendation itself stays evidence-based against the criteria "
+              "(#574 B1: tone changes wording, never the verdict)",
+              '- Suggest reviewers adopt "developmental feedback" as the main '
+              'approach, rather than strict "accept/reject" judgment'))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("register-softens-verdict regression" in err
+            or "developmental-register rule" in err)
+
+
+def test_m77_schema7_semantics_rewritten(tmp_path):
+    """Rewriting a Schema 7 field's transport semantics (keeping the row) must
+    fail — row existence alone was fail-open (round-10 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCHEMAS_REL,
+          lambda t: t.replace("Fallback provenance for `confidence` — the verbatim tag",
+                              "A synthesizer-generated confidence estimate"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "Schema 7 RoadmapItem transported-field row" in err
+
+
+def test_m78_selection_verb_quota_caught(tmp_path):
+    """'Select three weaknesses' — a selection-verb direct count — must fail
+    (round-11 P2)."""
+    root = _mirror(tmp_path)
+    _edit(root, SCORING_AGENTS[1],
+          lambda t: t.replace("### Weaknesses\n",
+                              "### Weaknesses\nSelect three weaknesses.\n", 1))
+    code, err = _run2(root)
+    assert code == 1
+    assert "finding-quota regression" in err
+
+
+def test_m29_calibration_bridge_removed(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, CALIBRATION_REL,
+          lambda t: t.replace("External studies can motivate hypotheses about leniency or harshness",
+                              "External studies set the decision prior")
+                     .replace("must not be imported as correction factors, thresholds, or target-profile measurements",
+                              "may be imported as a threshold"))
+    code, err = _run2(root)
+    assert code == 1
+    assert "external-evidence scope note" in err
+
+
+# --- P0-3 residue ---------------------------------------------------------------------
+
+def test_m19_skill_overlap_prohibition_restored(tmp_path):
+    root = _mirror(tmp_path)
+    _edit(root, SKILL_REL,
+          lambda t: t.replace("overlapping findings may corroborate one another, but role/persona separation is not evidence of independent errors",
+                              "no duplicate criticisms"))
+    code, err = _run2(root)
+    assert code == 1
+    assert ("overlap-corroboration standard" in err
+            or "overlap-prohibition regression" in err)
+
+
+# --- invocation error --------------------------------------------------------------
+
+def test_m20_missing_file_exits_2(tmp_path):
+    root = _mirror(tmp_path)
+    (root / SCHEMAS_REL).unlink()
+    assert _run(root) == 2
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-v"]))