S0-R1-C5.5-R6-R10 Quantitative Method Citation Retry Frame

core/generation_runner.py

@@ -1070,6 +1070,47 @@ class GenerationRunner:
                 return lineage
         return kind
 
+    @staticmethod
+    def _strip_unscoped_citation_identities(value):
+        """Remove raw citation capability tokens from non-authoritative context."""
+        return re.sub(r"\[CITE-\d+\]", "", str(value or ""), flags=re.I)
+
+    @staticmethod
+    def _section_citation_capability_context(agent, planned_items, max_chars=12000):
+        """Expose only citation identities already frozen for this manuscript unit.
+
+        Retrieval visibility is not citation authority.  R6-R10 therefore builds
+        writer-facing targeted context from the unit's frozen claim-evidence plan
+        instead of the global RAG pool, which may contain METHOD_AUTHORITY tags
+        owned by another unit.
+        """
+        rows = []
+        seen = set()
+        for item in list(planned_items or []):
+            if not isinstance(item, dict):
+                continue
+            tag = str(item.get("tag") or "").strip()
+            if not tag or tag in seen:
+                continue
+            metadata = dict(getattr(agent, "citation_map", {}).get(tag) or {})
+            evidence = str(item.get("evidence") or metadata.get("evidence") or "").strip()
+            claim = str(item.get("claim") or "").strip()
+            if not evidence:
+                continue
+            seen.add(tag)
+            row = f"{tag} AUTHORIZED CLAIM: {claim}\nEVIDENCE: {evidence}" if claim else f"{tag} EVIDENCE: {evidence}"
+            rows.append(row)
+        value = "\n\n--- Authorized Section Evidence ---\n".join(rows)
+        return value[:max(0, int(max_chars))]
+
+    @staticmethod
+    def _section_regressed_lineages(current_lineages, cleared_lineages, regression_attempts):
+        """Return previously-cleared lineages reintroduced by a later sibling repair."""
+        current = {str(value) for value in (current_lineages or set()) if str(value)}
+        cleared = {str(value) for value in (cleared_lineages or set()) if str(value)}
+        attempts = dict(regression_attempts or {})
+        return {name for name in current & cleared if int(attempts.get(name, 0)) < 1}
+
     @classmethod
     def _section_retry_decision(cls, rows, lineage_attempts, *, hard_cap_reached: bool = False):
         """Return (may_retry, exhausted_lineages, new_lineages).
@@ -2995,7 +3036,12 @@ class GenerationRunner:
                 self._build_qualitative_quote_invocation_plan(adaptive_structure, data_metadata)
                 if mode == "asq" else {}
             )
-            jit_texts = agent.prefetch_jit_literature(topic, keywords, adaptive_structure)
+            jit_texts = agent.prefetch_jit_literature(
+                topic, keywords, adaptive_structure,
+                quantitative_evidence_ledger=(
+                    data_metadata.get("quantitative_evidence_ledger") if mode == "amj" else None
+                ),
+            )
             if jit_texts:
                 rag_engine._initialize_chunks([jit_texts])
             self._progress(15, "citation_planning")
@@ -3690,9 +3736,11 @@ class GenerationRunner:
                     "\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_context = self._strip_unscoped_citation_identities(
+                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 ""
+            snippets = self._section_citation_capability_context(agent, planned_items)
             if snippets:
                 memory_block += f"\n<TARGETED_RAG>\n{snippets}\n</TARGETED_RAG>\n"
             heading_directive = "Do not output the section heading; it will be inserted by the system."
@@ -3803,7 +3851,10 @@ class GenerationRunner:
                     "When no supported external claim is assigned, prefer concise study positioning, transparent limitations, and cautious conceptual reasoning without invented citation support."
                 )
             else:
-                writer_synthesis_context = synthesis_result
+                # Literature synthesis is planning context, not a citation capability.
+                # Raw identities are stripped; only the frozen Section plan below may
+                # expose a usable [CITE-XX] token to the writer.
+                writer_synthesis_context = self._strip_unscoped_citation_identities(synthesis_result)
             user_prompt = f"""Write the assigned English manuscript unit.
 Section: {sec_title}
 Subsection: {subsection or 'None'}
