S0-R1-C3 Quantitative Causal-Negation Semantic Guard

core/quantitative_engine.py

@@ -493,6 +493,47 @@ Keywords: {keywords}"""
             ] if strict else [],
         }
 
+    @staticmethod
+    def _causal_phrase_is_explicitly_disclaimed(sentence, match_start, match_end):
+        """Return True only when a causal phrase is explicitly scoped by a limitation.
+
+        This is intentionally local to the matched phrase rather than sentence-wide so a
+        sentence can safely say that causal identification is unavailable while still
+        failing closed if a separate clause makes an affirmative causal claim.
+        """
+        value = str(sentence or "")
+        left_floor = max(0, int(match_start) - 180)
+        left = value[left_floor:int(match_start)]
+        # Do not let a disclaimer in an earlier independent/contrast clause shield a later
+        # affirmative causal assertion.  Keep the closest clause-like segment only.
+        boundaries = list(re.finditer(
+            r"(?i)(?:[;:,]|\bbut\b|\bhowever\b|\bwhereas\b|\byet\b|\bnevertheless\b)",
+            left,
+        ))
+        if boundaries:
+            left = left[boundaries[-1].end():]
+        left_folded = re.sub(r"\s+", " ", left.casefold()).strip()
+        right = value[int(match_end):min(len(value), int(match_end) + 140)]
+        right_folded = re.sub(r"\s+", " ", right.casefold()).strip()
+
+        pre_disclaimer_patterns = (
+            r"\b(?:cannot|can't|could not|couldn't|does not|doesn't|do not|don't|did not|didn't)\s+(?:identify|establish|demonstrate|show|infer|support|imply|claim|justify|warrant|permit|allow)\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:is not|isn't|are not|aren't|was not|wasn't|were not|weren't)\s+(?:able\s+to\s+)?(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:unable|insufficient)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:fails?|failed)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\bno\s+(?:evidence|basis|support)\s+(?:for|of)\s*(?:(?:an?|the)\s*)?$",
+            r"\bnot\s+(?:evidence|proof)\s+(?:for|of)\s*(?:(?:an?|the)\s*)?$",
+            r"\bno\s*$",
+        )
+        if any(re.search(pattern, left_folded) for pattern in pre_disclaimer_patterns):
+            return True
+
+        post_disclaimer_patterns = (
+            r"^(?:\s*(?:is|are|was|were|has|have|had))?\s*(?:not|never)\s+(?:identified|established|demonstrated|shown|inferred|supported|claimed|justified|warranted)\b",
+            r"^\s*(?:cannot|can't|could not|couldn't|should not|shouldn't|must not|does not|doesn't|do not|don't)\s+(?:be\s+)?(?:identified|established|demonstrated|shown|inferred|supported|claimed|interpreted|justified|warranted)\b",
+        )
+        return any(re.search(pattern, right_folded) for pattern in post_disclaimer_patterns)
+
     @classmethod
     def inspect_quantitative_study_fact_contract(cls, text, metadata, section_name=""):
         """Pure AMJ quantitative Evidence Ledger inspection; never rewrites prose."""
@@ -574,7 +615,10 @@ Keywords: {keywords}"""
                         violations.append({"type":"construct_role_mismatch","role":role,"observed":candidate,"expected":expected,"preview":sentence.strip()[:180]})
             if strict:
                 for pattern in causal_patterns:
-                    if re.search(pattern, sentence):
+                    match = re.search(pattern, sentence)
+                    if match and not cls._causal_phrase_is_explicitly_disclaimed(
+                        sentence, match.start(), match.end()
+                    ):
                         violations.append({"type":"causal_language_violation","preview":sentence.strip()[:180]})
                         break
                 if (any(c in sentence.casefold() for c in construct_folded) if construct_folded else False) and re.search(r"(?i)\bp\s*(?:=|<|>|≤|≥)\s*(?:0?\.\d+|\d+(?:\.\d+)?)", sentence):
@@ -706,9 +750,25 @@ Keywords: {keywords}"""
 
             if strict:
                 for pattern, replacement in causal_replacements:
-                    revised, count = re.subn(pattern, replacement, revised)
-                    if count:
-                        diagnostics.append({"type":"causal_language_repaired","replacement":replacement,"count":count})
+                    regex = re.compile(pattern)
+                    repaired_count = 0
+
+                    def causal_repl(match):
+                        nonlocal repaired_count
+                        if cls._causal_phrase_is_explicitly_disclaimed(
+                            revised, match.start(), match.end()
+                        ):
+                            return match.group(0)
+                        repaired_count += 1
+                        return replacement
+
+                    revised = regex.sub(causal_repl, revised)
+                    if repaired_count:
+                        diagnostics.append({
+                            "type":"causal_language_repaired",
+                            "replacement":replacement,
+                            "count":repaired_count,
+                        })
                 if any(c in revised.casefold() for c in construct_folded) if construct_folded else False:
                     revised, p_count = re.subn(r"(?i)\s*[,;]?\s*p\s*(?:=|<|>|≤|≥)\s*(?:0?\.\d+|\d+(?:\.\d+)?)", "", revised)
                     if p_count: