psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/test_check_v3_8_annotation_literal_sync.py

@@ -0,0 +1,262 @@
+"""Unit tests for v3.8 annotation-literal sync lint.
+
+The lint enforces that every `ANNOTATION_HIGH_WARN_*` constant in
+`scripts/claim_audit_finalizer.py` has a matching bracket-prefix in
+`academic-paper/agents/formatter_agent.md` REFUSE list. The tests cover:
+
+1. The prefix-extraction helper handles the three annotation literal
+   shapes correctly (plain closed, parenthesized variable, em-dash
+   contextual suffix).
+2. The lint reports PASS on the current repo state.
+3. The lint reports FAIL when a deliberately mutated finalizer module
+   adds an extra HIGH-WARN constant that the formatter doesn't carry.
+
+Run:
+    python -m unittest scripts.test_check_v3_8_annotation_literal_sync -v
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+import textwrap
+import unittest
+from pathlib import Path
+
+from scripts.check_v3_8_annotation_literal_sync import (
+    _annotation_prefix,
+    _extract_refuse_block,
+)
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+LINT_SCRIPT = REPO_ROOT / "scripts" / "check_v3_8_annotation_literal_sync.py"
+
+
+class AnnotationPrefixHelperTest(unittest.TestCase):
+    def test_plain_closed_literal_keeps_closing_bracket(self) -> None:
+        # Step 8 codex R2 P2-1 closure: closed literals require exact match
+        # INCLUDING the closing bracket. Cutting at `]` left the prefix without
+        # the bracket, so a renamed formatter rule
+        # `[HIGH-WARN-FABRICATED-REFERENCE-RENAMED]` would still satisfy the
+        # check for finalizer literal `[HIGH-WARN-FABRICATED-REFERENCE]`.
+        self.assertEqual(
+            _annotation_prefix("[HIGH-WARN-CLAIM-NOT-SUPPORTED]"),
+            "[HIGH-WARN-CLAIM-NOT-SUPPORTED]",
+        )
+
+    def test_interpolated_parenthesized_variable_cuts_at_space_paren(self) -> None:
+        self.assertEqual(
+            _annotation_prefix(
+                "[HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION ({violated_constraint_id})]"
+            ),
+            "[HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION",
+        )
+
+    def test_em_dash_contextual_suffix_cuts_at_space_emdash(self) -> None:
+        self.assertEqual(
+            _annotation_prefix(
+                "[HIGH-WARN-CLAIM-AUDIT-ANCHORLESS — v3.7.3 R-L3-1-A VIOLATION REACHED AUDIT]"
+            ),
+            "[HIGH-WARN-CLAIM-AUDIT-ANCHORLESS",
+        )
+
+    def test_interpolated_uncited_constraint_violation_prefix(self) -> None:
+        self.assertEqual(
+            _annotation_prefix(
+                "[HIGH-WARN-CONSTRAINT-VIOLATION-UNCITED ({violated_constraint_id})]"
+            ),
+            "[HIGH-WARN-CONSTRAINT-VIOLATION-UNCITED",
+        )
+
+    def test_fabricated_reference_plain_literal(self) -> None:
+        # Closed plain literal keeps the closing bracket for exact match
+        # (Step 8 codex R2 P2-1 closure).
+        self.assertEqual(
+            _annotation_prefix("[HIGH-WARN-FABRICATED-REFERENCE]"),
+            "[HIGH-WARN-FABRICATED-REFERENCE]",
+        )
+
+
+class RefuseBlockExtractorTest(unittest.TestCase):
+    """Step 8 codex R1 P3 closure: lint scope restricted to REFUSE-rules block."""
+
+    def test_extracts_block_starting_at_refuse_marker(self) -> None:
+        sample = textwrap.dedent(
+            """\
+            ## Cite-Time Provenance Hard Gate
+
+            Some intro prose mentioning HIGH-WARN-CLAIM-NOT-SUPPORTED here.
+
+            **REFUSE to emit final output** when the draft contains any of:
+
+            1. Rule one.
+            6. A literal `[HIGH-WARN-CLAIM-NOT-SUPPORTED]` annotation.
+
+            ## Output Format
+
+            Mentions HIGH-WARN-CLAIM-NOT-SUPPORTED outside the REFUSE block.
+            """
+        )
+        block = _extract_refuse_block(sample)
+        self.assertIsNotNone(block)
+        self.assertIn("[HIGH-WARN-CLAIM-NOT-SUPPORTED]", block)
+        # The intro mention before the REFUSE marker MUST be excluded.
+        self.assertNotIn(
+            "Some intro prose mentioning HIGH-WARN-CLAIM-NOT-SUPPORTED here.", block
+        )
+        # The Output Format mention after the next H2 MUST be excluded.
+        self.assertNotIn(
+            "Mentions HIGH-WARN-CLAIM-NOT-SUPPORTED outside the REFUSE block.", block
+        )
+
+    def test_returns_none_when_refuse_marker_absent(self) -> None:
+        sample = "## Some heading\n\nNo REFUSE-list marker anywhere.\n"
+        self.assertIsNone(_extract_refuse_block(sample))
+
+
+class LintScriptTest(unittest.TestCase):
+    def test_lint_passes_on_current_repo_state(self) -> None:
+        # The lint MUST pass on the shipped repo — Step 8 commit cluster
+        # closed the §3.6 + REFUSE list rules 6-10. A failure here means a
+        # subsequent edit drifted the finalizer literals away from the
+        # formatter prose without updating both sides.
+        result = subprocess.run(
+            [sys.executable, str(LINT_SCRIPT)],
+            capture_output=True,
+            text=True,
+            cwd=str(REPO_ROOT),
+        )
+        self.assertEqual(
+            result.returncode,
+            0,
+            f"lint exited with code {result.returncode}; stdout={result.stdout!r}; "
+            f"stderr={result.stderr!r}",
+        )
+        self.assertIn("PASS", result.stdout)
+
+    def test_lint_detects_dynamic_literal_substring_match_attack(self) -> None:
+        # Step 8 codex R3 P2 closure: interpolated/em-dash literals MUST
+        # also require a boundary character following the token in formatter
+        # prose, not raw substring match. A rename that appends text
+        # (`[HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION-RENAMED`) would have
+        # passed the R1/R2 lint via prefix-substring containment.
+        import tempfile
+        import shutil
+
+        with tempfile.TemporaryDirectory() as td:
+            tmp_root = Path(td) / "repo"
+            shutil.copytree(REPO_ROOT, tmp_root, ignore=shutil.ignore_patterns(
+                ".git", "node_modules", "__pycache__", "*.pyc", "venv*", ".venv"
+            ))
+            tmp_formatter = tmp_root / "academic-paper" / "agents" / "formatter_agent.md"
+            text = tmp_formatter.read_text()
+            mutated = text.replace(
+                "`[HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION`",
+                "`[HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION-RENAMED`",
+            )
+            self.assertNotEqual(text, mutated, "mutation should replace the literal")
+            tmp_formatter.write_text(mutated)
+
+            result = subprocess.run(
+                [sys.executable, str(tmp_root / "scripts" / "check_v3_8_annotation_literal_sync.py")],
+                capture_output=True,
+                text=True,
+                cwd=str(tmp_root),
+            )
+            self.assertEqual(
+                result.returncode,
+                1,
+                f"expected lint to fail on dynamic-literal rename; "
+                f"stdout={result.stdout!r}",
+            )
+            self.assertIn(
+                "HIGH-WARN-NEGATIVE-CONSTRAINT-VIOLATION",
+                result.stdout,
+            )
+
+    def test_lint_detects_closed_literal_substring_match_attack(self) -> None:
+        # Step 8 codex R2 P2-1 closure: the lint MUST NOT pass when the
+        # formatter prose contains a SUPERSTRING of the finalizer literal
+        # (e.g. finalizer says `[HIGH-WARN-FABRICATED-REFERENCE]` but
+        # formatter REFUSE list was edited to `[HIGH-WARN-FABRICATED-
+        # REFERENCE-RENAMED]`). The closing bracket is the contract
+        # terminator for closed literals.
+        import tempfile
+        import shutil
+
+        with tempfile.TemporaryDirectory() as td:
+            tmp_root = Path(td) / "repo"
+            shutil.copytree(REPO_ROOT, tmp_root, ignore=shutil.ignore_patterns(
+                ".git", "node_modules", "__pycache__", "*.pyc", "venv*", ".venv"
+            ))
+            tmp_formatter = tmp_root / "academic-paper" / "agents" / "formatter_agent.md"
+            text = tmp_formatter.read_text()
+            # Replace the closed literal in the formatter REFUSE rule with a
+            # superstring that PRESERVES the original as a prefix. A naive
+            # `prefix in text` check would still pass; the exact-closing-
+            # bracket contract catches it.
+            mutated = text.replace(
+                "[HIGH-WARN-FABRICATED-REFERENCE]",
+                "[HIGH-WARN-FABRICATED-REFERENCE-RENAMED]",
+            )
+            self.assertNotEqual(text, mutated, "mutation should replace the literal")
+            tmp_formatter.write_text(mutated)
+
+            result = subprocess.run(
+                [sys.executable, str(tmp_root / "scripts" / "check_v3_8_annotation_literal_sync.py")],
+                capture_output=True,
+                text=True,
+                cwd=str(tmp_root),
+            )
+            self.assertEqual(
+                result.returncode,
+                1,
+                f"expected lint to fail on superstring formatter literal; "
+                f"stdout={result.stdout!r}",
+            )
+            self.assertIn("HIGH-WARN-FABRICATED-REFERENCE", result.stdout)
+
+    def test_lint_detects_renamed_constant_missing_from_formatter(self) -> None:
+        # Simulate the canonical drift scenario: the finalizer renames an
+        # existing HIGH-WARN constant's literal (e.g. CLAIM-NOT-SUPPORTED →
+        # CLAIM-UNSUPPORTED) without coordinating with the formatter prose.
+        # The lint MUST exit 1 and surface the renamed prefix as missing.
+        # Renaming (not adding) keeps the count at 5 so the constant-count
+        # gate doesn't fire first — the real failure mode is the literal-
+        # match gate, which is what we want this test to pin.
+        import tempfile
+        import shutil
+
+        with tempfile.TemporaryDirectory() as td:
+            tmp_root = Path(td) / "repo"
+            shutil.copytree(REPO_ROOT, tmp_root, ignore=shutil.ignore_patterns(
+                ".git", "node_modules", "__pycache__", "*.pyc", "venv*", ".venv"
+            ))
+            tmp_finalizer = tmp_root / "scripts" / "claim_audit_finalizer.py"
+            text = tmp_finalizer.read_text()
+            # Rename the CLAIM-NOT-SUPPORTED literal in place — the formatter
+            # prose still says NOT-SUPPORTED, so the lint must surface the
+            # divergence on the renamed literal.
+            mutated = text.replace(
+                'ANNOTATION_HIGH_WARN_CLAIM_NOT_SUPPORTED = "[HIGH-WARN-CLAIM-NOT-SUPPORTED]"',
+                'ANNOTATION_HIGH_WARN_CLAIM_NOT_SUPPORTED = "[HIGH-WARN-CLAIM-UNSUPPORTED-RENAMED]"',
+            )
+            self.assertNotEqual(text, mutated, "mutation should have replaced the literal")
+            tmp_finalizer.write_text(mutated)
+
+            result = subprocess.run(
+                [sys.executable, str(tmp_root / "scripts" / "check_v3_8_annotation_literal_sync.py")],
+                capture_output=True,
+                text=True,
+                cwd=str(tmp_root),
+            )
+            self.assertEqual(
+                result.returncode,
+                1,
+                f"expected lint to fail on mutated finalizer; stdout={result.stdout!r}",
+            )
+            self.assertIn("HIGH-WARN-CLAIM-UNSUPPORTED-RENAMED", result.stdout)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

package/vendor/ars/scripts/test_check_v3_9_0_triangulation.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Tests for check_v3_9_0_triangulation.py lint per spec v3.9.0 §3.8."""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+SCRIPT = Path(__file__).parent / "check_v3_9_0_triangulation.py"
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+
+def run_lint(args: list[str] | None = None) -> subprocess.CompletedProcess:
+    cmd = [sys.executable, str(SCRIPT)] + (args or [])
+    return subprocess.run(cmd, capture_output=True, text=True, cwd=str(REPO_ROOT))
+
+
+def test_lint_passes_on_clean_repo():
+    """The real repo carries all 13 allowlist entries (9 v3.9.0 + 4 Delta-1) and
+    lint passes."""
+    result = run_lint()
+    assert result.returncode == 0, f"Lint failed: stderr={result.stderr}\nstdout={result.stdout}"
+
+
+def test_lint_detects_missing_allowlist_entry(tmp_path):
+    """Remove CONTAMINATED-TRIANGULATION-UNMATCHED from formatter — lint fails."""
+    formatter = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+    content = formatter.read_text()
+    broken_content = content.replace(
+        "`CONTAMINATED-TRIANGULATION-UNMATCHED`, ",
+        "",
+    )
+    broken = tmp_path / "formatter_agent.md"
+    broken.write_text(broken_content)
+    result = run_lint(["--formatter-path", str(broken)])
+    assert result.returncode == 1
+    assert "CONTAMINATED-TRIANGULATION-UNMATCHED" in result.stderr
+
+
+def test_lint_detects_extra_allowlist_entry(tmp_path):
+    """Add a non-spec CONTAMINATED-* token to formatter — lint fails."""
+    formatter = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+    content = formatter.read_text()
+    broken_content = content.replace(
+        "`CONTAMINATED-PREPRINT`,",
+        "`CONTAMINATED-PREPRINT`, `CONTAMINATED-FABRICATED`,",
+    )
+    broken = tmp_path / "formatter_agent.md"
+    broken.write_text(broken_content)
+    result = run_lint(["--formatter-path", str(broken)])
+    assert result.returncode == 1
+    assert "CONTAMINATED-FABRICATED" in result.stderr
+
+
+def test_lint_detects_refusal_list_contamination(tmp_path):
+    """If CONTAMINATED-* appears in refusal rules, lint fails (R-L3-2-E guard)."""
+    formatter = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+    content = formatter.read_text()
+    # Inject a fake refusal rule containing CONTAMINATED-TRIANGULATION-UNMATCHED.
+    # Use the unique first-refusal-rule text as anchor so we land inside
+    # the refusal rules list, not in Core Principles (which also has "1. ").
+    broken_content = content.replace(
+        "1. A literal `[UNVERIFIED CITATION",
+        "1. A literal `CONTAMINATED-TRIANGULATION-UNMATCHED` marker.\n1. A literal `[UNVERIFIED CITATION",
+        1,
+    )
+    broken = tmp_path / "formatter_agent.md"
+    broken.write_text(broken_content)
+    result = run_lint(["--formatter-path", str(broken)])
+    assert result.returncode == 1
+    assert "refusal" in result.stderr.lower()
+
+
+def test_lint_substring_collision_not_false_positive():
+    """CONTAMINATED-PREPRINT inside CONTAMINATED-PREPRINT+... not double-counted.
+
+    With set-equality extraction, the 9-token set is unambiguous.
+    """
+    result = run_lint()
+    assert result.returncode == 0
+
+
+# ---------------------------------------------------------------------------
+# Rule 1 — marker syntax
+# ---------------------------------------------------------------------------
+
+def test_rule1_all_markers_present_in_real_repo():
+    """Rule 1: real orchestrator has all 3 new v3.9.0 markers in subsection."""
+    result = run_lint()
+    assert result.returncode == 0
+
+
+def test_rule1_missing_marker_fails(tmp_path):
+    """Rule 1: remove CONTAMINATED-PARTIAL-UNMATCH from orchestrator subsection — lint fails."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    broken = content.replace("`CONTAMINATED-PARTIAL-UNMATCH`", "`CONTAMINATED-XXX-PARTIAL`")
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "rule 1" in result.stderr.lower() or "marker" in result.stderr.lower()
+
+
+# ---------------------------------------------------------------------------
+# Rule 2 — preprint composition order
+# ---------------------------------------------------------------------------
+
+def test_rule2_preprint_order_correct_in_real_repo():
+    """Rule 2: real orchestrator has all PREPRINT compositions with PREPRINT first."""
+    result = run_lint()
+    assert result.returncode == 0
+
+
+def test_rule2_preprint_order_violated_fails(tmp_path):
+    """Rule 2: inject CONTAMINATED-COVERAGE-NOISE+PREPRINT into orchestrator — lint fails."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    broken = content.replace(
+        "## Cite-Time Provenance Finalizer — v3.9.0 extension",
+        "## Cite-Time Provenance Finalizer — v3.9.0 extension\n\nFAKE: `CONTAMINATED-COVERAGE-NOISE+PREPRINT` violates order.\n",
+        1,
+    )
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "rule 2" in result.stderr.lower() or "preprint" in result.stderr.lower()
+
+
+# ---------------------------------------------------------------------------
+# Rule 3 — v3.7.3 legacy compat
+# ---------------------------------------------------------------------------
+
+def test_rule3_legacy_compat_preserved_in_real_repo():
+    """Rule 3: real orchestrator's k=1 k_max=1 S2 row produces CONTAMINATED-UNMATCHED."""
+    result = run_lint()
+    assert result.returncode == 0
+
+
+def test_rule3_legacy_compat_violated_fails(tmp_path):
+    """Rule 3: change the legacy row's suffix to COVERAGE-NOISE — lint fails."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    broken = content.replace(
+        "| `semantic_scholar_unmatched` | `CONTAMINATED-UNMATCHED` (v3.7.3 legacy)",
+        "| `semantic_scholar_unmatched` | `CONTAMINATED-COVERAGE-NOISE` (BROKEN)",
+        1,
+    )
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "rule 3" in result.stderr.lower() or "legacy" in result.stderr.lower()
+
+
+def test_rule3_preprint_legacy_drift_fails(tmp_path):
+    """Rule 3: drift preprint legacy row's suffix to CONTAMINATED-PREPRINT+COVERAGE-NOISE — lint fails."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    broken = content.replace(
+        "`CONTAMINATED-PREPRINT+UNMATCHED` (v3.7.3 legacy)",
+        "`CONTAMINATED-PREPRINT+COVERAGE-NOISE` (BROKEN)",
+        1,
+    )
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "rule 3" in result.stderr.lower() or "preprint" in result.stderr.lower()
+
+
+def test_rule3_missing_legacy_rows_fails(tmp_path):
+    """Rule 3: delete BOTH legacy S2 rows from the table — lint must fail."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    # Delete the bare legacy row.
+    broken = content.replace(
+        "| `ok` / `LOW-WARN` | false / absent | 1 | 1 | `semantic_scholar_unmatched` | `CONTAMINATED-UNMATCHED` (v3.7.3 legacy) |\n",
+        "",
+        1,
+    )
+    # Delete the preprint legacy row.
+    broken = broken.replace(
+        "| `ok` / `LOW-WARN` | true | 1 | 1 | `semantic_scholar_unmatched` | `CONTAMINATED-PREPRINT+UNMATCHED` (v3.7.3 legacy) |\n",
+        "",
+        1,
+    )
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    # Both row-missing messages should fire.
+    err = result.stderr.lower()
+    assert "missing" in err
+    assert "rule 3" in err
+
+
+# ---------------------------------------------------------------------------
+# Rule 4 — no *-BLOCK in v3.9.0 subsection
+# ---------------------------------------------------------------------------
+
+def test_rule4_no_block_tokens_in_real_repo():
+    """Rule 4: real orchestrator's v3.9.0 subsection has no backtick-quoted *-BLOCK tokens."""
+    result = run_lint()
+    assert result.returncode == 0
+
+
+def test_rule4_high_block_injection_fails(tmp_path):
+    """Rule 4: inject `CONTAMINATED-HIGH-BLOCK` into v3.9.0 subsection — lint fails."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    broken = content.replace(
+        "## Cite-Time Provenance Finalizer — v3.9.0 extension",
+        "## Cite-Time Provenance Finalizer — v3.9.0 extension\n\nFAKE: `CONTAMINATED-HIGH-BLOCK` policy-layer marker.\n",
+        1,
+    )
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "rule 4" in result.stderr.lower() or "block" in result.stderr.lower()
+
+
+# ---------------------------------------------------------------------------
+# Delta-1 (v3.10/v3.11) — arXiv four-index extension
+# ---------------------------------------------------------------------------
+# (Clean-repo pass for all 13 allowlist tokens is covered by
+# test_lint_passes_on_clean_repo above — not duplicated here.)
+
+def test_delta1_missing_arxiv_allowlist_token_fails(tmp_path):
+    """Drop CONTAMINATED-ARXIV-UNMATCHED from the formatter allowlist — set-equality
+    (rule 5) must fail (the Delta-1 token is load-bearing, not incidentally present)."""
+    formatter = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+    content = formatter.read_text()
+    # Remove the bare ARXIV token from the allowlist sentence (keep the PREPRINT+ARXIV
+    # composite so the failure is specifically the bare-token drop).
+    broken = content.replace("`CONTAMINATED-ARXIV-UNMATCHED`, ", "", 1)
+    p = tmp_path / "formatter_agent.md"
+    p.write_text(broken)
+    result = run_lint(["--formatter-path", str(p)])
+    assert result.returncode == 1
+    assert "CONTAMINATED-ARXIV-UNMATCHED" in result.stderr
+
+
+def test_delta1_missing_quadrangulation_matrix_row_fails(tmp_path):
+    """Mistoken CONTAMINATED-QUADRANGULATION-UNMATCHED in its MATRIX ROW ONLY (k=4
+    k_max=4) while the explanatory bullet prose keeps the token verbatim — rule 1
+    must still fail.
+
+    This is the mutation rule 1 exists to catch: the matrix table IS the prompt
+    contract, so deleting/mistokening an operational row must fail even though the
+    same token survives in surrounding prose. (A blanket str.replace of every
+    occurrence would mask this — it strips the prose too, so a subsection-wide token
+    scan would fail for the wrong reason rather than because the row is gone.)"""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    # Mistoken the suffix in the k=4 k_max=4 (non-preprint) table row only.
+    matrix_cell = "| 4 | 4 | — | `CONTAMINATED-QUADRANGULATION-UNMATCHED`"
+    broken_cell = "| 4 | 4 | — | `CONTAMINATED-QUADXXX`"
+    assert matrix_cell in content, "fixture drift: k=4 k_max=4 row shape changed"
+    broken = content.replace(matrix_cell, broken_cell, 1)
+    # The bullet prose still carries the verbatim token, proving the failure comes
+    # from the row scan, not from blanket token absence.
+    assert "`CONTAMINATED-QUADRANGULATION-UNMATCHED`" in broken
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 1
+    assert "QUADRANGULATION" in result.stderr or "Delta-1" in result.stderr
+
+
+def test_delta1_token_in_prose_only_still_passes_is_not_contract(tmp_path):
+    """Deleting a Delta-1 token from the bullet PROSE while keeping its matrix row
+    intact must still PASS — the prose is documentation, not the contract. This is
+    the negative twin of the row-oracle test: it proves rule 1 keys off the matrix
+    row, not subsection-wide presence (so prose edits don't cause false failures)."""
+    orch = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+    content = orch.read_text()
+    # The arxiv carve-out bullet starts with the bolded token; neutralise the bolded
+    # prose mention without touching its `| 1 | 1 |` matrix row.
+    prose_bullet = "- **`CONTAMINATED-ARXIV-UNMATCHED` (k=1, k_max=1"
+    assert prose_bullet in content, "fixture drift: arxiv carve-out bullet shape changed"
+    broken = content.replace(prose_bullet, "- **The arxiv carve-out (k=1, k_max=1", 1)
+    # Matrix row for the token is untouched.
+    assert "| 1 | 1 | `arxiv_unmatched` | `CONTAMINATED-ARXIV-UNMATCHED`" in broken
+    p = tmp_path / "orch.md"
+    p.write_text(broken)
+    result = run_lint(["--orchestrator-path", str(p)])
+    assert result.returncode == 0, f"prose-only edit should pass: stderr={result.stderr}"
+
+
+def test_delta1_arxiv_is_kmax1_carveout_documented():
+    """The arxiv carve-out semantics (fires only at k_max=1, not any k=1) must be
+    documented verbatim in the orchestrator subsection so a future edit cannot
+    silently widen it (the resolved reading of the ambiguous 'single-index' phrase:
+    single-index means k_max=1, not merely k=1). This pins the prompt contract."""
+    orch = (REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+            ).read_text()
+    # The disambiguating sentence must be present.
+    assert "single-index" in orch and "k_max=1" in orch
+    assert "CONTAMINATED-COVERAGE-NOISE" in orch  # the k=1 k_max>=2 arxiv fallback
+
+
+# ---------------------------------------------------------------------------
+# Invocation error handling
+# ---------------------------------------------------------------------------
+
+def test_orchestrator_path_missing_returns_2(tmp_path):
+    """Missing orchestrator file → exit 2 (invocation error)."""
+    result = run_lint(["--orchestrator-path", str(tmp_path / "nonexistent.md")])
+    assert result.returncode == 2
+
+
+def test_formatter_path_missing_returns_2(tmp_path):
+    """Missing formatter file → exit 2 (invocation error)."""
+    result = run_lint(["--formatter-path", str(tmp_path / "nonexistent.md")])
+    assert result.returncode == 2