S0-R1-C5.5-R6-R1 Unified Semantic Claim Frame

core/pipeline_agent.py

@@ -75,6 +75,7 @@ class SSciPipelineAgent:
     MAX_TRANSLATION_CLAIM_TOTAL_REPAIRS = 6
     PROTECTED_ENTITY_LEDGER_VERSION = 'protected-entity-ledger-v2'
     CANONICAL_GLOSSARY_QUALITY_VERSION = 'canonical-glossary-quality-v1'
+    SEMANTIC_CLAIM_FRAME_VERSION = 'smartpaper-core-semantic-claim-frame-v1'
 
     @staticmethod
     def _translation_defect_family(codes):
@@ -4014,12 +4015,21 @@ INPUT:
         External literature and participant quotations are excluded.
         """
         value = str(text or "")
-        facts = dict((metadata or {}).get("study_facts") or {})
-        relations = [row for row in (facts.get("data_source_roles") or []) if isinstance(row, dict)]
+        meta = dict(metadata or {})
+        facts = dict(meta.get("study_facts") or {})
+        semantic_frame = meta.get("semantic_claim_frame") if isinstance(meta.get("semantic_claim_frame"), dict) else None
+        if not semantic_frame:
+            try:
+                from core.qualitative_engine import QualitativeEngine
+                semantic_frame = QualitativeEngine.build_qualitative_semantic_claim_frame(meta)
+            except Exception:
+                semantic_frame = None
+        frame_relations = list((semantic_frame or {}).get("actor_data_source_relations") or [])
+        relations = frame_relations or [row for row in (facts.get("data_source_roles") or []) if isinstance(row, dict)]
         allowed_by_actor = {}
         for row in relations:
             role = re.sub(r"\s+", " ", str(row.get("actor_role") or "")).strip()
-            family = cls._qual_source_family(row.get("data_source"))
+            family = str(row.get("source_family") or "").strip() or cls._qual_source_family(row.get("data_source"))
             if not role or not family:
                 continue
             for variant in cls._qual_actor_variants(role):
@@ -6214,6 +6224,63 @@ TEXT:
             r'|\|'
         )
 
+    @classmethod
+    def _source_semantic_claim_frame(cls, source_claim):
+        """Derive a conservative language-neutral frame once from frozen English.
+
+        This frame is not a substitute for bilingual QA.  It is an immutable
+        source-side contract that target-language QA must preserve, preventing
+        ZH/RU/KK from independently reinterpreting polarity, causal strength, or
+        modality on every retry/resume.
+        """
+        text = re.sub(r"\s+", " ", str(source_claim or "")).strip()
+        folded = text.casefold()
+        causal = bool(re.search(
+            r"\b(?:causes?|caused|causing|leads?\s+to|led\s+to|drives?|drove|driven|determines?|determined|"
+            r"produces?|produced|results?\s+in|resulted\s+in|yields?|yielded|generates?|generated|"
+            r"causal(?:ity|\s+(?:effect|effects|mediation|mechanism|pathway|relationship|relationships)))\b",
+            folded, flags=re.I,
+        ))
+        association = bool(re.search(
+            r"\b(?:association|associations|associated|correlation|correlations|correlated|covariation|covariance|indirect\s+association)\b",
+            folded, flags=re.I,
+        ))
+        scalar_not = bool(re.search(r"\bnot\s+(?:only|merely|solely|exclusively|primarily|mainly)\b", folded, flags=re.I))
+        negative = False
+        if not scalar_not:
+            negative = bool(re.search(
+                r"\b(?:cannot|can't|could\s+not|couldn't|does\s+not|doesn't|do\s+not|don't|did\s+not|didn't|never|"
+                r"is\s+not|are\s+not|was\s+not|were\s+not|no\s+(?:evidence|basis|support|proof)|without\s+(?:evidence|support|identifying|establishing|demonstrating|showing|inferring))\b",
+                folded, flags=re.I,
+            ))
+        if causal and negative:
+            polarity = "NEGATIVE"
+            causal_strength = "CAUSAL_LIMITATION"
+        elif causal:
+            polarity = "AFFIRMATIVE"
+            causal_strength = "CAUSAL_ASSERTION"
+        elif association:
+            polarity = "NONE"
+            causal_strength = "ASSOCIATIONAL"
+        else:
+            polarity = "NONE"
+            causal_strength = "DESCRIPTIVE"
+        if re.search(r"\b(?:may|might|could|appears?\s+to|seems?\s+to|suggests?|consistent\s+with)\b", folded) and not re.search(r"\bcould\s+not\b", folded):
+            modality = "HEDGED"
+        elif negative and causal:
+            modality = "LIMITATION"
+        else:
+            modality = "ASSERTED"
+        frame = {
+            "version": cls.SEMANTIC_CLAIM_FRAME_VERSION,
+            "polarity": polarity,
+            "causal_strength": causal_strength,
+            "modality": modality,
+        }
+        canonical = json.dumps(frame, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        frame["frame_hash"] = hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+        return frame
+
     @classmethod
     def _translation_claim_units(cls, value):
         """Create stable source-side claim IDs without constraining target punctuation."""
@@ -7165,6 +7232,7 @@ SECTION: {section_name}
                     'claim_id': claim_id,
                     'english': item['text'],
                     'target': target_claims[claim_id],
+                    'source_semantic_frame': self._source_semantic_claim_frame(item['text']),
                 })
 
         issues = {}
@@ -7182,12 +7250,12 @@ SECTION: {section_name}
                 'target_language': target_lang,
                 'glossary': relevant_glossary,
                 'allowed_issue_codes': sorted(allowed_codes),
-                'items': [{'id': row['id'], 'english': row['english'], 'target': row['target']} for row in rows],
+                'items': [{'id': row['id'], 'english': row['english'], 'target': row['target'], 'source_semantic_frame': row['source_semantic_frame']} for row in rows],
             }
             profile = self._translation_language_profile(target_lang)
             lexical_contract = self._translation_lexical_retention_contract(target_lang)
             system_prompt = f"""You are a bilingual academic translation QA classifier for {target_lang}.
-Review EACH claim independently. Do not rewrite and do not provide free-form explanations. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
+Review EACH claim independently. Do not rewrite and do not provide free-form explanations. The supplied source_semantic_frame is server-frozen source authority: the target must preserve its polarity, causal_strength, and modality. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
 LANGUAGE ADAPTER: {profile['adapter_id']}; morphology={profile['morphology']}. {profile['term_policy']} {lexical_contract} {profile['contamination_policy']}
 For Russian, do not flag a terminology error merely because a translated term is inflected for grammatical case/number/gender; sustained non-Russian prose remains an additional contamination signal. For Kazakh, do not flag a terminology error merely because productive suffixes attach to the correct term stem; clearly Russian lexical/syntactic intrusion remains an additional language-specific signal when the pair supports that conclusion. Cyrillic script or absence of Kazakh-specific letters alone is never sufficient evidence.
 Return valid JSON only in this exact form: {{"items":[{{"id":"SP-P000001-C000001","ok":true,"codes":[],"evidence_codes":[]}}]}}.
@@ -7599,10 +7667,21 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             block_id: self._model_safe_translation_manifest(protected_maps.get(block_id, {}))
             for block_id, _source, _protected in protected_batch
         }
+        claim_semantic_manifest = {
+            block_id: {
+                claim_id: self._source_semantic_claim_frame(source_claim)
+                for claim_id, source_claim in dict(claim_sources_by_block.get(block_id) or {}).items()
+            }
+            for block_id, _source, _protected in protected_batch
+        }
         effective_prompt = system_prompt + (
             '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
             + json.dumps(semantic_manifest, ensure_ascii=False)
             + '\n</SEMANTIC_ANCHOR_MANIFEST>\n'
+            + '<SOURCE_SEMANTIC_CLAIM_FRAMES>\n'
+            + json.dumps(claim_semantic_manifest, ensure_ascii=False)
+            + '\n</SOURCE_SEMANTIC_CLAIM_FRAMES>\n'
+              'The source semantic claim frames are server-frozen. Preserve polarity, causal strength, and modality for each SP-C claim exactly; do not strengthen an association into causation or drop a negation/hedge. '
               'This manifest intentionally contains no factual values. Preserve every SP-P, SP-C, and SP-T marker exactly. '
               'Each SP-C marker identifies one source claim. A target claim may contain one or more grammatical sentences, but every protected fact must remain inside its original SP-C claim. '
               'Never infer, spell out, calculate, or recreate a hidden number, date, citation, acronym, name, formula, or identifier. Do not print the manifest.'
@@ -7935,6 +8014,8 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                     'block_id': str(block_id),
                     'claim_id': str(claim_id),
                     'source_hash': hashlib.sha256(str(item['text']).encode('utf-8')).hexdigest(),
+                    'semantic_frame': cls._source_semantic_claim_frame(item['text']),
+                    'semantic_frame_hash': cls._source_semantic_claim_frame(item['text']).get('frame_hash', ''),
                     'target_text': target_text,
                     'qa_status': 'repair_pending' if codes else 'passed',
                     'issue_codes': [str(code or '').strip().upper() for code in codes if str(code or '').strip()][:5],
@@ -7964,8 +8045,15 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                 key = f'SP-P{block_id}-{claim_id}'
                 row = states.get(key)
                 expected_hash = hashlib.sha256(str(item['text']).encode('utf-8')).hexdigest()
+                expected_semantic_hash = cls._source_semantic_claim_frame(item['text']).get('frame_hash', '')
                 if not isinstance(row, dict) or row.get('source_hash') != expected_hash or not str(row.get('target_text') or '').strip():
                     return {}, {}, False
+                # R6-R1: new states are semantic-frame bound.  Pre-R6 states do
+                # not carry this optional field and retain legacy fail-closed
+                # repair history instead of being silently "revived".
+                stored_semantic_hash = str(row.get('semantic_frame_hash') or '')
+                if stored_semantic_hash and stored_semantic_hash != expected_semantic_hash:
+                    return {}, {}, False
                 segments[claim_id] = str(row.get('target_text') or '').strip()
                 if str(row.get('qa_status') or '') == 'repair_pending':
                     codes = [str(code or '').strip().upper() for code in (row.get('issue_codes') or []) if str(code or '').strip()]

core/qualitative_engine.py

@@ -14,6 +14,7 @@ from config import APP_CONFIG
 class QualitativeEngine:
     QUALITATIVE_APPENDIX_MANIFEST_VERSION = "qualitative-appendix-manifest-v1"
     TARGET_APPENDIX_BINDING_VERSION = "target-qualitative-appendix-binding-v1"
+    SEMANTIC_CLAIM_FRAME_VERSION = "smartpaper-core-semantic-claim-frame-v1"
     APPENDIX_FIELDS = ("theme", "concept", "stage", "case_label", "evidence_role")
     APPENDIX_HEADERS = (
         "Higher-order Theme", "Empirical Concept", "Process Stage",
@@ -94,6 +95,91 @@ class QualitativeEngine:
                 rows.append(row)
         return rows
 
+    @classmethod
+    def build_qualitative_semantic_claim_frame(cls, metadata):
+        """Freeze actor/source, process-evidence, and quote identities in one frame.
+
+        The frame is server-side authority.  It contains no model-inferred prose
+        meaning and no verbatim quotation payload, only typed identities/hashes.
+        """
+        meta = dict(metadata or {})
+        facts = dict(meta.get("study_facts") or {})
+        relations = []
+        for row in cls._normalize_data_source_roles(facts.get("data_source_roles") or []):
+            actor = cls._clean_cell(row.get("actor_role"), "")
+            source = cls._clean_cell(row.get("data_source"), "")
+            folded = source.casefold()
+            if "interview" in folded:
+                family = "interview"
+            elif "focus" in folded and "group" in folded:
+                family = "focus_group"
+            elif "observ" in folded:
+                family = "observation"
+            elif "log" in folded:
+                family = "log"
+            elif "document" in folded or "archiv" in folded or "record" in folded:
+                family = "document"
+            else:
+                family = "other"
+            relation = {
+                "actor_role": actor,
+                "data_source": source,
+                "source_family": family,
+                "count": row.get("count"),
+                "relation": "EVIDENCED_BY",
+            }
+            relation_id_payload = json.dumps(relation, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+            relation["relation_id"] = hashlib.sha256(relation_id_payload.encode("utf-8")).hexdigest()[:16]
+            relations.append(relation)
+
+        quotes = []
+        for item in meta.get("evidence") or []:
+            if not isinstance(item, dict):
+                continue
+            quote_id = str(item.get("tag") or "").strip()
+            if not re.fullmatch(r"QUOTE-\d+", quote_id):
+                continue
+            quote_hash = str(item.get("quote_hash") or "").strip()
+            if not quote_hash and str(item.get("quote") or "").strip():
+                normalized = re.sub(r"\s+", " ", str(item.get("quote") or "")).strip()
+                quote_hash = hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+            quotes.append({
+                "quote_id": quote_id,
+                "quote_hash": quote_hash,
+                "theme_id": str(item.get("theme_id") or "").strip(),
+                "stage": cls._clean_cell(item.get("stage")),
+                "case_label": cls._clean_cell(item.get("case_label")),
+                "evidence_role": str(item.get("evidence_role") or "typical").strip().lower(),
+            })
+
+        process_evidence = []
+        for theme in meta.get("themes") or []:
+            if not isinstance(theme, dict):
+                continue
+            theme_id = str(theme.get("theme_id") or "").strip()
+            if not theme_id:
+                continue
+            process_evidence.append({
+                "theme_id": theme_id,
+                "stages": [cls._clean_cell(x, "") for x in (theme.get("stages") or []) if cls._clean_cell(x, "")],
+                "has_deviant_evidence": bool(theme.get("has_deviant_evidence")),
+                "quote_ids": [
+                    str(row.get("tag") or "").strip()
+                    for row in (theme.get("evidence") or []) if isinstance(row, dict) and str(row.get("tag") or "").strip()
+                ],
+            })
+
+        frame = {
+            "version": cls.SEMANTIC_CLAIM_FRAME_VERSION,
+            "mode": "qualitative",
+            "actor_data_source_relations": sorted(relations, key=lambda row: (row["actor_role"].casefold(), row["data_source"].casefold())),
+            "process_evidence": sorted(process_evidence, key=lambda row: row["theme_id"]),
+            "quote_identities": sorted(quotes, key=lambda row: row["quote_id"]),
+        }
+        canonical = json.dumps(frame, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        frame["frame_hash"] = hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+        return frame
+
     @classmethod
     def build_scoped_evidence_md(
         cls,
@@ -862,6 +948,7 @@ Rules:
             "evidence": clean_evidence,
             "themes": themes,
         }
+        metadata["semantic_claim_frame"] = self.build_qualitative_semantic_claim_frame(metadata)
         status_message = "✅ 定性研究事实��分析设计与证据结构已冻结。"
         return md, status_message, metadata
 

core/quantitative_engine.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import json
 import logging
 import re
@@ -21,6 +22,7 @@ class QuantitativeEngine:
     QUANTITATIVE_TABLE_MANIFEST_VERSION = "quantitative-table-manifest-v1"
     HYPOTHESIS_LEDGER_VERSION = "quantitative-hypothesis-ledger-v1"
     TARGET_TABLE_BINDING_VERSION = "target-quantitative-table-binding-v1"
+    SEMANTIC_CLAIM_FRAME_VERSION = "smartpaper-core-semantic-claim-frame-v1"
 
     _TARGET_TABLE_LOCALIZATION = {
         "zh": {
@@ -859,6 +861,130 @@ Keywords: {keywords}"""
             ] if strict else [],
         }
 
+    @staticmethod
+    def _semantic_frame_hash(payload):
+        canonical = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+    @classmethod
+    def build_quantitative_semantic_claim_frame(cls, sentence, metadata=None, section_name=""):
+        """Freeze a compact server-side semantic frame for one quantitative claim.
+
+        R6-R1 does not ask the model to decide this frame.  It records the
+        source-side claim role, causal polarity/strength, methodological domain,
+        hypothesis identity, and explicit result direction so downstream
+        validation/translation can inherit one stable semantic authority.
+        """
+        text = re.sub(r"\s+", " ", str(sentence or "")).strip()
+        folded = text.casefold()
+        meta = dict(metadata or {})
+        ledger = dict(meta.get("quantitative_evidence_ledger") or {})
+        if not ledger and meta:
+            try:
+                ledger = cls.build_quantitative_evidence_ledger(meta)
+            except Exception:
+                ledger = {}
+        constructs = dict(ledger.get("constructs") or {})
+        known_constructs = [str(value) for value in constructs.values() if str(value)]
+        ownership = cls._quantitative_sentence_ownership(text, section_name, known_constructs) if text else "other"
+
+        relation_specs = (
+            (r"\b(?:causes?|caused|causing)\b", "CAUSE"),
+            (r"\b(?:leads?|led)\s+to\b", "LEAD_TO"),
+            (r"\b(?:drives?|drove|driven)\b", "DRIVE"),
+            (r"\b(?:determines?|determined)\b", "DETERMINE"),
+            (r"\b(?:produces?|produced)\b", "PRODUCE"),
+            (r"\b(?:results?|resulted)\s+in\b", "RESULT_IN"),
+            (r"\b(?:yields?|yielded)\b", "YIELD"),
+            (r"\b(?:generates?|generated)\b", "GENERATE"),
+            (r"\bcausal(?:ity|\s+(?:effect|effects|mediation|mechanism|pathway|relationship|relationships|identification))\b", "CAUSAL_NOUN"),
+        )
+        relation = "NONE"
+        for pattern, label in relation_specs:
+            if re.search(pattern, folded, flags=re.I):
+                relation = label
+                break
+
+        methodological_bias = cls._is_methodological_bias_mechanism_sentence(text, known_constructs)
+        robustness_scope = bool(re.search(
+            r"\b(?:robustness|sensitivity|spearman|rank[- ]order|extreme\s+values?|outliers?|influential\s+(?:cases|observations)|"
+            r"response\s+styles?|common\s+method|same[- ]source|single\s+questionnaire|measurement\s+(?:error|bias))\b",
+            folded, flags=re.I,
+        ))
+        if methodological_bias:
+            domain = "METHODOLOGICAL_BIAS"
+        elif robustness_scope:
+            domain = "METHODOLOGICAL_ROBUSTNESS"
+        elif re.search(r"\b(?:analysis|analyses|bootstrap|regression|correlation|estimation|statistical\s+(?:test|model|analysis)|vif)\b", folded):
+            domain = "ANALYTICAL_REPORTING"
+        elif any(name.casefold() in folded for name in known_constructs):
+            domain = "SUBSTANTIVE_CONSTRUCT"
+        else:
+            domain = "GENERAL"
+
+        raw_causal_state = cls.classify_quantitative_causal_sentence(text) if text else "NON_CAUSAL"
+        validation_state = "NON_CAUSAL" if methodological_bias else raw_causal_state
+        if raw_causal_state == "EXPLICIT_CAUSAL_LIMITATION":
+            polarity = "NEGATIVE"
+            causal_strength = "CAUSAL_LIMITATION"
+        elif raw_causal_state == "AFFIRMATIVE_CAUSAL":
+            polarity = "AFFIRMATIVE"
+            causal_strength = "CAUSAL_ASSERTION"
+        elif re.search(r"\b(?:association|associations|associated|correlation|correlations|correlated|covariation|covariance)\b", folded):
+            polarity = "NONE"
+            causal_strength = "ASSOCIATIONAL"
+        else:
+            polarity = "NONE"
+            causal_strength = "NON_CAUSAL"
+
+        if re.search(r"\b(?:may|might|could|appears?\s+to|seems?\s+to|suggests?|consistent\s+with)\b", folded) and not re.search(r"\bcould\s+not\b", folded):
+            modality = "HEDGED"
+        elif raw_causal_state == "EXPLICIT_CAUSAL_LIMITATION":
+            modality = "LIMITATION"
+        else:
+            modality = "ASSERTED"
+
+        hypothesis_ids = sorted(set(re.findall(r"(?i)\bH\d+[A-Za-z]?\b", text)), key=str.casefold)
+        if re.search(r"\b(?:non[- ]?significant|not\s+significant|did\s+not\s+support|was\s+not\s+supported)\b", folded):
+            result_direction = "NOT_SUPPORTED_OR_NONSIGNIFICANT"
+        elif re.search(r"\b(?:positive|positively)\b[^.;]{0,80}\b(?:association|associated|relationship|correlation|estimate|coefficient)\b", folded):
+            result_direction = "POSITIVE"
+        elif re.search(r"\b(?:negative|negatively)\b[^.;]{0,80}\b(?:association|associated|relationship|correlation|estimate|coefficient)\b", folded):
+            result_direction = "NEGATIVE"
+        else:
+            result_direction = "UNSPECIFIED"
+
+        if hypothesis_ids:
+            claim_type = "HYPOTHESIS_CLAIM"
+        elif domain in {"METHODOLOGICAL_BIAS", "METHODOLOGICAL_ROBUSTNESS"}:
+            claim_type = "METHODOLOGICAL_CLAIM"
+        elif ownership == "result":
+            claim_type = "RESULT_CLAIM"
+        elif causal_strength == "ASSOCIATIONAL":
+            claim_type = "ASSOCIATION_CLAIM"
+        elif raw_causal_state != "NON_CAUSAL":
+            claim_type = "CAUSAL_SCOPE_CLAIM"
+        else:
+            claim_type = "OTHER"
+
+        frame = {
+            "version": cls.SEMANTIC_CLAIM_FRAME_VERSION,
+            "mode": "quantitative",
+            "claim_type": claim_type,
+            "ownership": ownership,
+            "domain": domain,
+            "relation": relation,
+            "polarity": polarity,
+            "causal_strength": causal_strength,
+            "causal_state": raw_causal_state,
+            "validation_state": validation_state,
+            "modality": modality,
+            "hypothesis_ids": hypothesis_ids,
+            "result_direction": result_direction,
+        }
+        frame["frame_hash"] = cls._semantic_frame_hash(frame)
+        return frame
+
     @classmethod
     def _classify_quantitative_causal_clause(cls, clause):
         """Classify one clause by causal *assertion scope*, not token presence.
@@ -987,6 +1113,33 @@ Keywords: {keywords}"""
 
         def direct_match_is_disclaimed(match):
             prefix = value[max(0, match.start() - 220):match.start()]
+            suffix = value[match.end():min(len(value), match.end() + 220)]
+
+            # R6-R1 predicate polarity closure: passive negation is a semantic
+            # limitation ("associations are not driven by outliers"), not an
+            # affirmative causal claim.  Do not exempt contrastive constructions
+            # that merely replace one asserted cause with another ("not driven by
+            # X but rather by Y") or scalar forms such as "not only driven".
+            passive_negative = bool(re.search(
+                r"\b(?:is|are|was|were|be|been|being)\s+"
+                r"(?:(?:clearly|necessarily|directly|statistically)\s+){0,2}"
+                r"(?:not|never)\s+"
+                r"(?:(?:clearly|necessarily|directly|statistically)\s+){0,2}$",
+                prefix, flags=re.I,
+            ))
+            if passive_negative:
+                alternate_cause = re.search(
+                    r"\b(?:but|rather|instead)\b\s*(?:rather\s+|instead\s+|also\s+)?by\b",
+                    suffix, flags=re.I,
+                )
+                alternate_negated = re.search(
+                    r"\b(?:but|rather|instead)\b\s*(?:also\s+)?(?:not|never)\s+by\b",
+                    suffix, flags=re.I,
+                )
+                if alternate_cause and not alternate_negated:
+                    return False
+                return True
+
             if re.search(
                 r"(?:\b(?:does|do|did|can|could|would|should|must|may|might)\s+not|"
                 r"\bcannot|\bcan't|\bcouldn't|\bnever)\s+(?:\w+\s+){0,2}$",
@@ -1074,6 +1227,22 @@ Keywords: {keywords}"""
     def classify_quantitative_causal_sentence(cls, sentence):
         """Three-state causal contract shared by inspection, repair, and tests."""
         value = str(sentence or "")
+        folded = re.sub(r"\s+", " ", value).strip().casefold()
+        # A negated passive can still assert an alternative cause: "not driven
+        # by X but rather by Y".  Detect this before contrast-clause splitting,
+        # otherwise the second fragment loses the causal predicate surface.
+        alternate_cause = re.search(
+            r"\b(?:is|are|was|were|be|been|being)\s+"
+            r"(?:(?:clearly|necessarily|directly|statistically)\s+){0,2}"
+            r"(?:not|never)\s+"
+            r"(?:(?:clearly|necessarily|directly|statistically)\s+){0,2}"
+            r"(?:caused|driven|determined|produced|generated|yielded)\b"
+            r"[^.;]{0,180}\b(?:but|rather|instead)\b\s*"
+            r"(?:rather\s+|instead\s+|also\s+)?by\b",
+            folded, flags=re.I,
+        )
+        if alternate_cause:
+            return "AFFIRMATIVE_CAUSAL"
         # 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)",
@@ -1206,10 +1375,10 @@ Keywords: {keywords}"""
                 methodological_bias_scope = cls._is_methodological_bias_mechanism_sentence(
                     sentence, known_constructs
                 )
-                causal_state = (
-                    "NON_CAUSAL" if methodological_bias_scope
-                    else cls.classify_quantitative_causal_sentence(sentence)
+                semantic_frame = cls.build_quantitative_semantic_claim_frame(
+                    sentence, meta, section_name
                 )
+                causal_state = str(semantic_frame.get("validation_state") or "NON_CAUSAL")
                 if causal_state == "AFFIRMATIVE_CAUSAL":
                     violations.append({
                         "type":"causal_language_violation",
@@ -1580,6 +1749,7 @@ Keywords: {keywords}"""
                 "Frozen bootstrap and collinearity checks",
             ],
         }
+        metadata["semantic_claim_frame_version"] = self.SEMANTIC_CLAIM_FRAME_VERSION
         metadata["hypothesis_ledger"] = self.build_hypothesis_ledger(construct_names)
         metadata["quantitative_table_manifest"] = self.build_table_manifest(
             validity_df, fl_matrix_df, path_table, spearman