@@ -3861,6 +3912,14 @@ Output only final academic prose. Do not report the word count."""
             # Four is a hard safety cap, not a blanket four-attempt entitlement.
             max_section_attempts = 1 if deterministic_appendix else 4
             lineage_attempts = {}
+            # R6-R10 monotonic retry state.  A defect that was repaired and absent
+            # on an intervening attempt may receive one regression-correction turn
+            # if a later sibling repair reintroduces it.  The Section hard cap is
+            # unchanged, so this cannot create an unbounded retry loop.
+            seen_lineages = set()
+            cleared_lineages = set()
+            regression_attempts = {}
+            historical_retry_rows = {}
             frozen_citation_state = self._snapshot_section_citation_state(
                 agent, citation_plan, display_name
             )
@@ -3897,6 +3956,13 @@ Output only final academic prose. Do not report the word count."""
                         f"<CLAIM_EVIDENCE_PLAN>\n{retry_claim_plan}\n</CLAIM_EVIDENCE_PLAN>",
                         candidate_user_prompt, flags=re.S,
                     )
+                    retry_capability_context = self._section_citation_capability_context(agent, planned_items)
+                    candidate_user_prompt = re.sub(
+                        r"\n<TARGETED_RAG>.*?</TARGETED_RAG>\n",
+                        (f"\n<TARGETED_RAG>\n{retry_capability_context}\n</TARGETED_RAG>\n"
+                         if retry_capability_context else "\n"),
+                        candidate_user_prompt, flags=re.S,
+                    )
                 if attempt_feedback:
                     excluded_text = ", ".join(sorted(retry_excluded_tags, key=agent._citation_tag_number)) or "None"
                     candidate_user_prompt += f"""
@@ -3995,20 +4061,49 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     preview_blocking, preview_advisory = self._partition_section_violations(
                         phase1_validation_rows, section_name=display_name, mode=mode, exhausted=False
                     )
+                    current_lineages = {
+                        self._section_violation_lineage(row) for row in preview_blocking
+                    }
+                    cleared_lineages.update(seen_lineages - current_lineages)
+                    regressed_lineages = self._section_regressed_lineages(
+                        current_lineages, cleared_lineages, regression_attempts
+                    )
+                    seen_lineages.update(current_lineages)
                     may_retry, exhausted_lineages, fresh_lineages = self._section_retry_decision(
                         preview_blocking, lineage_attempts, hard_cap_reached=hard_cap_reached
                     )
+                    retry_lineages = set(fresh_lineages)
+                    if regressed_lineages and not hard_cap_reached:
+                        retry_lineages.update(regressed_lineages)
+                        may_retry = True
                     if may_retry:
                         retry_rows = [
                             row for row in preview_blocking
-                            if self._section_violation_lineage(row) in fresh_lineages
+                            if self._section_violation_lineage(row) in retry_lineages
                         ]
                         for lineage in fresh_lineages:
                             lineage_attempts[lineage] = int(lineage_attempts.get(lineage, 0)) + 1
+                        for lineage in regressed_lineages:
+                            regression_attempts[lineage] = int(regression_attempts.get(lineage, 0)) + 1
+                        for row in preview_blocking:
+                            historical_retry_rows[self._section_violation_lineage(row)] = dict(row)
+                        # Every later repair is constrained by all earlier resolved
+                        # contracts, not only the newly visible lineage.  This makes
+                        # A+B -> C -> A+B repair interference explicitly non-monotonic
+                        # and gives it one bounded correction turn.
                         attempt_feedback = self._section_retry_feedback(retry_rows)
+                        historical_feedback = self._section_retry_feedback(
+                            list(historical_retry_rows.values())
+                        )
+                        if historical_feedback:
+                            attempt_feedback += (
+                                "\nNONREGRESSION CONSTRAINTS — previously repaired lineages must remain resolved:\n"
+                                + historical_feedback
+                            )
                         logging.warning(
-                            "Unified Phase-1 Section lineage retry | unit=%s attempt=%s lineages=%s exhausted_siblings=%s count=%s types=%s",
-                            display_name, section_attempt, sorted(fresh_lineages), sorted(exhausted_lineages), len(retry_rows),
+                            "Unified Phase-1 Section lineage retry | unit=%s attempt=%s lineages=%s exhausted_siblings=%s regressed_lineages=%s count=%s types=%s",
+                            display_name, section_attempt, sorted(retry_lineages), sorted(exhausted_lineages),
+                            sorted(regressed_lineages), len(retry_rows),
                             sorted({str(row.get("type") or "") for row in retry_rows if isinstance(row, dict)}),
                         )
                         self._restore_section_citation_state(

core/pipeline_agent.py

@@ -2311,8 +2311,27 @@ If the immutable hypothesis contract is non-empty, preserve its H-identifiers an
         return violations
 
     @staticmethod
-    def _method_authority_queries(structure):
-        """Derive bounded methodology queries from design language, never topic keywords."""
+    def _method_authority_queries(structure, quantitative_evidence_ledger=None):
+        """Derive bounded methodology queries from the *owned* evidence contract.
+
+        R6-R10 prevents generic Methodology headings from retrieving methods the
+        study did not perform (for example SEM for a VIF/bootstrap design).
+        """
+        ledger = dict(quantitative_evidence_ledger or {})
+        if bool(ledger.get("strict")):
+            allowed = {str(value or "").strip().casefold() for value in (ledger.get("allowed_methods") or [])}
+            queries = []
+            if allowed & {"reliability", "composite reliability", "average variance extracted", "fornell-larcker"}:
+                queries.append("measurement reliability validity methodology")
+            if "vif" in allowed:
+                queries.append("variance inflation factor collinearity methodology")
+            if "bootstrap" in allowed:
+                queries.append("bootstrap inference methodology")
+            if "spearman" in allowed:
+                queries.append("Spearman rank correlation methodology")
+            if not queries:
+                queries.append("empirical association analysis methodology")
+            return list(dict.fromkeys(queries))[:3]
         text_parts = []
         for sec in structure or []:
             if not isinstance(sec, dict):
@@ -2350,10 +2369,12 @@ If the immutable hypothesis contract is non-empty, preserve its H-identifiers an
             queries.append('empirical research design methodology')
         return list(dict.fromkeys(queries))[:3]
 
-    def prefetch_jit_literature(self, topic, keywords, structure):
+    def prefetch_jit_literature(self, topic, keywords, structure, quantitative_evidence_ledger=None):
         """Retrieve a dedicated methodology-authority lane without an LLM query call."""
         jit_rag_texts = []
-        queries_to_fetch = self._method_authority_queries(structure)
+        queries_to_fetch = self._method_authority_queries(
+            structure, quantitative_evidence_ledger=quantitative_evidence_ledger
+        )
         if not queries_to_fetch:
             return ""
         logging.info("METHOD_AUTHORITY retrieval | queries=%s", queries_to_fetch)

core/quantitative_engine.py

@@ -861,6 +861,98 @@ Keywords: {keywords}"""
             ] if strict else [],
         }
 
+    @classmethod
+    def classify_quantitative_method_threat_claim(cls, sentence, term):
+        """Classify a forbidden quantitative term by *claim role*, not token presence.
+
+        R6-R10 separates an actually performed/claimed unowned analysis from a
+        limitation, explicit non-use statement, threat discussion, or incidental
+        methodological mention.  Only ``PERFORMED_UNOWNED`` is blocking.
+        """
+        text = re.sub(r"\s+", " ", str(sentence or "")).strip()
+        folded = text.casefold()
+        label = re.sub(r"\s+", " ", str(term or "")).strip()
+        term_folded = label.casefold()
+        if not text or not term_folded:
+            return {"term": label, "category": "UNKNOWN", "state": "ABSENT"}
+        match = re.search(rf"(?i)(?<![A-Za-z]){re.escape(label)}(?![A-Za-z])", text)
+        if not match:
+            return {"term": label, "category": "UNKNOWN", "state": "ABSENT"}
+
+        threat_terms = {"common method bias", "endogeneity"}
+        fit_terms = {"rmsea", "cfi", "tli", "srmr"}
+        category = (
+            "THREAT" if term_folded in threat_terms else
+            "FIT_DIAGNOSTIC" if term_folded in fit_terms else
+            "ANALYTIC_METHOD"
+        )
+        before = folded[max(0, match.start() - 100):match.start()]
+        after = folded[match.end():min(len(folded), match.end() + 120)]
+        local = folded[max(0, match.start() - 120):min(len(folded), match.end() + 140)]
+
+        scalar_negation = bool(re.search(
+            r"\bnot\s+(?:only|merely|just|simply)\b", local
+        ))
+        explicit_nonuse = (not scalar_negation) and bool(
+            re.search(
+                r"\b(?:no|not|never|without|did\s+not|does\s+not|do\s+not|was\s+not|were\s+not|is\s+not|are\s+not|cannot|can\s+not)\b[^.;:]{0,55}$",
+                before,
+            )
+            or re.search(
+                r"^.{0,45}\b(?:was\s+not|were\s+not|is\s+not|are\s+not|did\s+not|does\s+not|do\s+not|cannot|can\s+not|not\s+(?:used|conducted|performed|estimated|tested|assessed|evaluated|reported|implemented|applied))\b",
+                after,
+            )
+            or re.search(
+                r"\b(?:does\s+not|do\s+not|did\s+not|cannot|can\s+not|is\s+not|are\s+not|was\s+not|were\s+not)\s+(?:address|assess|test|establish|identify|rule\s+out|correct|control|substitute|demonstrate|show|prove|support)\b",
+                local,
+            )
+        )
+        if explicit_nonuse:
+            return {"term": label, "category": category, "state": "NOT_PERFORMED_OR_LIMITATION"}
+
+        performed = bool(
+            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,
+            )
+            or re.search(
+                r"^.{0,65}\b(?:was|were|is|are)\s+(?:used|employed|conducted|performed|estimated|tested|assessed|evaluated|implemented|applied|fit|fitted|modeled|modelled|controlled|corrected|addressed|reported)\b",
+                after,
+            )
+            or re.search(
+                r"^.{0,65}\b(?:estimated|tested|assessed|evaluated|showed|indicated|yielded|produced|confirmed|supported)\b",
+                after,
+            )
+        )
+        if category == "FIT_DIAGNOSTIC" and re.search(
+            rf"(?i)(?:{re.escape(label)}\s*(?:=|:|was|were)\s*[-+]?\d)|(?:reported|fit\s+index|fit\s+indices)[^.;:]{{0,45}}{re.escape(label)}",
+            text,
+        ):
+            performed = True
+        if category == "THREAT":
+            # Threats may be discussed as limitations without implying a test.
+            if re.search(
+                rf"(?i)(?:assess|test|evaluate|examine|address|correct|control)(?:ed|ing|s)?[^.;:]{{0,45}}{re.escape(label)}|{re.escape(label)}[^.;:]{{0,45}}(?:was|were)\s+(?:assessed|tested|evaluated|examined|addressed|corrected|controlled)",
+                text,
+            ):
+                performed = True
+            elif not performed:
+                return {"term": label, "category": category, "state": "LIMITATION_OR_THREAT"}
+
+        return {
+            "term": label,
+            "category": category,
+            "state": "PERFORMED_UNOWNED" if performed else "MENTION_ONLY",
+        }
+
+    @classmethod
+    def _first_performed_unowned_quantitative_term(cls, sentence, forbidden_terms):
+        for term in forbidden_terms or []:
+            frame = cls.classify_quantitative_method_threat_claim(sentence, term)
+            if frame.get("state") == "PERFORMED_UNOWNED":
+                return frame
+        return None
+
     @staticmethod
     def _semantic_frame_hash(payload):
         canonical = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
@@ -1345,7 +1437,12 @@ Keywords: {keywords}"""
 
         for _start, _end, sentence in cls._sentence_spans(value):
             ownership = cls._quantitative_sentence_ownership(sentence, section_name, known_constructs)
-            if ownership not in {"study", "result"}:
+            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 ownership not in {"study", "result"} and not method_scope_unknown:
                 continue
             if sample_size:
                 for match in re.finditer(r"(?i)(\b(?:sample(?:\s+size)?(?:\s+of)?|N)\s*(?:=|:)?\s*)(\d{2,6})\b", sentence):
@@ -1392,10 +1489,16 @@ Keywords: {keywords}"""
                     })
                 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":
-                    bad = next((term for term in forbidden if re.search(rf"(?i)(?<![A-Za-z]){re.escape(term)}(?![A-Za-z])", sentence)), "")
-                    if bad:
-                        violations.append({"type":"unsupported_quantitative_method","method":bad,"preview":sentence.strip()[:180]})
+                if ownership == "study" or method_scope_unknown:
+                    method_frame = cls._first_performed_unowned_quantitative_term(sentence, forbidden)
+                    if method_frame:
+                        violations.append({
+                            "type":"unsupported_quantitative_method",
+                            "method":method_frame.get("term"),
+                            "claim_state":method_frame.get("state"),
+                            "method_category":method_frame.get("category"),
+                            "preview":sentence.strip()[:180],
+                        })
 
             vif_expected = results.get("predictor_mediator_vif") if strict else uploaded.get("VIF")
             boot_expected = results.get("bootstrap_iterations") if strict else uploaded.get("bootstrap_iterations")
@@ -1474,7 +1577,12 @@ Keywords: {keywords}"""
         replacements = []
         for start, end, sentence in cls._sentence_spans(value):
             ownership = cls._quantitative_sentence_ownership(sentence, section_name, known_constructs)
-            if ownership not in {"study", "result"}:
+            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 ownership not in {"study", "result"} and not method_scope_unknown:
                 continue
             revised = sentence
 
@@ -1533,10 +1641,16 @@ Keywords: {keywords}"""
                     revised, p_count = re.subn(r"(?i)\s*[,;]?\s*p\s*(?:=|<|>|≤|≥)\s*(?:0?\.\d+|\d+(?:\.\d+)?)", "", revised)
                     if p_count:
                         diagnostics.append({"type":"unfrozen_p_value_removed","count":p_count})
-                if ownership == "study":
-                    bad = next((term for term in forbidden if re.search(rf"(?i)(?<![A-Za-z]){re.escape(term)}(?![A-Za-z])", revised)), "")
-                    if bad:
-                        diagnostics.append({"type":"unsupported_quantitative_method_removed","method":bad,"preview":sentence.strip()[:180]})
+                if ownership == "study" or method_scope_unknown:
+                    method_frame = cls._first_performed_unowned_quantitative_term(revised, forbidden)
+                    if method_frame:
+                        diagnostics.append({
+                            "type":"unsupported_quantitative_method_removed",
+                            "method":method_frame.get("term"),
+                            "claim_state":method_frame.get("state"),
+                            "method_category":method_frame.get("category"),
+                            "preview":sentence.strip()[:180],
+                        })
                         revised = ""
 
             def replace_local_metric(pattern, expected, *, dtype="float", label="metric"):