S1-R4 Method Authority Guard + Balanced Final Abstract

core/generation_runner.py

@@ -1242,11 +1242,32 @@ class GenerationRunner:
                     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)
+                if "final_abstract_missing_empirical_finding" in wanted:
+                    # Preserve representativeness even when the abstract already
+                    # contains null/unsupported findings.  Prefer one supported
+                    # non-moderation relation so the fallback communicates a
+                    # central positive/negative empirical result rather than
+                    # becoming a list of only non-significant findings.
+                    supported = [
+                        item for item in items
+                        if str(item.get("relation") or "").strip().lower() != "moderation"
+                        and cls._final_abstract_ci_status(
+                            dict(relation_results.get(str(item.get("relation_id") or "")) or {})
+                        ) == "supported"
+                    ]
+                    candidate = next(
+                        (item for item in supported if str(item.get("outcome") or "").strip()),
+                        supported[0] if supported else None,
+                    )
+                    if candidate is None 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 sentence not in out:
+                            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)]

core/pipeline_agent.py

@@ -5088,6 +5088,84 @@ INPUT:
             return True
         return False
 
+    @staticmethod
+    def _has_explicit_current_qualitative_study_anchor(sentence):
+        """Identify an explicit current-study owner even in a cited sentence.
+
+        A method citation may justify a procedure, but it must not make this
+        manuscript's own empirical/procedural clause externally owned.  Keep
+        this narrower than the general qualitative ownership heuristic so a
+        cited phrase such as ``the study conducted interviews`` is not
+        accidentally reclassified as the current manuscript.
+        """
+        value = str(sentence or "")
+        return bool(re.search(
+            r"(?i)\b(?:we|our\s+study|this\s+study|the\s+present\s+study|"
+            r"research\s+team|our\s+data|our\s+analysis|our\s+interviews?|"
+            r"our\s+focus\s+groups?|our\s+observations?|in\s+this\s+study|"
+            r"in\s+our\s+study)\b",
+            value,
+        ))
+
+    @staticmethod
+    def _normalize_qualitative_analytic_design_identity(value):
+        folded = re.sub(r"\s+", " ", str(value or "")).strip().casefold()
+        if not folded:
+            return ""
+        if "gioia" in folded:
+            return "gioia"
+        if "grounded theory" in folded:
+            return "grounded_theory"
+        if "comparative case" in folded:
+            return "comparative_case"
+        if "longitudinal" in folded and "qualitative" in folded:
+            return "longitudinal_qualitative"
+        if "thematic" in folded:
+            return "thematic_process"
+        if "process analysis" in folded:
+            return "process_analysis"
+        return folded
+
+    @classmethod
+    def _performed_qualitative_analytic_design_identity(cls, sentence):
+        """Return a performed current-study qualitative design, if explicit.
+
+        This is a prose-level evidence guard, not a new method router.  It
+        prevents a cited method name from silently replacing the analytic design
+        frozen in the qualitative evidence packet.
+        """
+        value = re.sub(r"\s+", " ", str(sentence or "")).strip()
+        if not value or not cls._has_explicit_current_qualitative_study_anchor(value):
+            return ""
+        candidates = (
+            ("gioia", r"\bGioia(?:-style)?(?:\s+inductive\s+coding|\s+methodology|\s+method|\s+approach)?\b"),
+            ("grounded_theory", r"\bgrounded\s+theory\b"),
+            ("comparative_case", r"\bcomparative\s+case\s+analysis\b"),
+            ("longitudinal_qualitative", r"\blongitudinal\s+qualitative\s+analysis\b"),
+            ("process_analysis", r"\bprocess\s+analysis\b"),
+            ("thematic_process", r"\b(?:iterative\s+)?thematic(?:/process)?\s+analysis\b|\bthematic\s+analysis\b"),
+        )
+        for identity, pattern in candidates:
+            match = re.search(pattern, value, flags=re.I)
+            if not match:
+                continue
+            before = value[max(0, match.start() - 120):match.start()]
+            if re.search(
+                r"(?i)\b(?:did\s+not|does\s+not|do\s+not|was\s+not|were\s+not|"
+                r"not|without|never)\b[^.;:]{0,45}$",
+                before,
+            ):
+                continue
+            full_before = value[:match.start()]
+            if re.search(
+                r"(?i)\b(?:use|uses|used|employ|employs|employed|apply|applies|applied|"
+                r"adopt|adopts|adopted|follow|follows|followed|conduct|conducts|conducted|"
+                r"analy[sz]e|analy[sz]es|analy[sz]ed|code|codes|coded)\b[^.;:]{0,180}$",
+                full_before,
+            ):
+                return identity
+        return ""
+
     @classmethod
     def _is_study_owned_qualitative_claim(cls, sentence, section_name=""):
         """Conservatively identify only this manuscript's empirical/procedural claims.
@@ -5102,6 +5180,11 @@ INPUT:
             return False
         if re.match(r'^["“‘\']', stripped) or re.search(r"\bQUOTE-\d+\b", value, flags=re.I):
             return False
+        # Explicit current-study ownership dominates an appended method or
+        # theory citation.  The cited source may justify the procedure, but it
+        # cannot own the statement that *this* study performed it.
+        if cls._has_explicit_current_qualitative_study_anchor(value):
+            return True
         if cls._has_external_literature_marker(value):
             return False
         if re.search(r"(?i)\b(?:prior|previous|earlier|existing)\s+(?:research|stud(?:y|ies)|literature)\b", value):
@@ -5155,6 +5238,9 @@ INPUT:
             "ethics": [str(x or "").strip().casefold() for x in (facts.get("ethics_procedures") or []) if str(x or "").strip()],
             "reflexivity": [str(x or "").strip().casefold() for x in (facts.get("reflexivity_procedures") or []) if str(x or "").strip()],
         }
+        authorized_design = cls._normalize_qualitative_analytic_design_identity(
+            facts.get("analytic_design") or facts.get("analysis_method")
+        )
         procedure_patterns = {
             "trustworthiness": r"\bmember\s+check(?:ing|s)?\b|\bpeer\s+debrief(?:ing|ed)?\b|\baudit\s+trail\b|\bexternal\s+audit\b",
             "ethics": r"\binformed\s+consent\b|\bethics?\s+approval\b|\binstitutional\s+review\s+board\b|\bIRB\b|\bapproval\s+(?:number|code)\b",
@@ -5191,6 +5277,18 @@ INPUT:
             if not core.strip() or not cls._is_study_owned_qualitative_claim(core, section_name):
                 continue
 
+            observed_design = cls._performed_qualitative_analytic_design_identity(core)
+            if observed_design and authorized_design and observed_design != authorized_design:
+                sig = ("analytic_design", observed_design)
+                if sig not in seen:
+                    seen.add(sig)
+                    violations.append({
+                        "type":"unsupported_qualitative_analytic_design",
+                        "observed":observed_design,
+                        "expected":authorized_design,
+                        "preview":core.strip()[:180],
+                    })
+
             # Check every explicit procedure mention; do not stop after the first.
             for category, pattern in procedure_patterns.items():
                 for match in re.finditer(pattern, core, flags=re.I):
@@ -5253,6 +5351,9 @@ INPUT:
             "ethics": [str(x or "").strip() for x in (facts.get("ethics_procedures") or []) if str(x or "").strip()],
             "reflexivity": [str(x or "").strip() for x in (facts.get("reflexivity_procedures") or []) if str(x or "").strip()],
         }
+        authorized_design = cls._normalize_qualitative_analytic_design_identity(
+            facts.get("analytic_design") or facts.get("analysis_method")
+        )
         allowed_by_actor = {}
         canonical_relations = []
         canonical_by_actor = {}
@@ -5287,6 +5388,16 @@ INPUT:
             lower = core.casefold()
             if not core.strip() or not cls._is_study_owned_qualitative_claim(core, section_name):
                 continue
+            observed_design = cls._performed_qualitative_analytic_design_identity(core)
+            if observed_design and authorized_design and observed_design != authorized_design:
+                replacements.append((start, end, ""))
+                diagnostics.append({
+                    "type":"unsupported_qualitative_analytic_design_removed",
+                    "observed":observed_design,
+                    "expected":authorized_design,
+                    "preview":core.strip()[:180],
+                })
+                continue
             removed = False
             for category, pattern in procedure_patterns.items():
                 procedure_match = re.search(pattern, core, flags=re.I)

core/quantitative_engine.py

@@ -1024,6 +1024,24 @@ Keywords: {keywords}"""
             return "study"
         return "unknown"
 
+    @staticmethod
+    def _has_explicit_current_study_anchor(sentence):
+        """Return True only for an explicit *current manuscript* ownership anchor.
+
+        A literature citation does not transfer ownership of a clause such as
+        ``We tested ... (Author, year)`` to the cited source.  This helper is
+        intentionally narrower than the general sentence-ownership heuristic:
+        generic phrases such as ``the study`` are excluded because they may
+        refer to a cited study.
+        """
+        value = str(sentence or "")
+        return bool(re.search(
+            r"(?i)\b(?:we|our\s+study|this\s+study|the\s+present\s+study|"
+            r"our\s+analysis|our\s+model|our\s+sample|our\s+results|"
+            r"in\s+this\s+study|in\s+our\s+study)\b",
+            value,
+        ))
+
     @staticmethod
     def _unique_numeric(pattern, evidence, *, integer=False):
         values = []
@@ -1182,7 +1200,41 @@ Keywords: {keywords}"""
         if explicit_nonuse:
             return {"term": label, "category": category, "state": "NOT_PERFORMED_OR_LIMITATION"}
 
+        # The original local-window classifier can miss a long current-study
+        # frame such as ``We tested the hypotheses ... using partial least
+        # squares structural equation modeling (PLS-SEM)`` because the action
+        # verb may sit more than 70 characters before the forbidden term.  A
+        # citation appended to the same sentence must not make that performed
+        # method claim externally owned.  Detect the explicit current-study
+        # action across the whole pre-term clause before applying the narrower
+        # legacy patterns below.
+        full_before = folded[:match.start()]
+        if re.search(
+            r"\b(?:did\s+not|does\s+not|do\s+not|was\s+not|were\s+not|never)\s+"
+            r"(?!only\b)(?:use|uses|used|employ|employs|employed|conduct|conducts|conducted|"
+            r"perform|performs|performed|estimate|estimates|estimated|test|tests|tested|"
+            r"assess|assesses|assessed|evaluate|evaluates|evaluated|implement|implements|"
+            r"implemented|apply|applies|applied|fit|fits|fitted|model|models|modeled|modelled)\b"
+            r"[^.;:]{0,240}$",
+            full_before,
+        ):
+            return {"term": label, "category": category, "state": "NOT_PERFORMED_OR_LIMITATION"}
+        current_study_performed = bool(
+            cls._has_explicit_current_study_anchor(text)
+            and re.search(
+                r"\b(?:use|uses|used|employ|employs|employed|conduct|conducts|conducted|"
+                r"perform|performs|performed|estimate|estimates|estimated|test|tests|tested|"
+                r"assess|assesses|assessed|evaluate|evaluates|evaluated|implement|implements|"
+                r"implemented|apply|applies|applied|ran|run|runs|fit|fits|fitted|model|models|"
+                r"modeled|modelled|control|controls|controlled|correct|corrects|corrected|"
+                r"address|addresses|addressed)\b[^.;:]{0,240}$",
+                full_before,
+            )
+        )
+
         performed = bool(
+            current_study_performed
+            or
             re.search(
                 r"\b(?:we|the\s+study|this\s+study|the\s+analysis|our\s+analysis|the\s+model|the\s+authors?)\b[^.;:]{0,70}\b(?:use|uses|used|employ|employs|employed|conduct|conducts|conducted|perform|performs|performed|estimate|estimates|estimated|test|tests|tested|assess|assesses|assessed|evaluate|evaluates|evaluated|implement|implements|implemented|apply|applies|applied|ran|run|runs|fit|fits|fitted|model|models|modeled|modelled|control|controls|controlled|correct|corrects|corrected|address|addresses|addressed)\b[^.;:]{0,70}$",
                 before,
@@ -1917,11 +1969,34 @@ Keywords: {keywords}"""
 
         for _start, _end, sentence in cls._sentence_spans(value):
             ownership = cls._quantitative_sentence_ownership(sentence, section_name, known_constructs)
+            current_study_method_frame = (
+                cls._first_performed_unowned_quantitative_term(sentence, forbidden)
+                if strict and cls._has_explicit_current_study_anchor(sentence)
+                else None
+            )
+            method_scope_hybrid = bool(
+                strict
+                and ownership == "external"
+                and current_study_method_frame is not None
+            )
             method_scope_unknown = (
                 strict and ownership == "unknown"
                 and bool(re.search(r"(?i)method|measure", str(section_name or "")))
                 and cls._first_performed_unowned_quantitative_term(sentence, forbidden) is not None
             )
+            if method_scope_hybrid:
+                violations.append({
+                    "type":"unsupported_quantitative_method",
+                    "method":current_study_method_frame.get("term"),
+                    "claim_state":current_study_method_frame.get("state"),
+                    "method_category":current_study_method_frame.get("category"),
+                    "preview":sentence.strip()[:180],
+                })
+                # The literature-cited part remains externally owned.  Do not
+                # run unrelated metric/role rewrites across this hybrid
+                # sentence; the method violation alone is sufficient to force
+                # bounded regeneration/fail-closed handling.
+                continue
             if ownership not in {"study", "result"} and not method_scope_unknown:
                 continue
             if sample_size:
@@ -2065,11 +2140,31 @@ Keywords: {keywords}"""
         replacements = []
         for start, end, sentence in cls._sentence_spans(value):
             ownership = cls._quantitative_sentence_ownership(sentence, section_name, known_constructs)
+            current_study_method_frame = (
+                cls._first_performed_unowned_quantitative_term(sentence, forbidden)
+                if strict and cls._has_explicit_current_study_anchor(sentence)
+                else None
+            )
+            method_scope_hybrid = bool(
+                strict
+                and ownership == "external"
+                and current_study_method_frame is not None
+            )
             method_scope_unknown = (
                 strict and ownership == "unknown"
                 and bool(re.search(r"(?i)method|measure", str(section_name or "")))
                 and cls._first_performed_unowned_quantitative_term(sentence, forbidden) is not None
             )
+            if method_scope_hybrid:
+                diagnostics.append({
+                    "type":"unsupported_quantitative_method_removed",
+                    "method":current_study_method_frame.get("term"),
+                    "claim_state":current_study_method_frame.get("state"),
+                    "method_category":current_study_method_frame.get("category"),
+                    "preview":sentence.strip()[:180],
+                })
+                replacements.append((start, end, ""))
+                continue
             if ownership not in {"study", "result"} and not method_scope_unknown:
                 continue
             revised = sentence