S1-R3A Final Abstract Resilience + RU-KK Title Fallback

core/generation_runner.py

@@ -1053,7 +1053,8 @@ class GenerationRunner:
             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"\bH\d+\s+(?:was|were|is|are)\s+(?:supported|unsupported|not\s+supported|rejected)\b|"
+            r"\bdid\s+not\s+(?:significantly\s+)?(?:moderate|mediate|change|alter)\b"
             r")"
         )
         result_sentences = []
@@ -1065,7 +1066,8 @@ class GenerationRunner:
         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"
+            r"supported|unsupported|non[- ]?significant|not\s+significant|nonzero|received\s+no\s+support|"
+            r"did\s+not\s+(?:significantly\s+)?(?:moderate|mediate|change|alter))\b"
         )
         for sentence in sentences:
             if not finding_pattern.search(sentence):
@@ -1100,8 +1102,10 @@ class GenerationRunner:
         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",
+                r"non[- ]?significant|not\s+significant|not\s+significantly\s+(?:associated|related)|"
+                r"no\s+(?:meaningful\s+)?(?:association|relationship|interaction|moderation|effect|evidence)|"
+                r"did\s+not\s+(?:significantly\s+)?(?:moderate|mediate|differ|vary|change|alter)|"
+                r"confidence\s+interval[^.!?]{0,80}(?:included|crossed)\s+zero)\b",
                 value,
             ))
         if status == "supported":
@@ -1113,6 +1117,232 @@ class GenerationRunner:
             ))
         return True
 
+    @staticmethod
+    def _final_abstract_metric_light(text: str) -> tuple[str, list[dict]]:
+        """Remove nonessential inferential statistics from a Final Abstract.
+
+        This is a completion-resilience transform, not a correctness waiver.
+        It is used only after a frozen Final Abstract has already been generated
+        and a strict study-fact validator reports a metric-specific defect.  The
+        substantive finding sentence is preserved while beta/CI/p-value detail
+        that is optional in an abstract is removed.  Sample-size/design facts are
+        intentionally untouched.
+        """
+        value = str(text or "")
+        original = value
+
+        # Parenthetical inferential bundles are the common case:
+        #   (β = .21, 95% CI [...], p = .03)
+        metric_bundle = re.compile(
+            r"\s*\((?=[^()]{0,220}(?:β|standardized\s+estimate|(?:\d{2}%\s*)?CI\b|confidence\s+interval|\bp\s*[=<>]))[^()]*\)",
+            flags=re.I,
+        )
+        value = metric_bundle.sub("", value)
+
+        # Bare inline statistics are also optional in the abstract. Keep the
+        # surrounding finding language and remove only the metric surface.
+        value = re.sub(
+            r"(?i)(?:,\s*)?(?:β|standardized\s+estimate)\s*(?:=|:)?\s*[-+]?\d+(?:\.\d+)?",
+            "",
+            value,
+        )
+        value = re.sub(
+            r"(?i)(?:,\s*)?(?:\d{2}%\s*)?(?:CI|confidence\s+interval)\s*[:=]?\s*[\[(][^\])]{1,80}[\])]?",
+            "",
+            value,
+        )
+        value = re.sub(r"(?i)(?:,\s*)?\bp\s*(?:=|<|>)\s*\.?\d+(?:\.\d+)?", "", value)
+
+        # Typography cleanup only; never alter construct identities or finding
+        # polarity/support language.
+        value = re.sub(r"\s+,", ",", value)
+        value = re.sub(r",\s*,+", ",", value)
+        value = re.sub(r"\(\s*\)", "", value)
+        value = re.sub(r"\s+([.;:])", r"\1", value)
+        value = re.sub(r" {2,}", " ", value)
+        value = re.sub(r"\n{3,}", "\n\n", value).strip()
+
+        diagnostics = []
+        if value != original.strip():
+            diagnostics.append({
+                "type": "final_abstract_metric_light_recovery",
+                "reason": (
+                    "Optional inferential statistics were removed from the Final Abstract after strict metric validation could not safely bind them."
+                ),
+            })
+        return value, diagnostics
+
+    @classmethod
+    def _canonical_final_abstract_findings(
+        cls, mode: str, data_metadata: dict, *, hypothesis_ledger: dict | None = None,
+        violation_types: set[str] | None = None,
+    ) -> list[str]:
+        """Return fact-safe, metric-light finding sentences from frozen ledgers.
+
+        These sentences are a last-resort completion fallback after DeepSeek has
+        already received bounded local-repair opportunities.  They use only
+        frozen relation/theme identities and support status; no new statistic,
+        method, participant, or causal claim is invented.
+        """
+        meta = dict(data_metadata or {})
+        wanted = set(violation_types or set())
+        out: list[str] = []
+
+        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 {})
+            items = [dict(x) for x in (ledger.get("items") or []) if isinstance(x, dict)]
+
+            def relation_sentence(item: dict) -> str:
+                predictor = str(item.get("predictor") or "").strip()
+                outcome = str(item.get("outcome") or "").strip()
+                moderator = str(item.get("moderator") or "").strip()
+                relation = str(item.get("relation") or "").strip().lower()
+                row = dict(relation_results.get(str(item.get("relation_id") or "")) or {})
+                if not predictor or not outcome or not row:
+                    return ""
+                status = cls._final_abstract_ci_status(row)
+                estimate = row.get("estimate")
+                try:
+                    estimate_value = float(estimate)
+                except (TypeError, ValueError):
+                    estimate_value = 0.0
+                if relation == "moderation" and moderator:
+                    if status == "unsupported":
+                        return f"{moderator} did not significantly moderate the {predictor}–{outcome} association."
+                    if status == "supported":
+                        return f"{moderator} significantly moderated the {predictor}–{outcome} association."
+                    return f"The analysis assessed whether {moderator} moderated the {predictor}–{outcome} association."
+                if status == "unsupported":
+                    return f"{predictor} was not significantly associated with {outcome}."
+                direction = "positively" if estimate_value >= 0 else "negatively"
+                return f"{predictor} was {direction} associated with {outcome}."
+
+            if wanted.intersection({
+                "final_abstract_missing_unsupported_finding",
+                "final_abstract_missing_moderation_finding",
+                "final_abstract_missing_empirical_finding",
+            }):
+                unsupported = []
+                moderation = []
+                for item in items:
+                    row = dict(relation_results.get(str(item.get("relation_id") or "")) or {})
+                    status = cls._final_abstract_ci_status(row)
+                    if status == "unsupported":
+                        unsupported.append(item)
+                    if str(item.get("relation") or "").strip().lower() == "moderation":
+                        moderation.append(item)
+                if "final_abstract_missing_unsupported_finding" in wanted:
+                    out.extend(filter(None, (relation_sentence(item) for item in unsupported)))
+                if "final_abstract_missing_moderation_finding" in wanted and moderation:
+                    sentence = relation_sentence(moderation[0])
+                    if sentence:
+                        out.append(sentence)
+                if "final_abstract_missing_empirical_finding" in wanted and not out:
+                    candidate = next((item for item in items if relation_results.get(str(item.get("relation_id") or ""))), None)
+                    sentence = relation_sentence(candidate or {})
+                    if sentence:
+                        out.append(sentence)
+
+            if "final_abstract_missing_indirect_finding" in wanted:
+                indirect_rows = [dict(x) for x in (ledger.get("indirect_analyses") or []) if isinstance(x, dict)]
+                selected = next((x for x in indirect_rows if x.get("numbered_hypothesis")), indirect_rows[0] if indirect_rows else None)
+                if selected:
+                    path = [str(x or "").strip() for x in (selected.get("path") or []) if str(x or "").strip()]
+                    effect = dict(indirect_results.get(str(selected.get("effect_id") or "")) or {})
+                    if len(path) >= 3 and effect:
+                        status = cls._final_abstract_ci_status(effect)
+                        try:
+                            estimate_value = float(effect.get("estimate"))
+                        except (TypeError, ValueError):
+                            estimate_value = 0.0
+                        if status == "unsupported":
+                            out.append(
+                                f"The indirect association from {path[0]} to {path[-1]} through {path[1]} was not significant."
+                            )
+                        else:
+                            direction = "positive" if estimate_value >= 0 else "negative"
+                            out.append(
+                                f"The indirect association from {path[0]} to {path[-1]} through {path[1]} was {direction} and significant."
+                            )
+
+        elif str(mode or "").strip().lower() == "asq":
+            if wanted.intersection({
+                "final_abstract_missing_qualitative_finding",
+                "final_abstract_missing_qualitative_theme_findings",
+            }):
+                themes = [dict(x) for x in (meta.get("themes") or []) if isinstance(x, dict)]
+                labels = []
+                for theme in themes:
+                    label = str(theme.get("title") or "").strip()
+                    if not label:
+                        concepts = [str(x or "").strip() for x in (theme.get("concepts") or []) if str(x or "").strip()]
+                        label = concepts[0] if concepts else ""
+                    if label and label not in labels:
+                        labels.append(label)
+                    if len(labels) >= 2:
+                        break
+                if len(labels) >= 2:
+                    out.append(f"The analysis identified {labels[0]} and {labels[1]} as central themes.")
+                elif len(labels) == 1:
+                    out.append(f"The analysis identified {labels[0]} as a central theme.")
+
+        deduped = []
+        seen = set()
+        for sentence in out:
+            key = cls._final_abstract_normalized_text(sentence)
+            if key and key not in seen:
+                deduped.append(sentence)
+                seen.add(key)
+        return deduped
+
+    @classmethod
+    def _final_abstract_resilience_repair(
+        cls, mode: str, text: str, violations, data_metadata: dict, *, hypothesis_ledger: dict | None = None,
+    ) -> tuple[str, list[dict]]:
+        """Provider-neutral last-mile repair for recoverable Final-Abstract defects."""
+        current = str(text or "").strip()
+        rows = [dict(x) for x in (violations or []) if isinstance(x, dict)]
+        kinds = {str(x.get("type") or "") for x in rows}
+        diagnostics: list[dict] = []
+
+        metric_kinds = {"quantitative_metric_owner_unresolved", "quantitative_metric_mismatch", "unfrozen_p_value"}
+        if str(mode or "").strip().lower() == "amj" and kinds.intersection(metric_kinds):
+            current, metric_diagnostics = cls._final_abstract_metric_light(current)
+            diagnostics.extend(metric_diagnostics)
+
+        finding_kinds = {
+            "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 kinds.intersection(finding_kinds):
+            sentences = cls._canonical_final_abstract_findings(
+                mode, data_metadata, hypothesis_ledger=hypothesis_ledger,
+                violation_types=kinds.intersection(finding_kinds),
+            )
+            haystack = cls._final_abstract_normalized_text(current)
+            added = []
+            for sentence in sentences:
+                key = cls._final_abstract_normalized_text(sentence)
+                if key and key not in haystack:
+                    added.append(sentence)
+            if added:
+                current = (current.rstrip() + " " + " ".join(added)).strip()
+                diagnostics.append({
+                    "type": "final_abstract_frozen_finding_fallback",
+                    "count": len(added),
+                    "reason": "Frozen finding identities were added after bounded model repair left only abstract-coverage defects.",
+                })
+        return current, diagnostics
+
     @classmethod
     def _final_abstract_finding_violations(
         cls, mode: str, text: str, data_metadata: dict, *, hypothesis_ledger: dict | None = None
@@ -1679,6 +1909,27 @@ class GenerationRunner:
                 rows.extend(self._final_abstract_finding_violations(
                     mode, repaired, data_metadata, hypothesis_ledger=hypothesis_ledger
                 ))
+                if rows:
+                    resilient, resilience_notes = self._final_abstract_resilience_repair(
+                        mode, repaired, rows, data_metadata, hypothesis_ledger=hypothesis_ledger
+                    )
+                    if resilient != repaired:
+                        repaired = resilient
+                        rows = self._study_fact_violations(
+                            mode, agent, quant_engine, repaired, data_metadata, section_name=label
+                        )
+                        if hypothesis_ledger:
+                            rows.extend(self._hypothesis_contract_violations(
+                                repaired, hypothesis_ledger, section_name=label
+                            ))
+                        rows.extend(self._final_abstract_finding_violations(
+                            mode, repaired, data_metadata, hypothesis_ledger=hypothesis_ledger
+                        ))
+                        if resilience_notes:
+                            self._record_adaptive_completion_residual(
+                                quality_notes, resilience_notes, section_name=label,
+                                stage="front_matter_resilience_recovery"
+                            )
             current, remaining = repaired, rows
             if not remaining:
                 return current, []
@@ -2249,25 +2500,27 @@ class GenerationRunner:
                     if 'moderation' in missing:
                         label = role_label.get('moderator') or ''
                         if code.startswith('zh'):
-                            suffixes.append(f'调节变量：{label}' if label else '调节作用')
+                            suffixes.append(f'{label}的调节作用' if label else '调节作用')
                         elif code.startswith('ru'):
-                            suffixes.append(f'модератор: {label}' if label else 'модерация')
+                            suffixes.append(f'модерирующая роль переменной «{label}»' if label else 'модерирующая роль')
                         elif code.startswith('kk') or code.startswith('kz'):
-                            suffixes.append(f'модератор: {label}' if label else 'модераторлық рөл')
+                            suffixes.append(f'«{label}» айнымалысының модераторлық рөлі' if label else 'модераторлық рөл')
                         else:
-                            suffixes.append(f'moderator: {label}' if label else 'moderation')
+                            suffixes.append(f'the moderating role of {label}' if label else 'moderation')
                     if missing.intersection({'mediation', 'serial_mediation', 'parallel_mediation'}):
                         label = role_label.get('mediator') or ''
                         if code.startswith('zh'):
-                            suffixes.append(f'中介变量：{label}' if label else '中介作用')
+                            suffixes.append(f'{label}的中介作用' if label else '中介作用')
                         elif code.startswith('ru'):
-                            suffixes.append(f'медиатор: {label}' if label else 'медиация')
+                            suffixes.append(f'медиирующая роль переменной «{label}»' if label else 'медиирующая роль')
                         elif code.startswith('kk') or code.startswith('kz'):
-                            suffixes.append(f'медиатор: {label}' if label else 'медиаторлық рөл')
+                            suffixes.append(f'«{label}» айнымалысының медиаторлық рөлі' if label else 'медиаторлық рөл')
                         else:
-                            suffixes.append(f'mediator: {label}' if label else 'mediation')
+                            suffixes.append(f'the mediating role of {label}' if label else 'mediation')
                     if suffixes:
-                        repaired_title = title.rstrip(' .;:') + ' (' + '; '.join(suffixes) + ')'
+                        separator = '：' if code.startswith('zh') else ': '
+                        joiner = '；' if code.startswith('zh') else '; '
+                        repaired_title = title.rstrip(' .;:：') + separator + joiner.join(suffixes)
                         value = value[:title_match.start(1)] + repaired_title + value[title_match.end(1):]
                         diagnostics.append({'type':'target_user_relation_title_rebound','missing':sorted(missing)})
         return value, diagnostics
@@ -5663,6 +5916,29 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 remaining_final_fact_rows.extend(self._final_abstract_finding_violations(
                     mode, final_abstract, data_metadata, hypothesis_ledger=hypothesis_ledger
                 ))
+                if remaining_final_fact_rows:
+                    resilient_abstract, resilience_notes = self._final_abstract_resilience_repair(
+                        mode, final_abstract, remaining_final_fact_rows, data_metadata,
+                        hypothesis_ledger=hypothesis_ledger
+                    )
+                    if resilient_abstract != final_abstract:
+                        final_abstract = resilient_abstract
+                        remaining_final_fact_rows = self._study_fact_violations(
+                            mode, agent, quant_engine, final_abstract, data_metadata,
+                            section_name="Final Abstract",
+                        )
+                        if hypothesis_ledger:
+                            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 resilience_notes:
+                            self._record_adaptive_completion_residual(
+                                quality_notes, resilience_notes, section_name="Final Abstract",
+                                stage="final_abstract_resilience_recovery"
+                            )
                 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,

core/quantitative_engine.py

@@ -1861,7 +1861,7 @@ Keywords: {keywords}"""
                     continue
                 if row.get("estimate") is not None:
                     candidates.append((f"relation:{rid}", row.get("estimate")))
-            if re.search(r"(?i)indirect", clause):
+            if re.search(r"(?i)\bindirect\b", clause):
                 for eid, row in indirect_results.items():
                     if not isinstance(row, dict):
                         continue