S1-R2 final abstract frozen finding coverage

core/generation_runner.py

@@ -1022,6 +1022,267 @@ class GenerationRunner:
             rows.extend(scope_inspector(text, data_metadata, section_name=section_name) or [])
         return list(rows)
 
+    @staticmethod
+    def _final_abstract_normalized_text(value: str) -> str:
+        """Normalize reader-facing English prose for deterministic finding coverage checks."""
+        return re.sub(r"[^a-z0-9]+", " ", str(value or "").casefold()).strip()
+
+    @classmethod
+    def _final_abstract_identity_present(cls, sentence: str, label: str) -> bool:
+        needle = cls._final_abstract_normalized_text(label)
+        haystack = cls._final_abstract_normalized_text(sentence)
+        return bool(needle and haystack and needle in haystack)
+
+    @staticmethod
+    def _final_abstract_result_sentences(text: str) -> list[str]:
+        """Return sentences that actually assert a frozen empirical finding.
+
+        Deliberately exclude vague contribution language such as "our findings
+        contribute".  A Final Abstract must report what the study found, not
+        merely say that findings exist.
+        """
+        sentences = [
+            part.strip()
+            for part in re.split(r"(?<=[.!?])\s+|\n+", str(text or ""))
+            if str(part or "").strip()
+        ]
+        finding_pattern = re.compile(
+            r"(?i)(?:"
+            r"\b(?:we|the\s+study|the\s+analysis|the\s+results?|our\s+analysis)\s+"
+            r"(?:find|finds|found|show|shows|showed|indicate|indicates|indicated|reveal|reveals|revealed|identify|identifies|identified|support|supports|supported)\b|"
+            r"\bfindings?\s+(?:show|shows|showed|indicate|indicates|indicated|reveal|reveals|revealed|identify|identifies|identified|suggest|suggests|suggested)\b|"
+            r"\b(?:was|were|is|are)\s+(?:positively|negatively|significantly|non[- ]?significantly|not\s+significantly)\s+(?:associated|related)\b|"
+            r"\b(?:association|relationship|interaction|indirect\s+(?:association|effect)|theme|themes|pattern|patterns|mechanism|mechanisms)\b[^.!?]{0,140}\b(?:was|were|is|are|emerged|identified|supported|unsupported|significant|non[- ]?significant|nonzero)\b|"
+            r"\bH\d+\s+(?:was|were|is|are)\s+(?:supported|unsupported|not\s+supported|rejected)\b"
+            r")"
+        )
+        result_sentences = []
+        prospective = re.compile(
+            r"(?i)\b(?:we\s+(?:propose|hypothesize|hypothesise|predict|expect|test)|"
+            r"hypothes(?:is|es|ized|ised)|this\s+study\s+(?:examines|investigates|tests)|"
+            r"we\s+further\s+hypothesize)\b"
+        )
+        retrospective = re.compile(
+            r"(?i)\b(?:results?|findings?\s+(?:show|indicate|reveal|identify|suggest)|"
+            r"analysis\s+(?:show|indicate|reveal|identify)|found|revealed|indicated|"
+            r"supported|unsupported|non[- ]?significant|not\s+significant|nonzero|received\s+no\s+support)\b"
+        )
+        for sentence in sentences:
+            if not finding_pattern.search(sentence):
+                # Explicit frozen-status language can be result-bearing even
+                # without a finite 'was/were' construction.
+                if not re.search(
+                    r"(?i)\b(?:nonzero\s+indirect\s+(?:association|effect)|"
+                    r"unsupported\s+(?:interaction|moderation|association)|"
+                    r"supported\s+(?:interaction|moderation|association))\b",
+                    sentence,
+                ):
+                    continue
+            if prospective.search(sentence) and not retrospective.search(sentence):
+                continue
+            result_sentences.append(sentence)
+        return result_sentences
+
+    @staticmethod
+    def _final_abstract_ci_status(row: dict) -> str:
+        ci = list((row or {}).get("ci") or [])
+        if len(ci) != 2:
+            return ""
+        try:
+            low, high = float(ci[0]), float(ci[1])
+        except (TypeError, ValueError):
+            return ""
+        return "supported" if (low > 0.0 or high < 0.0) else "unsupported"
+
+    @staticmethod
+    def _final_abstract_support_language(sentence: str, status: str) -> bool:
+        value = str(sentence or "")
+        if status == "unsupported":
+            return bool(re.search(
+                r"(?i)\b(?:not\s+supported|unsupported|no\s+support|did\s+not\s+support|"
+                r"non[- ]?significant|not\s+significant|no\s+(?:meaningful\s+)?(?:association|relationship|interaction|moderation|effect|evidence)|"
+                r"did\s+not\s+(?:moderate|differ|vary)|confidence\s+interval[^.!?]{0,80}(?:included|crossed)\s+zero)\b",
+                value,
+            ))
+        if status == "supported":
+            return bool(re.search(
+                r"(?i)\b(?:supported|significant|nonzero|positive(?:ly)?\s+(?:association|associated|relationship|related)|"
+                r"negative(?:ly)?\s+(?:association|associated|relationship|related)|"
+                r"was\s+associated|were\s+associated|was\s+related|were\s+related)\b",
+                value,
+            ))
+        return True
+
+    @classmethod
+    def _final_abstract_finding_violations(
+        cls, mode: str, text: str, data_metadata: dict, *, hypothesis_ledger: dict | None = None
+    ) -> list[dict]:
+        """S1-R2 deterministic Final-Abstract frozen-finding coverage gate.
+
+        The gate is language-neutral at the manuscript-authority layer: English
+        Final Front Matter is frozen once, then ZH/RU/KK are semantic
+        translations of that exact source.  Product tier is intentionally not an
+        input because Standard and Flagship share this correctness contract.
+        """
+        value = str(text or "").strip()
+        meta = dict(data_metadata or {})
+        result_sentences = cls._final_abstract_result_sentences(value)
+        rows: list[dict] = []
+
+        if str(mode or "").strip().lower() == "amj":
+            ledger = dict(hypothesis_ledger or meta.get("hypothesis_ledger") or {})
+            evidence = dict(meta.get("association_results") or {})
+            if not evidence:
+                evidence = dict((meta.get("quantitative_evidence_ledger") or {}).get("association_results") or {})
+            relation_results = dict(evidence.get("relation_results") or {})
+            indirect_results = dict(evidence.get("indirect_results") or {})
+
+            def relation_sentence(item: dict, *, require_status: bool = True) -> bool:
+                relation_id = str(item.get("relation_id") or "")
+                frozen = dict(relation_results.get(relation_id) or {})
+                status = cls._final_abstract_ci_status(frozen)
+                identities = [item.get("predictor"), item.get("outcome")]
+                if str(item.get("relation") or "") == "moderation":
+                    identities.append(item.get("moderator"))
+                for sentence in result_sentences:
+                    if not all(cls._final_abstract_identity_present(sentence, label) for label in identities if label):
+                        continue
+                    if str(item.get("relation") or "") == "moderation" and not re.search(r"(?i)\b(?:moderat|interaction)\w*\b", sentence):
+                        continue
+                    if require_status and status and not cls._final_abstract_support_language(sentence, status):
+                        continue
+                    return True
+                return False
+
+            numbered = [dict(item) for item in (ledger.get("items") or []) if isinstance(item, dict)]
+            unsupported = []
+            moderation = []
+            for item in numbered:
+                frozen = dict(relation_results.get(str(item.get("relation_id") or "")) or {})
+                status = cls._final_abstract_ci_status(frozen)
+                if status == "unsupported":
+                    unsupported.append(item)
+                if str(item.get("relation") or "") == "moderation":
+                    moderation.append(item)
+
+            # Unsupported numbered hypotheses are interpretation-critical and
+            # must never disappear from the Final Abstract.
+            for item in unsupported:
+                if relation_sentence(item, require_status=True):
+                    continue
+                rows.append({
+                    "type": "final_abstract_missing_unsupported_finding",
+                    "hypothesis_id": str(item.get("hypothesis_id") or ""),
+                    "reason": (
+                        "The Final Abstract omits the frozen unsupported/non-significant status of a numbered hypothesis."
+                    ),
+                    "repair_instruction": (
+                        "State the unsupported finding concisely in ordinary results language, preserving the exact construct identities. "
+                        "Do not add coefficients unless indispensable."
+                    ),
+                })
+
+            # A focal moderation result is a main boundary-condition finding even
+            # when supported; require one moderation result sentence when present.
+            if moderation and not any(relation_sentence(item, require_status=True) for item in moderation):
+                item = moderation[0]
+                rows.append({
+                    "type": "final_abstract_missing_moderation_finding",
+                    "hypothesis_id": str(item.get("hypothesis_id") or ""),
+                    "reason": "The Final Abstract does not report the frozen moderation/interaction finding.",
+                    "repair_instruction": (
+                        "Report whether the frozen moderator changed the focal association, using the exact predictor, moderator, and outcome identities. "
+                        "Keep the statement concise and evidence-bounded."
+                    ),
+                })
+
+            # Preserve the main mechanism finding when an indirect analysis was
+            # actually compiled.  If several unnumbered paths exist, one main
+            # frozen path is sufficient; numbered indirect hypotheses remain
+            # independently governed by the hypothesis contract.
+            indirect_rows = [dict(item) for item in (ledger.get("indirect_analyses") or []) if isinstance(item, dict)]
+            if indirect_rows:
+                selected = next((item for item in indirect_rows if item.get("numbered_hypothesis")), indirect_rows[0])
+                effect = dict(indirect_results.get(str(selected.get("effect_id") or "")) or {})
+                status = cls._final_abstract_ci_status(effect)
+                path = list(selected.get("path") or [])
+                indirect_found = False
+                for sentence in result_sentences:
+                    if not re.search(r"(?i)\b(?:indirect|mediat)\w*\b", sentence):
+                        continue
+                    required_labels = []
+                    if path:
+                        required_labels.extend([path[0], path[-1]])
+                        if len(path) > 2:
+                            required_labels.append(path[1])
+                    if required_labels and not all(cls._final_abstract_identity_present(sentence, x) for x in required_labels if x):
+                        continue
+                    if status and not cls._final_abstract_support_language(sentence, status):
+                        continue
+                    indirect_found = True
+                    break
+                if not indirect_found:
+                    rows.append({
+                        "type": "final_abstract_missing_indirect_finding",
+                        "reason": "The Final Abstract omits the main frozen indirect/mediation finding.",
+                        "repair_instruction": (
+                            "Summarize the frozen indirect association through the identified mediator in one concise findings sentence. "
+                            "Do not claim causal mediation for observational data and do not add unnecessary statistics."
+                        ),
+                    })
+
+            # Every empirical Final Abstract needs at least one actual result
+            # sentence.  Design/hypothesis prose plus 'our findings contribute'
+            # is not sufficient.
+            if relation_results and not result_sentences:
+                rows.append({
+                    "type": "final_abstract_missing_empirical_finding",
+                    "reason": "The Final Abstract describes the design/hypotheses but states no frozen empirical result.",
+                    "repair_instruction": (
+                        "Add one or two concise sentences stating the main frozen empirical findings before the contribution. "
+                        "Prefer support/non-support and substantive direction over a list of coefficients."
+                    ),
+                })
+            return rows
+
+        if str(mode or "").strip().lower() == "asq":
+            themes = [dict(item) for item in (meta.get("themes") or []) if isinstance(item, dict)]
+            if not themes:
+                if not result_sentences:
+                    rows.append({
+                        "type": "final_abstract_missing_qualitative_finding",
+                        "reason": "The Final Abstract states no empirical qualitative finding.",
+                        "repair_instruction": "Add a concise findings sentence grounded in the frozen qualitative evidence; do not invent a theme or process claim.",
+                    })
+                return rows
+
+            covered = set()
+            for index, theme in enumerate(themes):
+                anchors = [str(theme.get("title") or "").strip()]
+                anchors.extend(str(x or "").strip() for x in (theme.get("concepts") or []))
+                anchors = [x for x in anchors if x]
+                for sentence in result_sentences:
+                    if any(cls._final_abstract_identity_present(sentence, anchor) for anchor in anchors):
+                        covered.add(index)
+                        break
+            required = min(2, len(themes))
+            if len(covered) < required:
+                rows.append({
+                    "type": "final_abstract_missing_qualitative_theme_findings",
+                    "observed": len(covered),
+                    "expected": required,
+                    "reason": (
+                        "The Final Abstract does not report enough frozen qualitative theme/concept findings to function as a results-bearing final abstract."
+                    ),
+                    "repair_instruction": (
+                        f"State the main qualitative findings in one or two concise sentences grounded in at least {required} frozen theme/concept identities. "
+                        "Do not merely say that findings contribute, and do not invent themes, quotations, participants, or procedures."
+                    ),
+                })
+            return rows
+
+        return rows
+
     @staticmethod
     def _section_retry_feedback(violations, *, limit=8) -> str:
         rows = []
@@ -1090,6 +1351,12 @@ class GenerationRunner:
             "unsupported_moderation_claim", "unsupported_mediation_claim", "unsupported_temporal_scope",
             "unsupported_design_tradition", "unsupported_unit_of_analysis", "unsupported_data_source_claim",
             "unsupported_process_claim",
+            "final_abstract_missing_empirical_finding",
+            "final_abstract_missing_unsupported_finding",
+            "final_abstract_missing_moderation_finding",
+            "final_abstract_missing_indirect_finding",
+            "final_abstract_missing_qualitative_finding",
+            "final_abstract_missing_qualitative_theme_findings",
         }
         if kind in always_fatal:
             return "FATAL"
@@ -1408,6 +1675,10 @@ class GenerationRunner:
                 rows.extend(self._hypothesis_contract_violations(
                     repaired, hypothesis_ledger, section_name=label
                 ))
+            if str(label or "").strip().casefold() == "final abstract":
+                rows.extend(self._final_abstract_finding_violations(
+                    mode, repaired, data_metadata, hypothesis_ledger=hypothesis_ledger
+                ))
             current, remaining = repaired, rows
             if not remaining:
                 return current, []
@@ -5354,6 +5625,9 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 final_front_fact_rows.extend(self._hypothesis_contract_violations(
                     final_abstract, hypothesis_ledger, section_name="Final Abstract"
                 ))
+            final_front_fact_rows.extend(self._final_abstract_finding_violations(
+                mode, final_abstract, data_metadata, hypothesis_ledger=hypothesis_ledger
+            ))
             if final_front_fact_rows:
                 feedback = self._section_retry_feedback(final_front_fact_rows)
                 logging.warning(
@@ -5386,6 +5660,9 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     remaining_final_fact_rows.extend(self._hypothesis_contract_violations(
                         final_abstract, hypothesis_ledger, section_name="Final Abstract"
                     ))
+                remaining_final_fact_rows.extend(self._final_abstract_finding_violations(
+                    mode, final_abstract, data_metadata, hypothesis_ledger=hypothesis_ledger
+                ))
                 if remaining_final_fact_rows:
                     final_abstract, residual_final_rows = self._adaptive_repair_front_matter(
                         agent=agent, quant_engine=quant_engine, abstract_text=final_abstract,
@@ -5394,6 +5671,10 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                         quality_notes=quality_notes, label="Final Abstract",
                     )
                     if residual_final_rows:
+                        self._raise_if_fatal_completion_residual(
+                            residual_final_rows, section_name="Final Abstract", mode=mode,
+                            error_code="final_abstract_finding_contract_unresolved"
+                        )
                         logging.warning("Adaptive Final Abstract accepted with residual diagnostics | count=%s", len(residual_final_rows))
                 quality_diagnostics.append({
                     "scope":"final_abstract_study_fact_integrity", "name":"Final Abstract",