psyclaw 0.27.23 → 0.28.1

package/vendor/ars/scripts/test_check_215_field_norm.py

@@ -0,0 +1,238 @@
+"""Unit tests for check_215_field_norm.py (#215).
+
+The lint reads the three real reviewer surfaces. These tests (a) assert the shipped
+files pass, and (b) monkey-patch the file reader to inject mutated content so every
+assertion is shown to be non-vacuous (RED when the #215 block/marker is removed or
+de-scoped). Mirrors the falsifiability discipline of check_v3_9_2_phase_boundary.
+"""
+from __future__ import annotations
+
+import re
+import unittest
+
+from scripts import check_215_field_norm as cfn
+
+
+DOMAIN = "academic-paper-reviewer/agents/domain_reviewer_agent.md"
+DA = "academic-paper-reviewer/agents/devils_advocate_reviewer_agent.md"
+CAL = "academic-paper-reviewer/references/calibration_mode_protocol.md"
+
+
+def _real_reads() -> dict[str, str]:
+    return {p: cfn._read(p) for p in (DOMAIN, DA, CAL)}
+
+
+class TestShipped(unittest.TestCase):
+    def test_shipped_surfaces_pass(self) -> None:
+        self.assertEqual(cfn.check(), [], msg="shipped reviewer surfaces should pass #215 lint")
+
+
+class TestMutations(unittest.TestCase):
+    """Each test patches cfn._read to serve a mutated copy of ONE surface and asserts the
+    lint goes RED with a message naming that surface."""
+
+    def setUp(self) -> None:
+        self._orig_read = cfn._read
+        self._files = _real_reads()
+
+    def tearDown(self) -> None:
+        cfn._read = self._orig_read
+
+    def _patch(self, path: str, mutate) -> list[str]:
+        files = dict(self._files)
+        files[path] = mutate(files[path])
+        cfn._read = lambda p: files[p]
+        return cfn.check()
+
+    def test_domain_step5_removed_fails(self) -> None:
+        errors = self._patch(
+            DOMAIN, lambda t: t.replace("### Step 5: Field-Norm Severity Discipline (#215)", "### Step 5: Removed")
+        )
+        self.assertTrue(
+            any("domain_reviewer_agent.md" in e and "Step 5" in e for e in errors),
+            msg=f"expected domain Step 5 error: {errors!r}",
+        )
+
+    def test_domain_broadened_evidence_removed_fails(self) -> None:
+        errors = self._patch(
+            DOMAIN, lambda t: t.replace("not limited to a literature citation", "limited to a literature citation")
+        )
+        self.assertTrue(
+            any("broadened-evidence" in e for e in errors),
+            msg=f"expected broadened-evidence error: {errors!r}",
+        )
+
+    def test_domain_must_not_scoped_to_block(self) -> None:
+        """Removing 'MUST NOT' from the Step 5 block must fail even though MUST NOT may exist
+        elsewhere in the file — proving the check is block-scoped, not file-wide."""
+        errors = self._patch(
+            DOMAIN,
+            lambda t: self._strip_in_block(
+                t, "### Step 5: Field-Norm Severity Discipline (#215)", "MUST NOT", "must-not"
+            ),
+        )
+        self.assertTrue(
+            any("domain_reviewer_agent.md Step 5" in e and "MUST NOT" in e for e in errors),
+            msg=f"expected block-scoped MUST NOT error: {errors!r}",
+        )
+
+    def test_da_dimension9_removed_fails(self) -> None:
+        errors = self._patch(
+            DA, lambda t: t.replace("### 9. Field-Norm Severity Calibration (#215)", "### 9. Removed")
+        )
+        self.assertTrue(
+            any("devils_advocate_reviewer_agent.md" in e and "dimension" in e for e in errors),
+            msg=f"expected DA dimension 9 error: {errors!r}",
+        )
+
+    def test_da_field_removed_fails(self) -> None:
+        errors = self._patch(
+            DA, lambda t: t.replace("field_norm_boundary", "xxx").replace("evidence_crossing_rationale", "yyy")
+        )
+        self.assertTrue(
+            any("field_norm_boundary" in e for e in errors)
+            and any("evidence_crossing_rationale" in e for e in errors),
+            msg=f"expected DA missing-field errors: {errors!r}",
+        )
+
+    def test_calibration_phase35_removed_fails(self) -> None:
+        errors = self._patch(
+            CAL, lambda t: t.replace("### Phase 3.5: Severity-miscalibration measurement (#215)", "### Phase 3.5: Removed")
+        )
+        self.assertTrue(
+            any("calibration_mode_protocol.md" in e and "Phase 3.5" in e for e in errors),
+            msg=f"expected calibration Phase 3.5 error: {errors!r}",
+        )
+
+    def test_calibration_anti_circularity_removed_fails(self) -> None:
+        """Removing the anti-circularity anchor (the gold-set pointer) from Phase 3.5 must fail —
+        this is the codex P1 fix that the classifier rates grounding, not norm-correctness."""
+        errors = self._patch(
+            CAL,
+            lambda t: self._strip_in_block(
+                t,
+                "### Phase 3.5: Severity-miscalibration measurement (#215)",
+                "evals/gold/field_norm_severity",
+                "evals/gold/REMOVED",
+            ),
+        )
+        self.assertTrue(
+            any("calibration_mode_protocol.md Phase 3.5" in e and "anti-circularity" in e for e in errors),
+            msg=f"expected anti-circularity error: {errors!r}",
+        )
+
+    def test_domain_grounding_clause_removed_fails(self) -> None:
+        """codex P2: a bare `MUST` check passes on `MUST NOT` alone. Deleting the load-bearing
+        positive grounding clause must still fail — assert the specific clause, not a modal verb."""
+        errors = self._patch(
+            DOMAIN,
+            lambda t: self._strip_in_block(
+                t,
+                "### Step 5: Field-Norm Severity Discipline (#215)",
+                "ground the norm in an external",
+                "do something with the norm",
+            ),
+        )
+        self.assertTrue(
+            any("domain_reviewer_agent.md Step 5" in e and "ground the norm in an external" in e for e in errors),
+            msg=f"expected grounding-clause error: {errors!r}",
+        )
+
+    def test_da_output_format_column_removed_fails(self) -> None:
+        """codex P1: deleting the CRITICAL/MAJOR table columns from the Output Format block must
+        fail even though the snake_case field names remain in the gating prose elsewhere — proves
+        the column check is scoped to the output block, not file-wide."""
+        errors = self._patch(
+            DA,
+            lambda t: self._strip_in_block(
+                t, "## Output Format", "Field-Norm Boundary", "Removed-Column",
+            ),
+        )
+        self.assertTrue(
+            any("Output Format" in e and "Field-Norm Boundary" in e for e in errors),
+            msg=f"expected scoped output-format column error: {errors!r}",
+        )
+
+    def test_da_single_table_column_removed_fails(self) -> None:
+        """codex re-review P1: if ONLY the CRITICAL table loses its columns while MAJOR keeps
+        them, a whole-block check would find the names in MAJOR and false-pass. Each severity
+        subsection must be checked separately. Mutate only the CRITICAL table header row."""
+        def drop_critical_columns(t: str) -> str:
+            # Replace the column names on the CRITICAL table's header row only (first occurrence
+            # after '#### CRITICAL'), leaving the MAJOR table intact.
+            idx = t.index("#### CRITICAL")
+            head = t[:idx]
+            tail = t[idx:]
+            tail = tail.replace(
+                "| # | Dimension | Issue Description | Evidence Anchor | Confidence | Field-Norm Boundary | Evidence-Crossing Rationale |",
+                "| # | Dimension | Issue Description | Evidence Anchor | Confidence |",
+                1,
+            )
+            return head + tail
+
+        errors = self._patch(DA, drop_critical_columns)
+        self.assertTrue(
+            any("CRITICAL table" in e and "Field-Norm Boundary" in e for e in errors),
+            msg=f"expected single-table (CRITICAL) column error: {errors!r}",
+        )
+
+    def test_domain_must_weakened_to_should_fails(self) -> None:
+        """codex re-review P1: weakening 'MUST** ground' to 'SHOULD** ground' must fail — the
+        load-bearing invariant is the positive MUST requirement, not just the grounding phrase."""
+        errors = self._patch(
+            DOMAIN,
+            lambda t: self._strip_in_block(
+                t,
+                "### Step 5: Field-Norm Severity Discipline (#215)",
+                "**MUST** ground the norm",
+                "**SHOULD** ground the norm",
+            ),
+        )
+        self.assertTrue(
+            any("Step 5" in e and "MUST** ground the norm in an external" in e for e in errors),
+            msg=f"expected weakened-modal error: {errors!r}",
+        )
+
+    def test_calibration_risk_definitions_removed_fails(self) -> None:
+        """codex P2: the intro line already contains 'low / med / high', so a bare-word check
+        passes after the three definition bullets are deleted. Removing a definition marker
+        (**`high`**) must fail."""
+        errors = self._patch(
+            CAL,
+            lambda t: self._strip_in_block(
+                t,
+                "### Phase 3.5: Severity-miscalibration measurement (#215)",
+                "**`high`**",
+                "**removed**",
+            ),
+        )
+        self.assertTrue(
+            any("Phase 3.5" in e and "'high' risk-level definition" in e for e in errors),
+            msg=f"expected risk-definition error: {errors!r}",
+        )
+
+    def test_block_not_truncated_by_code_fence(self) -> None:
+        """The Output Format block embeds a ```markdown sample report whose code fence contains
+        '## Devil's Advocate Review' etc. _block() must NOT treat those fenced ## lines as the
+        next header — otherwise the block truncates early and drops the CRITICAL table below it.
+        This asserts the real columns (below the fence) are inside the captured block."""
+        block = cfn._block(self._files[DA], r"^## Output Format")
+        self.assertIsNotNone(block)
+        self.assertIn("Field-Norm Boundary", block, "fence-aware _block must reach the CRITICAL table")
+        self.assertIn("#### CRITICAL", block)
+
+    @staticmethod
+    def _strip_in_block(text: str, header: str, needle: str, replacement: str) -> str:
+        """Replace `needle` with `replacement` ONLY inside the block starting at `header`
+        (up to the next ##/### header), leaving any same-string occurrences elsewhere intact.
+        Lets a test prove block-scoping rather than file-wide presence. Reuses the lint's own
+        `_block()` so the test and the production scope logic cannot drift apart."""
+        block = cfn._block(text, re.escape(header))
+        if block is None:
+            return text
+        start = text.index(block)
+        return text[:start] + block.replace(needle, replacement) + text[start + len(block):]
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/ars/scripts/test_check_216_surface_form.py

@@ -0,0 +1,341 @@
+"""Mutation tests for check_216_surface_form.py (#216).
+
+The lint reads the real Devil's Advocate agent surface. These tests (a) assert the shipped
+file passes, and (b) monkey-patch the file reader to inject mutated content so every assertion
+is shown non-vacuous: the lint goes RED when a marker, a load-bearing clause, the verdict-time
+framing, the §F.3.6 attribution, or the epistemic disclaimer is removed / weakened / de-scoped.
+
+Covers the six mutation classes codex flagged (P1.2):
+  1. clause deletion           -> test_clause_*_removed_fails
+  2. MUST/SHOULD weakening      -> test_authorship_softened_fails / test_down_rate_softened_fails
+  3. marker-only block          -> test_block_emptied_of_clauses_fails
+  4. clause moved outside block -> test_clause_moved_outside_block_fails
+  5. fenced-marker truncation   -> test_markers_fenced_fails
+  6. verdict/output-surface     -> test_verdict_framing_removed_fails
+"""
+from __future__ import annotations
+
+import unittest
+
+from scripts import check_216_surface_form as csf
+
+DA = csf.DA_AGENT
+
+
+class TestShipped(unittest.TestCase):
+    def test_shipped_surface_passes(self) -> None:
+        self.assertEqual(csf.check(), [], msg="shipped DA surface should pass #216 lint")
+
+
+class TestMutations(unittest.TestCase):
+    def setUp(self) -> None:
+        self._orig_read = csf._read
+        self._real = csf._read(DA)
+
+    def tearDown(self) -> None:
+        csf._read = self._orig_read
+
+    def _patch(self, mutate) -> list[str]:
+        mutated = mutate(self._real)
+        csf._read = lambda p: mutated if p == DA else self._orig_read(p)
+        return csf.check()
+
+    # --- 1. clause deletion (one test per load-bearing clause, proving each is non-vacuous) ---
+
+    def test_clause_extract_substance_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("Extract the checkable substance first", "Skip the substance"))
+        self.assertTrue(any("extract-substance" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_judge_vs_paper_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("Judge the claim against the paper, not against the polish", "Judge however")
+        )
+        self.assertTrue(any("judge-vs-paper-not-polish" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_no_credit_specificity_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("Do not credit technical specificity", "Credit specificity"))
+        self.assertTrue(any("no-credit-specificity" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_checking_required_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("still requires checking against the paper before you accept it", "is fine to accept")
+        )
+        self.assertTrue(any("still-requires-checking" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_counterfactual_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("Run the opposite-style counterfactual", "Skip the counterfactual"))
+        self.assertTrue(any("opposite-style-counterfactual" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_would_verdict_change_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace(
+                "would my verdict change if this same substantive claim were rewritten in the opposite style",
+                "nothing changes",
+            )
+        )
+        self.assertTrue(any("would-my-verdict-change" in e for e in errors), msg=f"{errors!r}")
+
+    def test_clause_revise_or_ambiguous_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("revise the verdict, or mark the claim ambiguous", "keep the verdict")
+        )
+        self.assertTrue(any("revise-or-mark-ambiguous" in e for e in errors), msg=f"{errors!r}")
+
+    # --- 2. MUST/SHOULD-style weakening (the guard binds the modal to the action) ---
+
+    def test_authorship_softened_fails(self) -> None:
+        """Flipping the deliberate 'not a judgment input' to allow authorship must fail."""
+        errors = self._patch(
+            lambda t: t.replace(
+                "Authorship (human vs AI origin of a concern) is deliberately **not** a judgment input",
+                "Authorship may be considered as a judgment input",
+            )
+        )
+        self.assertTrue(any("authorship-not-input" in e for e in errors), msg=f"{errors!r}")
+
+    def test_down_rate_softened_fails(self) -> None:
+        """Weakening 'Do not down-rate informal or vague wording' must fail — a bare 'down-rate'
+        elsewhere cannot satisfy the bound clause."""
+        errors = self._patch(
+            lambda t: t.replace("Do not down-rate informal or vague wording", "You may down-rate informal wording")
+        )
+        self.assertTrue(any("no-down-rate-informal" in e for e in errors), msg=f"{errors!r}")
+
+    def test_unless_guard_removed_fails(self) -> None:
+        """Dropping the UNLESS guard turns the parity rule into 'never penalise vagueness',
+        which would over-correct (the sfp-005 boundary). Must fail."""
+        errors = self._patch(
+            lambda t: t.replace(
+                "unless* the ambiguity actually changes the truth conditions or makes the claim unevaluable",
+                "no matter what",
+            )
+        )
+        self.assertTrue(any("unless-truth-conditions" in e for e in errors), msg=f"{errors!r}")
+
+    # --- 3. marker-only block (markers present but all clauses gone) ---
+
+    def test_block_emptied_of_clauses_fails(self) -> None:
+        """Keep the BEGIN/END markers but replace the clause body with filler. A marker-presence
+        check would false-pass; the clause checks must fail."""
+        block = csf._marker_block(self._real)
+        assert block is not None
+        errors = self._patch(lambda t: t.replace(block, "\nSee elsewhere for details.\n"))
+        self.assertTrue(
+            sum("parity block: missing load-bearing clause" in e for e in errors) >= 5,
+            msg=f"emptied block should drop many clauses: {errors!r}",
+        )
+
+    # --- 4. clause moved outside the marker block (block-scoping proof) ---
+
+    def test_clause_moved_outside_block_fails(self) -> None:
+        """Delete a clause from inside the block and re-add it AFTER the END marker. The clause
+        text still exists in the file, but the block-scoped check must still fail — proving the
+        lint is block-scoped, not file-wide."""
+        needle = "Run the opposite-style counterfactual."
+
+        def mutate(t: str) -> str:
+            t2 = t.replace("- **Run the opposite-style counterfactual.**", "- (moved)")
+            # re-inject the raw clause text after the END marker, outside the block
+            return t2.replace(csf.END_MARKER + " (#216) -->", csf.END_MARKER + " (#216) -->\n" + needle)
+
+        errors = self._patch(mutate)
+        self.assertTrue(any("opposite-style-counterfactual" in e for e in errors), msg=f"{errors!r}")
+
+    def test_marker_block_moved_out_of_section_fails(self) -> None:
+        """codex P2: if the whole marker block is relocated to AFTER the parity section ends
+        (e.g. into Severity Classification) while the section header/framing/disclaimer remain,
+        a file-wide marker lookup would false-pass. The section-scoped lookup must fail."""
+        begin = "<!-- " + csf.BEGIN_MARKER
+        end_tail = csf.END_MARKER + " (#216) -->"
+
+        def mutate(t: str) -> str:
+            b = t.index(begin)
+            e = t.index(end_tail, b) + len(end_tail)
+            block = t[b:e]
+            without = t[:b] + "(parity steps moved below)\n" + t[e:]
+            # re-inject the block INSIDE a later section (after the Severity Classification header)
+            # so it is out of the parity section but still present in the file.
+            anchor = "## Severity Classification\n"
+            return without.replace(anchor, anchor + "\n" + block + "\n\n", 1)
+
+        errors = self._patch(mutate)
+        self.assertTrue(
+            any("INSIDE the" in e and "section" in e and DA in e for e in errors),
+            msg=f"out-of-section marker should fail: {errors!r}",
+        )
+
+    def test_whole_section_fenced_fails(self) -> None:
+        """codex P2 round 8: if the ENTIRE parity section (header included) is wrapped in a ```
+        fence, the header match must be ignored (it is only a code sample). The lint must report
+        the section as missing, not pass on a fenced sample."""
+        header = "## Surface-Form Parity Self-Check (#216)"
+
+        def mutate(t: str) -> str:
+            idx = t.index(header)
+            # wrap from the header through the end of the section's epistemic disclaimer in a fence
+            end_anchor = "## Severity Classification"
+            end = t.index(end_anchor, idx)
+            return t[:idx] + "```\n" + t[idx:end] + "```\n\n" + t[end:]
+
+        errors = self._patch(mutate)
+        self.assertTrue(
+            any(DA in e and "missing" in e and "section" in e for e in errors),
+            msg=f"fenced section should be treated as missing: {errors!r}",
+        )
+
+    # --- 5. fenced-marker truncation (markers buried in a code fence are not live) ---
+
+    def test_markers_fenced_fails(self) -> None:
+        """Wrap the whole marker block in a ``` fence. The markers then sit inside a code sample
+        and must not count as a live block."""
+
+        def mutate(t: str) -> str:
+            block_full_begin = "<!-- " + csf.BEGIN_MARKER
+            idx = t.index(block_full_begin)
+            return t[:idx] + "```\n" + t[idx:].replace(
+                csf.END_MARKER + " (#216) -->", csf.END_MARKER + " (#216) -->\n```", 1
+            )
+
+        errors = self._patch(mutate)
+        self.assertTrue(
+            any("marker block" in e for e in errors),
+            msg=f"fenced markers should not count as a live block: {errors!r}",
+        )
+
+    def test_clauses_fenced_inside_block_fails(self) -> None:
+        """codex P2 round 12: markers stay live but the bullet clauses between them are wrapped in
+        a ``` fence. The clauses are then only a sample; the live-text check must fail."""
+        block = csf._marker_block(self._real)
+        assert block is not None
+        errors = self._patch(lambda t: t.replace(block, "\n```\n" + block + "\n```\n"))
+        self.assertTrue(
+            sum("missing load-bearing clause" in e for e in errors) >= 5,
+            msg=f"fenced clauses should not count as live: {errors!r}",
+        )
+
+    # --- 6. verdict/output-surface framing removal ---
+
+    def test_verdict_framing_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("verdict-assignment time", "some time").replace("verdict time", "some time")
+        )
+        self.assertTrue(any("verdict" in e and "time-of-application" in e for e in errors), msg=f"{errors!r}")
+
+    def test_section_header_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("## Surface-Form Parity Self-Check (#216)", "## Removed Section")
+        )
+        self.assertTrue(any("missing '## Surface-Form Parity Self-Check (#216)' section" in e for e in errors), msg=f"{errors!r}")
+
+    def test_f36_attribution_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("§F.3.6", "§X"))
+        self.assertTrue(any("§F.3.6 paper attribution" in e for e in errors), msg=f"{errors!r}")
+
+    def test_epistemic_disclaimer_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("Epistemic status", "Note"))
+        self.assertTrue(any("epistemic-status disclaimer" in e for e in errors), msg=f"{errors!r}")
+
+
+SYNTH = csf.SYNTH_AGENT
+
+
+class TestSynthesizerSurface(unittest.TestCase):
+    """The editorial synthesizer is the SECOND verdict-time surface (codex P2 round 6). It must
+    carry its own scoped parity block; each assertion is proven non-vacuous by a mutation."""
+
+    def setUp(self) -> None:
+        self._orig_read = csf._read
+        self._real = csf._read(SYNTH)
+
+    def tearDown(self) -> None:
+        csf._read = self._orig_read
+
+    def _patch(self, mutate) -> list[str]:
+        mutated = mutate(self._real)
+        csf._read = lambda p: mutated if p == SYNTH else self._orig_read(p)
+        return csf.check()
+
+    def test_synth_section_present_in_shipped(self) -> None:
+        # sanity: the shipped synthesizer passes (no patch)
+        csf._read = self._orig_read
+        self.assertEqual(csf.check(), [], msg="shipped surfaces should pass")
+
+    def test_synth_section_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("### Step 1c — Surface-Form Parity Check (#216)", "### Step 1c — Removed"))
+        self.assertTrue(any(SYNTH in e and "missing" in e and "section" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_clause_no_down_rate_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("Do not down-rate informal or vague wording", "You may down-rate"))
+        self.assertTrue(any(SYNTH in e and "no-down-rate-informal" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_clause_authorship_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace(
+                "Authorship (whether a sub-claim originated from a human or an AI reviewer) is **not** a decision input",
+                "Authorship may change a sub-claim's decision bearing",
+            )
+        )
+        self.assertTrue(any(SYNTH in e and "authorship-not-input" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_clause_reassess_unevaluable_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace("reassess on substance, or mark the sub-claim unevaluable", "keep the assessment")
+        )
+        self.assertTrue(any(SYNTH in e and "reassess-or-unevaluable" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_clause_paper_evidence_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace(
+                "A precise-sounding sub-claim still needs paper evidence",
+                "A precise-sounding sub-claim is sufficient",
+            )
+        )
+        self.assertTrue(any(SYNTH in e and "needs-paper-evidence" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_clause_counterfactual_assessment_removed_fails(self) -> None:
+        errors = self._patch(
+            lambda t: t.replace(
+                "would this sub-claim's evidentiary assessment change if the same substance were rewritten in the opposite style",
+                "would the prose sound different",
+            )
+        )
+        self.assertTrue(any(SYNTH in e and "would-assessment-change" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_marker_block_removed_fails(self) -> None:
+        block = csf._marker_block(self._real)
+        assert block is not None
+        errors = self._patch(lambda t: t.replace(block, "\nsee elsewhere\n"))
+        self.assertTrue(
+            sum(SYNTH in e and "missing load-bearing clause" in e for e in errors) >= 4,
+            msg=f"emptied synth block should drop clauses: {errors!r}",
+        )
+
+    def test_synth_f36_attribution_removed_fails(self) -> None:
+        errors = self._patch(lambda t: t.replace("§F.3.6", "§X"))
+        self.assertTrue(any(SYNTH in e and "§F.3.6 paper attribution" in e for e in errors), msg=f"{errors!r}")
+
+    def test_synth_marker_moved_to_later_subsection_fails(self) -> None:
+        """codex P2 round 7: Step 1c is a ### section, so _section() must stop at the next ###
+        (Step 2), not only at ##. Move the marker block out of Step 1c into Step 2; the
+        section-scoped check must fail because the block is no longer inside Step 1c."""
+        begin = "<!-- " + csf.BEGIN_MARKER
+        end_tail = csf.END_MARKER + " (#216) -->"
+
+        def mutate(t: str) -> str:
+            b = t.index(begin)
+            e = t.index(end_tail, b) + len(end_tail)
+            block = t[b:e]
+            without = t[:b] + "(parity steps moved below)\n" + t[e:]
+            # re-inject INSIDE the later ### Step 2 subsection
+            anchor = "### Step 2: Consensus Identification\n"
+            return without.replace(anchor, anchor + "\n" + block + "\n\n", 1)
+
+        errors = self._patch(mutate)
+        self.assertTrue(
+            any(SYNTH in e and "INSIDE the" in e and "section" in e for e in errors),
+            msg=f"block moved to a later ### should fail: {errors!r}",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()