S0-R1-C5.4 Contract Consistency Failure Surface Stabilization

core/generation_runner.py

@@ -944,6 +944,13 @@ class GenerationRunner:
                 continue
             kind = str(item.get('type') or 'validation_issue')
             detail = str(item.get('repair_instruction') or item.get('reason') or item.get('preview') or '')
+            if kind == 'causal_language_violation' and not detail:
+                detail = (
+                    "Rewrite only the causal-strength wording. Preserve the study fact and analytical meaning, "
+                    "but state association/covariation rather than causal identification. Explicit limitation "
+                    "phrases such as 'restricted to associations, not causal effects' and 'cannot establish "
+                    "causality' are valid and should not be weakened further."
+                )
             actor = str(item.get('actor') or '')
             expected = item.get('expected')
             observed = item.get('observed')
@@ -3343,6 +3350,16 @@ class GenerationRunner:
                     "\nASQ EVIDENCE-CHANNEL RULE: A sentence whose factual subject is this study's setting, participants, interviews, data sources, cases, actors, observations, events, quotations, analytic steps, or empirical findings must not carry an external [CITE-XX] tag. "
                     "Place any prior-literature or methodological-rationale claim in a separate sentence and cite only that external claim."
                 )
+            if section_id not in {"results", "findings", "appendix"}:
+                citation_rule += (
+                    "\nCURRENT-STUDY PROVENANCE RULE: Do not attach external literature citations to this study's own research question, H1-Hn statement, sample/design fact, analytic choice, result, limitation specific to the available study evidence, or author positioning. "
+                    "If prior literature provides a rationale, state that external rationale in a separate sentence and cite only that sentence."
+                )
+            if bool(state.get("evidence_risk_detected")) and section_id not in {"results", "findings", "appendix"}:
+                citation_rule += (
+                    "\nEVIDENCE-LIMITED CLAIM-DENSITY CONTRACT: Direct high-relevance literature coverage is limited. Treat assigned claim-evidence items as the ceiling for source-dependent empirical, definitional, prevalence, and field-gap claims in this unit. "
+                    "Do not invent additional literature claims merely to make the section sound comprehensive. Prefer concise study positioning, cautious conceptual reasoning, and clearly qualified interpretations when no directly validated source is assigned."
+                )
             memory_context = agent._build_memory_context(sec_title, 2500)
             memory_block = f"\n<GLOBAL_MEMORY>\n{memory_context}\n</GLOBAL_MEMORY>\n" if memory_context else ""
             snippets = rag_engine.get_relevant_context(display_name) if rag_engine is not None else ""
@@ -3458,6 +3475,7 @@ Planning length: approximately {int(adjusted_target * min_ratio)}-{int(adjusted_
 {citation_rule}
 {table_rule}
 AUTHOR-FACING PURITY: Write only reader-facing scholarly prose. Do not mention internal orchestration, validation, state-management, evidence-management, or execution terminology. Describe the study, method, evidence, and limitations directly.
+{("CAUSAL-STRENGTH CONTRACT: This cross-sectional observational design supports association/covariation language only. Do not state that one construct causes, leads to, drives, determines, produces, or causally mediates another. Explicit limitation language is valid and preferred when relevant, including 'restricted to associations, not causal effects', 'cannot establish causality', and 'the indirect association is not causal mediation identification'." if mode == "amj" else "")}
 {self._hypothesis_contract_directive(hypothesis_ledger)}
 {str(sec.get('required_content') or '')}
 {qualitative_rule}

core/pipeline_agent.py

@@ -2774,6 +2774,13 @@ INPUT:
                     or section_loads.get(section, 0) >= capacities.get(section, target)
                 ):
                     continue
+                provenance = self._citation_claim_provenance(claim, section)
+                if provenance != 'EXTERNAL_LITERATURE_CLAIM':
+                    logging.info(
+                        'Citation planner rejected non-literature claim provenance: section=%s tag=%s provenance=%s',
+                        section, tag, provenance,
+                    )
+                    continue
                 evidence = str((self.citation_map.get(tag) or {}).get('evidence') or '')
                 if len(self._citation_terms(claim) & self._citation_terms(evidence)) < 2:
                     continue
@@ -3256,10 +3263,20 @@ INPUT:
         section = str(section_name or '').lower()
         if not text:
             return 'STRUCTURAL'
-        if re.match(r'^(?:h\d+[a-z]?\s*[:.\-]|hypothesis\s+\d+\b)', lower):
+        if re.match(r'^(?:h\d+[a-z]?\b|hypothesis\s+\d+\b)', lower):
             return 'HYPOTHESIS_STATEMENT'
         if re.search(r'\b(?:we hypothesi[sz]e|we propose|we predict|we expect)\b', lower):
             return 'HYPOTHESIS_STATEMENT'
+        if re.search(
+            r'\b(?:the research question|our research question|research question guiding the study|the focal research question)\b',
+            lower,
+        ):
+            return 'STUDY_POSITIONING'
+        if re.search(
+            r'\b(?:h\d+[a-z]?\s+(?:states?|proposes?|predicts?|addresses?|posits?|hypothesi[sz]es?|tests?))\b',
+            lower,
+        ):
+            return 'HYPOTHESIS_STATEMENT'
         if re.search(
             r'\b(?:the present study|this study|our study|the current study|the present research|this research)\b',
             lower,

core/quantitative_engine.py

@@ -600,51 +600,77 @@ 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.
+    @classmethod
+    def _classify_quantitative_causal_clause(cls, clause):
+        """Classify study/result prose as causal assertion, explicit limitation, or non-causal.
 
-        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.
+        The contract is semantic at the clause level rather than a blacklist of the
+        token ``causal``.  Explicit statements that restrict interpretation to
+        association/covariation are permitted, while affirmative causal verbs and
+        causal-identification claims remain fail-closed.
         """
-        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(?:inability|lack\s+of\s+(?:an?\s+)?ability)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
-            r"\bwithout\s+(?:directly\s+)?(?:identifying|establishing|demonstrating|showing|inferring|supporting|justifying|warranting)(?:\s+\w+){0,8}\s*(?:(?:an?|the)\s*)?$",
-            r"\b(?:not\s+designed|not\s+intended)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
-            r"\b(?:should not|shouldn't|must not|cannot|can't|could not|couldn't)\s+be\s+interpreted\s+as\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*$",
+        value = re.sub(r"\s+", " ", str(clause or "")).strip().casefold()
+        if not value:
+            return "NON_CAUSAL"
+
+        causal_nouns = r"(?:causal(?:ity|\s+(?:effect|effects|mediation|mechanism|pathway|relationship|relationships|identification))|cause(?:s|d)?|causation)"
+        limitation_patterns = (
+            rf"\b(?:cannot|can't|could not|couldn't|does not|doesn't|do not|don't|did not|didn't|fails? to|failed to|is not able to|are not able to|was not able to|were not able to|unable to|insufficient to)\s+(?:identify|establish|demonstrate|show|infer|support|imply|claim|justify|warrant|permit|allow|prove)\b[^.;]{{0,80}}\b{causal_nouns}\b",
+            rf"\b(?:is|are|was|were)\s+insufficient\s+to\s+(?:identify|establish|demonstrate|show|infer|support|prove)\b[^.;]{{0,80}}\b{causal_nouns}\b",
+            rf"\b(?:is|are|was|were)\s+not\s+(?:designed|intended)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|prove)\b[^.;]{{0,80}}\b{causal_nouns}\b",
+            rf"\bwithout\s+(?:identifying|establishing|demonstrating|showing|inferring|supporting|proving)\b[^.;]{{0,80}}\b{causal_nouns}\b",
+            rf"\b(?:no|without)\s+(?:evidence|basis|support|identification|proof)\b[^.;]{{0,60}}\b{causal_nouns}\b",
+            rf"\b(?:not|never)\s+(?:evidence|proof)\s+(?:of|for)\b[^.;]{{0,50}}\b{causal_nouns}\b",
+            rf"\b(?:should not|shouldn't|must not|cannot|can't|could not|couldn't)\s+be\s+(?:interpreted|read|treated|understood)\s+as\b[^.;]{{0,60}}\b{causal_nouns}\b",
+            rf"\b(?:is|are|was|were)\s+(?:restricted|limited|confined)\s+to\b[^.;]{{0,120}}\b(?:not|rather than|instead of)\s+(?:to\s+)?\b{causal_nouns}\b",
+            rf"\b(?:restricted|limited|confined)\s+to\b[^.;]{{0,120}}\b(?:not|rather than|instead of)\s+(?:to\s+)?\b{causal_nouns}\b",
+            rf"\b(?:association|associations|covariation|covariance|correlation|correlations|indirect association|descriptive pattern|descriptive patterns)\b[^.;]{{0,80}}\b(?:not(?:\s+as)?|rather than|instead of)\s+(?:an?\s+|the\s+)?{causal_nouns}\b",
+            rf"\b{causal_nouns}\b\s+(?:is|are|was|were)\s+(?:not|never)\s+(?:identified|established|demonstrated|shown|inferred|supported|claimed|justified|warranted|proven)\b",
+            rf"\b{causal_nouns}\b\s+(?:cannot|can't|could not|couldn't)\s+be\s+(?:identified|established|demonstrated|shown|inferred|supported|claimed|justified|warranted|proven)\b",
+            rf"\b(?:inability|lack\s+of\s+(?:an?\s+)?ability)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant|prove)\b[^.;]{{0,80}}\b{causal_nouns}\b",
+            rf"\b(?:not|no)\s+(?:an?\s+|the\s+)?{causal_nouns}\b",
+            rf"\b(?:cannot|can't|could not|couldn't)\s+be\s+used\s+to\s+(?:infer|establish|demonstrate|show|prove)\s+(?:an?\s+|the\s+)?{causal_nouns}\b",
+            rf"\bwithout\s+(?:proving|establishing|demonstrating|showing|identifying)\s+(?:an?\s+|the\s+)?{causal_nouns}\b",
         )
-        if any(re.search(pattern, left_folded) for pattern in pre_disclaimer_patterns):
-            return True
+        if any(re.search(pattern, value, flags=re.I) for pattern in limitation_patterns):
+            return "EXPLICIT_CAUSAL_LIMITATION"
+
+        affirmative_patterns = (
+            r"\b(?:causes?|caused|causing)\b",
+            r"\b(?:leads?|led)\s+to\b",
+            r"\b(?:drives?|drove|driven)\b",
+            r"\b(?:determines?|determined)\b",
+            r"\b(?:produces?|produced)\b",
+            r"\b(?:results?|resulted)\s+in\b",
+            r"\b(?:transmits?|transmitted)\s+(?:an?\s+|the\s+)?causal\s+effect\b",
+            r"\b(?:has|have|had|exerts?|exerted)\s+(?:an?\s+|the\s+)?causal\s+effect\b",
+            r"\bcausal\s+(?:effect|effects|mediation|mechanism|pathway|relationship|relationships|identification)\b",
+            r"\b(?:demonstrates?|demonstrated|shows?|showed|establishes?|established|identifies?|identified|proves?|proved)\s+(?:a\s+|the\s+)?causal(?:ity|\s+(?:effect|effects|mechanism|pathway|relationship|relationships|mediation))\b",
+        )
+        if any(re.search(pattern, value, flags=re.I) for pattern in affirmative_patterns):
+            return "AFFIRMATIVE_CAUSAL"
+        return "NON_CAUSAL"
 
-        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",
-            r"^\s*(?:claim|claims|interpretation|inference)s?\s+(?:is|are)\s+(?:not|unsupported|unwarranted)\b",
+    @classmethod
+    def classify_quantitative_causal_sentence(cls, sentence):
+        """Three-state causal contract shared by inspection, repair, and tests."""
+        value = str(sentence or "")
+        # Contrast clauses must not let an early disclaimer shield a later assertion.
+        clauses = re.split(
+            r"(?i)(?:;|\bbut\b|\bhowever\b|\bwhereas\b|\byet\b|\bnevertheless\b|\balthough\b|\bthough\b)",
+            value,
         )
-        return any(re.search(pattern, right_folded) for pattern in post_disclaimer_patterns)
+        states = [cls._classify_quantitative_causal_clause(part) for part in clauses if str(part).strip()]
+        if "AFFIRMATIVE_CAUSAL" in states:
+            return "AFFIRMATIVE_CAUSAL"
+        if "EXPLICIT_CAUSAL_LIMITATION" in states:
+            return "EXPLICIT_CAUSAL_LIMITATION"
+        return "NON_CAUSAL"
+
+    @classmethod
+    def _causal_phrase_is_explicitly_disclaimed(cls, sentence, match_start=None, match_end=None):
+        """Compatibility wrapper for older call sites; uses the shared tri-state contract."""
+        return cls.classify_quantitative_causal_sentence(sentence) == "EXPLICIT_CAUSAL_LIMITATION"
 
     @classmethod
     def inspect_quantitative_study_fact_contract(cls, text, metadata, section_name=""):
@@ -668,15 +694,6 @@ Keywords: {keywords}"""
             "mediator": r"(?:mediator|mediating\s+variable|mediating\s+construct)",
             "outcome": r"(?:outcome|dependent\s+variable|outcome\s+construct)",
         }
-        causal_patterns = (
-            r"(?i)\bhad\s+a\s+causal\s+effect\s+on\b",
-            r"(?i)\bexerted\s+a\s+causal\s+effect\s+on\b",
-            r"(?i)\bcausal\s+effect\s+on\b",
-            r"(?i)\b(?:an|a|the)\s+causal\s+effect\b",
-            r"(?i)\bcausal\s+effects\b",
-            r"(?i)\bcausal\s+effect\b",
-            r"(?i)\bcausal\s+mediation\b",
-        )
         violations = []
 
         def add_metric_violations(sentence, pattern, expected, *, dtype="float", label="metric"):
@@ -726,13 +743,18 @@ Keywords: {keywords}"""
                     if pattern.search(sentence):
                         violations.append({"type":"construct_role_mismatch","role":role,"observed":candidate,"expected":expected,"preview":sentence.strip()[:180]})
             if strict:
-                for pattern in causal_patterns:
-                    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
+                causal_state = cls.classify_quantitative_causal_sentence(sentence)
+                if causal_state == "AFFIRMATIVE_CAUSAL":
+                    violations.append({
+                        "type":"causal_language_violation",
+                        "preview":sentence.strip()[:180],
+                        "reason":"The sentence makes an affirmative causal claim that exceeds the cross-sectional observational evidence contract.",
+                        "repair_instruction":(
+                            "Preserve the study meaning but rewrite as association/covariation only. "
+                            "Explicit causal-limit language is allowed, including forms such as "
+                            "'restricted to associations, not causal effects' or 'cannot establish causality'."
+                        ),
+                    })
                 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):
                     violations.append({"type":"unfrozen_p_value","preview":sentence.strip()[:180]})
                 if ownership == "study":
@@ -861,26 +883,17 @@ Keywords: {keywords}"""
                         diagnostics.append({"type":"construct_role_repaired","role":role,"observed":candidate,"expected":expected,"count":count})
 
             if strict:
-                for pattern, replacement in causal_replacements:
-                    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,
-                        })
+                causal_state = cls.classify_quantitative_causal_sentence(revised)
+                if causal_state == "AFFIRMATIVE_CAUSAL":
+                    for pattern, replacement in causal_replacements:
+                        regex = re.compile(pattern)
+                        revised, repaired_count = regex.subn(replacement, 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: