S0-R1-C5.1 Hypothesis Authority Semantic JIT Citation Split

core/generation_runner.py

@@ -1047,6 +1047,36 @@ class GenerationRunner:
               "or change the construct pairing to fit observed results. The contract is result-independent."
         )
 
+    @staticmethod
+    def _hypothesis_memory_text(ledger: dict) -> str:
+        """Render the sole AMJ H1-Hn memory from the frozen ledger."""
+        lines = []
+        for item in (dict(ledger or {}).get("items") or []):
+            if not isinstance(item, dict):
+                continue
+            hid = str(item.get("hypothesis_id") or "").strip().upper()
+            predictor = re.sub(r"\s+", " ", str(item.get("predictor") or "")).strip()
+            outcome = re.sub(r"\s+", " ", str(item.get("outcome") or "")).strip()
+            if hid and predictor and outcome:
+                lines.append(f"{hid}: {predictor} is associated with {outcome}.")
+        return "\n".join(lines)
+
+    @staticmethod
+    def _normalize_hypothesis_ordinal_aliases(text: str, ledger: dict) -> str:
+        """Map safe ordinal aliases to frozen H-identifiers without semantic rewrite."""
+        value = str(text or "")
+        items = [item for item in (dict(ledger or {}).get("items") or []) if isinstance(item, dict)]
+        if not items:
+            return value
+        words = ["first", "second", "third", "fourth", "fifth", "sixth"]
+        for index, item in enumerate(items[: len(words)]):
+            hid = str(item.get("hypothesis_id") or "").strip().upper()
+            if not hid:
+                continue
+            word = words[index]
+            value = re.sub(rf"\b(?:the\s+)?{word}\s+hypothesis\b", hid, value, flags=re.I)
+        return value
+
     @classmethod
     def _hypothesis_contract_violations(
         cls, text: str, ledger: dict, *, section_name: str = "", require_all: bool = False
@@ -1081,45 +1111,43 @@ class GenerationRunner:
                 "reason": "Ordinal hypothesis aliases can silently reorder the canonical H1-Hn identity.",
                 "repair_instruction": "Refer to hypotheses only by their frozen H1-Hn identifiers.",
             })
-        definition_scope = bool(re.search(r"Hypothesis Development|Integrated Research Model", str(section_name or ""), flags=re.I))
-        if definition_scope:
-            all_constructs = {
-                re.sub(r"\s+", " ", str(item.get(key) or "")).strip()
-                for item in items for key in ("predictor", "outcome")
-                if str(item.get(key) or "").strip()
+        all_constructs = {
+            re.sub(r"\s+", " ", str(item.get(key) or "")).strip()
+            for item in items for key in ("predictor", "outcome")
+            if str(item.get(key) or "").strip()
+        }
+        for start, end, sentence in SSciPipelineAgent._sentence_spans(value):
+            ids = list(dict.fromkeys(
+                f"H{n}" for n in re.findall(r"\bH(\d{1,2})\b", sentence, flags=re.I)
+            ))
+            # Collective references such as "H1-H3 are summarized below"
+            # are not definitions and must not be mistaken for remapping.
+            if len(ids) != 1:
+                continue
+            hid = ids[0]
+            item = expected.get(hid)
+            if not item:
+                continue
+            predictor = re.sub(r"\s+", " ", str(item.get("predictor") or "")).strip()
+            outcome = re.sub(r"\s+", " ", str(item.get("outcome") or "")).strip()
+            lower_sentence = re.sub(r"\s+", " ", sentence).casefold()
+            mentioned_constructs = {
+                term for term in all_constructs if term.casefold() in lower_sentence
             }
-            for start, end, sentence in SSciPipelineAgent._sentence_spans(value):
-                ids = list(dict.fromkeys(
-                    f"H{n}" for n in re.findall(r"\bH(\d{1,2})\b", sentence, flags=re.I)
-                ))
-                # Collective references such as "H1-H3 are summarized below"
-                # are not definitions and must not be mistaken for remapping.
-                if len(ids) != 1:
-                    continue
-                hid = ids[0]
-                item = expected.get(hid)
-                if not item:
-                    continue
-                predictor = re.sub(r"\s+", " ", str(item.get("predictor") or "")).strip()
-                outcome = re.sub(r"\s+", " ", str(item.get("outcome") or "")).strip()
-                lower_sentence = re.sub(r"\s+", " ", sentence).casefold()
-                mentioned_constructs = {
-                    term for term in all_constructs if term.casefold() in lower_sentence
-                }
-                # Validate pairing only when the sentence actually names one or
-                # more constructs. A bare cross-reference ("H1 is summarized")
-                # remains legal and cannot silently redefine the hypothesis.
-                if mentioned_constructs and predictor and outcome and (
-                    predictor.casefold() not in lower_sentence or outcome.casefold() not in lower_sentence
-                ):
-                    rows.append({
-                        "type": "hypothesis_contract_pairing_mismatch",
-                        "id": hid,
-                        "sentence": re.sub(r"\s+", " ", sentence).strip()[:420],
-                        "expected": f"{predictor} -> {outcome}",
-                        "reason": "A canonical hypothesis label was attached to a different construct pairing.",
-                        "repair_instruction": f"Define {hid} only for {predictor} and {outcome}, using association language.",
-                    })
+            # Pairing identity is global, not limited to the theory-definition
+            # sections. Require at least two named constructs so a bare reference
+            # such as "H1 was supported" cannot be misclassified as remapping.
+            if len(mentioned_constructs) >= 2 and predictor and outcome and (
+                predictor.casefold() not in lower_sentence or outcome.casefold() not in lower_sentence
+            ):
+                rows.append({
+                    "type": "hypothesis_contract_pairing_mismatch",
+                    "id": hid,
+                    "sentence": re.sub(r"\s+", " ", sentence).strip()[:420],
+                    "expected": f"{predictor} -> {outcome}",
+                    "reason": "A canonical hypothesis label was attached to a different construct pairing.",
+                    "repair_instruction": f"Define {hid} only for {predictor} and {outcome}, using association language.",
+                })
         if require_all:
             missing = sorted(set(expected) - observed)
             if missing:
@@ -2448,6 +2476,15 @@ class GenerationRunner:
                     )
                 state["data_metadata"] = data_metadata
 
+        hypothesis_ledger = dict(data_metadata.get("hypothesis_ledger") or {}) if mode == "amj" else {}
+        hypothesis_contract = self._hypothesis_contract_directive(hypothesis_ledger)
+        if hypothesis_ledger:
+            # C5.1 single authority: legacy prose extraction may not redefine AMJ
+            # H1-Hn once the result-independent ledger exists. Downstream memory is
+            # populated deterministically from that ledger and survives checkpoints.
+            agent.global_memory["hypotheses"] = self._hypothesis_memory_text(hypothesis_ledger)
+            agent.global_memory["hypothesis_contract_locked"] = True
+
         self._qualitative_quote_sources = (
             self._qualitative_quote_source_map(data_metadata) if mode == "asq" else {}
         )
@@ -2522,12 +2559,24 @@ class GenerationRunner:
                 agent.stream_generate_research_logic(
                     topic, keywords, synthesis_result, refs_text,
                     data_evidence=planning_data_md, mode=mode,
+                    hypothesis_contract=hypothesis_contract,
                 )
             )
             agent.record_prewrite_stage("research_logic", prewrite_started, prewrite_calls)
             research_logic_contract = re.sub(
                 r"<think>.*?</think>", "", research_logic_response, flags=re.DOTALL
             ).strip()
+            if hypothesis_ledger:
+                research_logic_contract = self._normalize_hypothesis_ordinal_aliases(
+                    research_logic_contract, hypothesis_ledger
+                )
+                logic_hypothesis_rows = self._hypothesis_contract_violations(
+                    research_logic_contract, hypothesis_ledger, section_name="Research Logic Contract"
+                )
+                if logic_hypothesis_rows:
+                    raise RuntimeError(
+                        f"research_logic_hypothesis_contract_invalid:{logic_hypothesis_rows[:3]}"
+                    )
             if not research_logic_contract:
                 raise RuntimeError("research_logic_contract_missing")
             agent.global_memory["research_logic_contract"] = research_logic_contract
@@ -2536,8 +2585,13 @@ class GenerationRunner:
             working_front = agent.generate_working_front_matter(
                 topic, keywords, research_logic_contract, synthesis_result,
                 data_evidence=planning_data_md, mode=mode,
+                hypothesis_contract=hypothesis_contract,
             )
             working_abstract = str(working_front.get("abstract") or "").strip()
+            if hypothesis_ledger:
+                working_abstract = self._normalize_hypothesis_ordinal_aliases(
+                    working_abstract, hypothesis_ledger
+                )
             working_keywords = list(working_front.get("keywords") or [])
             if not working_abstract or not working_keywords:
                 raise RuntimeError("working_front_matter_missing")
@@ -2545,6 +2599,10 @@ class GenerationRunner:
                 mode, agent, quant_engine, working_abstract, data_metadata,
                 section_name="Working Abstract",
             )
+            if hypothesis_ledger:
+                front_fact_rows.extend(self._hypothesis_contract_violations(
+                    working_abstract, hypothesis_ledger, section_name="Working Abstract"
+                ))
             if front_fact_rows:
                 feedback = self._section_retry_feedback(front_fact_rows)
                 logging.warning(
@@ -2554,12 +2612,21 @@ class GenerationRunner:
                 working_front = agent.generate_working_front_matter(
                     topic, keywords, research_logic_contract, synthesis_result,
                     data_evidence=planning_data_md, mode=mode, validation_feedback=feedback,
+                    hypothesis_contract=hypothesis_contract,
                 )
                 working_abstract = str(working_front.get("abstract") or "").strip()
+                if hypothesis_ledger:
+                    working_abstract = self._normalize_hypothesis_ordinal_aliases(
+                        working_abstract, hypothesis_ledger
+                    )
                 working_keywords = list(working_front.get("keywords") or [])
                 _, remaining_front_rows = self._repair_validate_study_fact_contract(
                     mode, agent, quant_engine, working_abstract, data_metadata, section_name="Working Abstract",
                 )
+                if hypothesis_ledger:
+                    remaining_front_rows.extend(self._hypothesis_contract_violations(
+                        working_abstract, hypothesis_ledger, section_name="Working Abstract"
+                    ))
                 if remaining_front_rows:
                     raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining_front_rows[:3]}")
                 quality_diagnostics.append({
@@ -2757,6 +2824,18 @@ class GenerationRunner:
         research_logic_contract = str(
             state.get("research_logic_contract") or agent.global_memory.get("research_logic_contract") or ""
         )
+        if hypothesis_ledger and research_logic_contract:
+            research_logic_contract = self._normalize_hypothesis_ordinal_aliases(
+                research_logic_contract, hypothesis_ledger
+            )
+            resumed_logic_rows = self._hypothesis_contract_violations(
+                research_logic_contract, hypothesis_ledger, section_name="Research Logic Contract"
+            )
+            if resumed_logic_rows:
+                raise RuntimeError(
+                    f"research_logic_hypothesis_contract_invalid_on_resume:{resumed_logic_rows[:3]}"
+                )
+            agent.global_memory["research_logic_contract"] = research_logic_contract
         citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
         citation_minimums = dict(state.get("citation_minimums") or {})
         citation_reserve_targets = dict(state.get("citation_reserve_targets") or {})
@@ -2798,20 +2877,37 @@ class GenerationRunner:
         working_abstract = str(state.get("working_abstract") or "").strip()
         working_keywords = list(state.get("working_keywords") or [])
         if working_abstract and not state.get("english_finalized"):
+            if hypothesis_ledger:
+                working_abstract = self._normalize_hypothesis_ordinal_aliases(
+                    working_abstract, hypothesis_ledger
+                )
             _, resumed_front_rows = self._repair_validate_study_fact_contract(
                 mode, agent, quant_engine, working_abstract, data_metadata, section_name="Working Abstract",
             )
+            if hypothesis_ledger:
+                resumed_front_rows.extend(self._hypothesis_contract_violations(
+                    working_abstract, hypothesis_ledger, section_name="Working Abstract"
+                ))
             if resumed_front_rows:
                 feedback = self._section_retry_feedback(resumed_front_rows)
                 working_front = agent.generate_working_front_matter(
                     topic, keywords, research_logic_contract, synthesis_result,
                     data_evidence=planning_data_md, mode=mode, validation_feedback=feedback,
+                    hypothesis_contract=hypothesis_contract,
                 )
                 candidate_abstract = str(working_front.get("abstract") or "").strip()
+                if hypothesis_ledger:
+                    candidate_abstract = self._normalize_hypothesis_ordinal_aliases(
+                        candidate_abstract, hypothesis_ledger
+                    )
                 candidate_keywords = list(working_front.get("keywords") or [])
                 _, remaining = self._repair_validate_study_fact_contract(
                     mode, agent, quant_engine, candidate_abstract, data_metadata, section_name="Working Abstract",
                 )
+                if hypothesis_ledger:
+                    remaining.extend(self._hypothesis_contract_violations(
+                        candidate_abstract, hypothesis_ledger, section_name="Working Abstract"
+                    ))
                 if remaining:
                     raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining[:3]}")
                 working_abstract = candidate_abstract
@@ -3010,25 +3106,43 @@ class GenerationRunner:
             working_front = agent.generate_working_front_matter(
                 topic, keywords, research_logic_contract, synthesis_result,
                 data_evidence=planning_data_md, mode=mode,
+                hypothesis_contract=hypothesis_contract,
             )
             working_abstract = str(working_front.get("abstract") or "").strip()
+            if hypothesis_ledger:
+                working_abstract = self._normalize_hypothesis_ordinal_aliases(
+                    working_abstract, hypothesis_ledger
+                )
             working_keywords = list(working_front.get("keywords") or [])
             if not working_abstract or not working_keywords:
                 raise RuntimeError("working_front_matter_missing")
             _, front_fact_rows = self._repair_validate_study_fact_contract(
                 mode, agent, quant_engine, working_abstract, data_metadata, section_name="Working Abstract",
             )
+            if hypothesis_ledger:
+                front_fact_rows.extend(self._hypothesis_contract_violations(
+                    working_abstract, hypothesis_ledger, section_name="Working Abstract"
+                ))
             if front_fact_rows:
                 feedback = self._section_retry_feedback(front_fact_rows)
                 working_front = agent.generate_working_front_matter(
                     topic, keywords, research_logic_contract, synthesis_result,
                     data_evidence=planning_data_md, mode=mode, validation_feedback=feedback,
+                    hypothesis_contract=hypothesis_contract,
                 )
                 working_abstract = str(working_front.get("abstract") or "").strip()
+                if hypothesis_ledger:
+                    working_abstract = self._normalize_hypothesis_ordinal_aliases(
+                        working_abstract, hypothesis_ledger
+                    )
                 working_keywords = list(working_front.get("keywords") or [])
                 _, remaining = self._repair_validate_study_fact_contract(
                     mode, agent, quant_engine, working_abstract, data_metadata, section_name="Working Abstract",
                 )
+                if hypothesis_ledger:
+                    remaining.extend(self._hypothesis_contract_violations(
+                        working_abstract, hypothesis_ledger, section_name="Working Abstract"
+                    ))
                 if remaining:
                     raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining[:3]}")
                 quality_diagnostics.append({
@@ -3414,6 +3528,16 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     en_raw = re.sub(r"(?m)^(#{2,3})\s+[\d\.\s一二三四五六七八九十、]+\s*(.*)", r"\1 \2", en_raw)
                     en_raw = re.sub(r"(?m)^#{4,}\s+(.*)", r"**\1**", en_raw)
                     en_raw = re.sub(r"(?m)^#\s+(.+)$", r"## \1", en_raw)
+                    if mode == "amj" and hypothesis_ledger:
+                        normalized_hypothesis_text = self._normalize_hypothesis_ordinal_aliases(
+                            en_raw, hypothesis_ledger
+                        )
+                        if normalized_hypothesis_text != en_raw:
+                            logging.info(
+                                "Deterministic hypothesis ordinal alias normalization | unit=%s",
+                                display_name,
+                            )
+                        en_raw = normalized_hypothesis_text
                     if mode == "asq":
                         # Model prose has no authority over quote presence/count.
                         en_raw = self._strip_model_controlled_qualitative_quotes(en_raw, data_metadata)
@@ -3919,9 +4043,14 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             # front matter deterministically. No body rebalance may occur afterward.
             self._progress(92, "final_front_matter")
             final_front = agent.generate_final_front_matter(
-                topic, keywords, body_only, data_evidence=user_data_md, mode=mode
+                topic, keywords, body_only, data_evidence=user_data_md, mode=mode,
+                hypothesis_contract=hypothesis_contract,
             )
             final_abstract = str(final_front.get("abstract") or "").strip()
+            if hypothesis_ledger:
+                final_abstract = self._normalize_hypothesis_ordinal_aliases(
+                    final_abstract, hypothesis_ledger
+                )
             final_keywords = list(final_front.get("keywords") or [])
             if not final_abstract or not final_keywords:
                 raise RuntimeError("final_front_matter_missing")
@@ -3929,6 +4058,10 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 mode, agent, quant_engine, final_abstract, data_metadata,
                 section_name="Final Abstract",
             )
+            if hypothesis_ledger:
+                final_front_fact_rows.extend(self._hypothesis_contract_violations(
+                    final_abstract, hypothesis_ledger, section_name="Final Abstract"
+                ))
             if final_front_fact_rows:
                 feedback = self._section_retry_feedback(final_front_fact_rows)
                 logging.warning(
@@ -3938,9 +4071,13 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 )
                 final_front = agent.generate_final_front_matter(
                     topic, keywords, body_only, data_evidence=user_data_md, mode=mode,
-                    validation_feedback=feedback,
+                    validation_feedback=feedback, hypothesis_contract=hypothesis_contract,
                 )
                 final_abstract = str(final_front.get("abstract") or "").strip()
+                if hypothesis_ledger:
+                    final_abstract = self._normalize_hypothesis_ordinal_aliases(
+                        final_abstract, hypothesis_ledger
+                    )
                 final_keywords = list(final_front.get("keywords") or [])
                 if not final_abstract or not final_keywords:
                     raise RuntimeError("final_front_matter_missing_after_retry")
@@ -3948,6 +4085,10 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     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"
+                    ))
                 if remaining_final_fact_rows:
                     state["final_abstract_retry_exhausted"] = {
                         "attempts": 2,
@@ -3973,6 +4114,14 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             state.pop("final_abstract_retry_exhausted", None)
             full_draft_en = replace_abstract(full_draft_en, final_abstract)
             full_draft_en = self._replace_keywords(full_draft_en, final_keywords)
+            if mode == "amj" and hypothesis_ledger:
+                post_front_hypothesis_rows = self._hypothesis_contract_violations(
+                    full_draft_en, hypothesis_ledger, section_name="Full Manuscript", require_all=True
+                )
+                if post_front_hypothesis_rows:
+                    raise RuntimeError(
+                        f"final_hypothesis_contract_failed_after_front_matter:{post_front_hypothesis_rows[:3]}"
+                    )
             body_only, _reference_tail = agent.validate_reference_tail(
                 full_draft_en, minimum_references=final_reference_count
             )

core/pipeline_agent.py

@@ -195,7 +195,7 @@ class SSciPipelineAgent:
         self.global_memory = {
             "hypotheses": "", "variables": "", "model_summary": "",
             "method_summary": "", "research_logic_contract": "",
-            "core_golden_metadata": []
+            "core_golden_metadata": [], "hypothesis_contract_locked": False,
         }
         
         try: 
@@ -456,7 +456,10 @@ class SSciPipelineAgent:
 
     def _extract_memory_from_text(self, text, section_name):
         lower_sec = section_name.lower()
-        if any(kw in lower_sec for kw in ["introduction", "literature", "hypothesis", "framing"]):
+        if (
+            not bool(self.global_memory.get("hypothesis_contract_locked"))
+            and any(kw in lower_sec for kw in ["introduction", "literature", "hypothesis", "framing"])
+        ):
             hypo_matches = re.findall(r'(H\d+[:\s].*?)(?=\n|$)', text, re.IGNORECASE)
             if hypo_matches: 
                 self.global_memory["hypotheses"] = "\n".join(hypo_matches[:10])
@@ -1274,6 +1277,7 @@ class SSciPipelineAgent:
         refs_text,
         data_evidence="",
         mode="amj",
+        hypothesis_contract="",
     ):
         """Generate a provisional research-logic contract without prewriting results."""
         mode = 'asq' if str(mode).lower() == 'asq' else 'amj'
@@ -1296,6 +1300,10 @@ Literature Synthesis:
 
 {evidence_block}
 {mode_directive}
+<IMMUTABLE_HYPOTHESIS_CONTRACT>
+{str(hypothesis_contract or '')}
+</IMMUTABLE_HYPOTHESIS_CONTRACT>
+If the immutable hypothesis contract is non-empty, it is the sole authority for H-identifiers and construct pairings. Do not redefine, reorder, or infer an alternative H1-Hn architecture.
 Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It must guide later sections without fixing an expected result or conclusion. Do not use citations in the contract."""
         def _stream_direct_research_logic():
             # R4-A: research logic is a concise planning contract. A reasoning-first
@@ -1469,7 +1477,7 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
         raise DeepSeekRequestError(f'{phase} front matter validation failed: {last_error}')
 
     def generate_working_front_matter(
-        self, topic, keywords, research_logic_contract, synthesis_result, data_evidence='', mode='amj', validation_feedback=''
+        self, topic, keywords, research_logic_contract, synthesis_result, data_evidence='', mode='amj', validation_feedback='', hypothesis_contract=''
     ):
         """Create a provisional visible abstract/keyword anchor without prewriting results."""
         evidence = self._truncate_context(str(data_evidence or ''), 3500)
@@ -1490,6 +1498,10 @@ USER KEYWORD SEEDS: {keywords}
 <FROZEN_RESEARCH_EVIDENCE>
 {evidence}
 </FROZEN_RESEARCH_EVIDENCE>
+<IMMUTABLE_HYPOTHESIS_CONTRACT>
+{str(hypothesis_contract or '')}
+</IMMUTABLE_HYPOTHESIS_CONTRACT>
+If the immutable hypothesis contract is non-empty, preserve its H-identifiers and construct pairings exactly; do not invent or reorder hypotheses.
 <LOCAL_VALIDATION_FEEDBACK>
 {str(validation_feedback or '')[:2500]}
 </LOCAL_VALIDATION_FEEDBACK>"""
@@ -1503,7 +1515,7 @@ USER KEYWORD SEEDS: {keywords}
             prompt, phase='Working', max_tokens=1100, validator=validate_working,
         )
 
-    def generate_final_front_matter(self, topic, keywords, manuscript, data_evidence='', mode='amj', validation_feedback=''):
+    def generate_final_front_matter(self, topic, keywords, manuscript, data_evidence='', mode='amj', validation_feedback='', hypothesis_contract=''):
         """Generate final Abstract + Keywords only from the frozen completed body/evidence."""
         evidence = self._truncate_context(str(data_evidence or ''), 5000)
         body = self._abstract_manuscript_context(manuscript, 18000)
@@ -1516,6 +1528,10 @@ USER KEYWORD SEEDS: {keywords}
 <FROZEN_RESEARCH_EVIDENCE>
 {evidence}
 </FROZEN_RESEARCH_EVIDENCE>
+<IMMUTABLE_HYPOTHESIS_CONTRACT>
+{str(hypothesis_contract or '')}
+</IMMUTABLE_HYPOTHESIS_CONTRACT>
+If the immutable hypothesis contract is non-empty, preserve its H-identifiers and construct pairings exactly; do not invent or reorder hypotheses.
 <COMPLETED_FROZEN_MANUSCRIPT>
 {body}
 </COMPLETED_FROZEN_MANUSCRIPT>
@@ -2585,7 +2601,7 @@ Return ONLY a valid JSON array of strings."""
         return int(match.group()) if match else 10**9
 
     @staticmethod
-    def _citation_terms(value):
+    def _citation_term_sequence(value):
         stopwords = {
             "about", "after", "also", "among", "and", "are", "because",
             "been", "before", "between", "both", "can", "could", "does",
@@ -2596,7 +2612,11 @@ Return ONLY a valid JSON array of strings."""
             "with", "within", "would",
         }
         words = re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", str(value).lower())
-        return {word for word in words if word not in stopwords}
+        return [word for word in words if word not in stopwords]
+
+    @classmethod
+    def _citation_terms(cls, value):
+        return set(cls._citation_term_sequence(value))
 
     def build_claim_evidence_plan(self, tasks, topic, synthesis_result, mode='amj', target_unique=60):
         """Build a bounded citation-first plan without one oversized model call.
@@ -2810,6 +2830,17 @@ INPUT:
         'use','uses','used','using','user','users','approach','approaches','framework','frameworks',
     })
 
+    _CITATION_RECOVERY_QUERY_NOISE_TERMS = frozenset({
+        'academic','academics','accept','accepted','acceptance','acceptable','access','accessed',
+        'account','accounts','absence','absent','abandoned','accomplish','accomplished','achieve',
+        'achieved','achieves','across','accordingly','additional','aim','aims','allow','allows',
+        'available','based','basis','consider','considered','current','different','evidence',
+        'existing','finding','findings','important','indicate','indicates','paper','prior','process',
+        'processes','provide','provides','related','relationship','relationships','relevant','report',
+        'reports','show','shows','specific','support','supports','introduction','discussion',
+        'background','theoretical','framing','methodology','setting','results','hypothesis','hypotheses',
+    })
+
     @classmethod
     def _citation_recovery_overlap(cls, section_name, section_context, claim, evidence):
         anchor_terms = cls._citation_terms(f"{section_name} {section_context}")
@@ -2941,30 +2972,62 @@ INPUT:
         return selected
 
     def _deterministic_contextual_jit_query(self, topic, section_name, section_context):
-        """Build one bounded section-aware recovery query without a model call."""
-        generic = set(self._CITATION_RECOVERY_GENERIC_TERMS)
-        context_terms = [
-            term for term in sorted(self._citation_terms(section_context))
-            if term not in generic and len(term) >= 3
-        ]
-        topic_terms = [
-            term for term in sorted(self._citation_terms(topic))
-            if term not in generic and len(term) >= 3
-        ]
-        section_terms = [
-            term for term in re.findall(r"[A-Za-z][A-Za-z-]{2,}", str(section_name or '').lower())
-            if term not in generic
+        """Build one bounded topic/construct-first recovery query without a model call.
+
+        C5.1 deliberately preserves semantic/source order.  The previous code
+        converted the manuscript context to a set and then alphabetically sorted
+        it, which produced queries such as ``academic accept access ...``.  Topic
+        terms now anchor the query, while context terms are ranked by occurrence
+        frequency with first appearance as the deterministic tie-breaker.
+        """
+        noise = set(self._CITATION_RECOVERY_GENERIC_TERMS) | set(self._CITATION_RECOVERY_QUERY_NOISE_TERMS)
+
+        def clean_sequence(value):
+            output = []
+            for term in self._citation_term_sequence(value):
+                if len(term) < 3 or term in noise or term in output:
+                    continue
+                output.append(term)
+            return output
+
+        topic_terms = clean_sequence(topic)
+        section_terms = clean_sequence(section_name)
+        raw_context = [
+            term for term in self._citation_term_sequence(section_context)
+            if len(term) >= 3 and term not in noise
         ]
+        counts = Counter(raw_context)
+        first_index = {}
+        for index, term in enumerate(raw_context):
+            first_index.setdefault(term, index)
+        context_terms = sorted(
+            counts,
+            key=lambda term: (-counts[term], first_index[term]),
+        )
+
         selected = []
-        # Context is authoritative because JIT exists to repair one current unit,
-        # not to broaden the manuscript into another application domain.
-        for term in context_terms + section_terms + topic_terms:
-            normalized = self._normalize_search_query(term)
-            if normalized and normalized not in selected:
-                selected.append(normalized)
+        # A recovery query should remain anchored in the manuscript topic rather
+        # than drifting toward alphabetically early prose vocabulary.
+        topic_target = min(3, len(topic_terms))
+        for term in topic_terms[:topic_target]:
+            if term not in selected:
+                selected.append(term)
+        for term in section_terms + context_terms + topic_terms[topic_target:]:
+            if term not in selected:
+                selected.append(term)
             if len(selected) >= 5:
                 break
-        return ' '.join(selected[:5]) if len(selected) >= 3 else ''
+
+        # When two or more topic/construct-specific terms are available, at
+        # least two must survive into the bounded query.  Otherwise skip JIT
+        # instead of spending retrieval budget on a semantically weak query.
+        if len(topic_terms) >= 2 and len(set(selected) & set(topic_terms)) < 2:
+            return ''
+        if len(selected) < 3:
+            return ''
+        if any(term in noise for term in selected):
+            return ''
+        return ' '.join(selected[:5])
 
     def fetch_contextual_jit_recovery_items(
         self, *, topic, section_name, section_context, section_id='', needed=1, excluded_tags=None,
@@ -4170,6 +4233,62 @@ INPUT:
             core = f"{core} {tag}{punctuation}".strip()
         return f"{leading}{core}{trailing}"
 
+    def _adjudicate_single_source_split(self, *, sentence, selected_tag, evidence, split_reason, section_name=''):
+        """Decide whether one selected source supports the complete compound claim.
+
+        This is a bounded decision-only semantic check. It has no prose rewrite,
+        citation invention, or retrieval authority. Any malformed/failed decision
+        fails closed as partial support so the existing same-Section retry owns the
+        correction.
+        """
+        selected_evidence = ''
+        selected_reference = ''
+        for row in evidence or []:
+            if str(row.get('tag') or '').strip() == str(selected_tag or '').strip():
+                selected_evidence = str(row.get('evidence') or '').strip()
+                selected_reference = str(row.get('reference') or '').strip()
+                break
+        payload = {
+            'section': str(section_name or ''),
+            'sentence': str(sentence or ''),
+            'selected_tag': str(selected_tag or ''),
+            'selected_reference': selected_reference,
+            'selected_evidence': selected_evidence,
+            'original_split_reason': str(split_reason or '')[:700],
+        }
+        system_prompt = (
+            "You are a strict citation-support adjudicator. Decide only whether the supplied single source directly supports "
+            "the complete original sentence, including every material clause. Do not rewrite prose, add citations, infer from title alone, "
+            "or use outside knowledge. Return JSON only: "
+            '{"decision":"complete_support|partial_or_unsupported","reason":"brief evidence-grounded reason"}.'
+        )
+        try:
+            response = self.call_deepseek(
+                system_prompt,
+                json.dumps(payload, ensure_ascii=False),
+                max_tokens=700,
+                temp=0.0,
+                model_role='reasoning',
+                thinking=False,
+                allow_fallback=False,
+            )
+            parsed = self._extract_json_from_text(response)
+            if isinstance(parsed, dict):
+                decision = str(parsed.get('decision') or '').strip().lower()
+                reason = str(parsed.get('reason') or '').strip()
+                if decision == 'complete_support':
+                    return True, reason
+                if decision == 'partial_or_unsupported':
+                    return False, reason
+        except PipelineCancelledError:
+            raise
+        except Exception as exc:
+            logging.warning(
+                'Citation split adjudication failed closed: section=%s error=%s',
+                section_name, type(exc).__name__,
+            )
+        return False, 'Single-source split adjudication did not confirm complete support.'
+
     def semantic_audit_claim_specific_citations(
         self,
         text,
@@ -4391,23 +4510,30 @@ Return exactly:
                     )
                     continue
                 if status == "split":
-                    # S0-R1-C2 decision-consistency postcondition.  The audit
-                    # contract permits split only when different sources are
-                    # actually required.  If the auditor itself returns exactly
-                    # one eligible tag, that is evidence that one source supports
-                    # the complete claim; keep the original sentence and bind that
-                    # one tag instead of consuming the Section retry.
+                    # C5.1: ``split + one tag`` is an inconsistent audit decision,
+                    # not proof of complete support.  Re-adjudicate the same
+                    # sentence/source pair once, without rewrite/retrieval authority.
+                    # This preserves C2's legitimate full-support recovery while
+                    # preventing a partially unsupported clause from inheriting an
+                    # overbroad sentence-final citation.
                     if len(revised_tags) == 1:
                         selected = next(iter(revised_tags))
-                        replacements[record["id"]] = self._citation_tag_only_rewrite(
-                            record["original"], selected
+                        complete_support, adjudication_reason = self._adjudicate_single_source_split(
+                            sentence=record["original"], selected_tag=selected,
+                            evidence=record.get("evidence") or [], split_reason=reason,
+                            section_name=section_name,
                         )
-                        self._append_citation_audit(
-                            section_name, "normalize_inconsistent_split_to_single_source",
-                            record["original"], replacements[record["id"]],
-                            reason or "Audit returned split with only one eligible supporting source.",
-                        )
-                        continue
+                        if complete_support:
+                            replacements[record["id"]] = self._citation_tag_only_rewrite(
+                                record["original"], selected
+                            )
+                            self._append_citation_audit(
+                                section_name, "normalize_inconsistent_split_to_single_source",
+                                record["original"], replacements[record["id"]],
+                                adjudication_reason or reason or "Decision-only adjudication confirmed complete support.",
+                            )
+                            continue
+                        reason = adjudication_reason or reason
                     violation = {
                         "type":"citation_claim_split_required", "id":record["id"],
                         "sentence":record["original"][:500], "reason":reason,