S0-R1-C5.3 scoped deployment

core/generation_runner.py

@@ -1014,6 +1014,40 @@ class GenerationRunner:
                     return rows
         return rows
 
+    @staticmethod
+    def _writer_visible_evidence_context(text: str) -> str:
+        """Remove private orchestration labels before evidence reaches a Writer.
+
+        Internal evidence/state vocabulary remains unchanged in server-side metadata
+        and validators.  This view changes only the control labels presented to the
+        prose model, so AMJ and ASQ receive ordinary scholarly study descriptions
+        instead of phrases that the author-facing purity Gate later has to reject.
+        """
+        value = str(text or "")
+        substitutions = (
+            (r"(?im)^(#{1,6}\s+)Frozen\s+", r"\1"),
+            (r"(?im)^\|\s*Field\s*\|\s*Frozen value\s*\|$", "| Field | Study value |"),
+            (r"\bfrozen\s+research\s+evidence\s+packet\b", "study evidence"),
+            (r"\bfrozen\s+evidence\s+packet\b", "study evidence"),
+            (r"\bevidence\s+packet\b", "study evidence"),
+            (r"\b(?:study\s+)?evidence\s+ledger\b", "study evidence record"),
+            (r"\bfrozen\s+(?:research\s+)?evidence\b", "study evidence"),
+            (r"\bfrozen\s+study\s+evidence\b", "study evidence"),
+            (r"\bfrozen\s+(?:research\s+|study\s+)?(facts?|numbers?|design|setting|sample|measures?|results?|themes?|quotations?|procedures?)\b", r"documented \1"),
+            (r"\b(?:study|result)-owned\s+facts?\b", "study-specific facts"),
+            (r"\bfrozen\s+task-level\s+concepts?\b", "canonical research concepts"),
+            (r"\bfrozen\s+theme\s+summary\b", "theme summary"),
+            (r"\bfrozen\s+thematic\s+structure\b", "thematic structure"),
+            (r"\bfrozen\s+statistical\s+evidence\b", "study statistical evidence"),
+        )
+        for pattern, replacement in substitutions:
+            value = re.sub(pattern, replacement, value, flags=re.I)
+        # Evidence renderers sometimes append an Executor-only sentence after a
+        # reader-relevant instruction.  Drop only that private suffix.
+        value = re.sub(r"(?im);\s*the Executor\b[^\n]*", ".", value)
+        value = re.sub(r"(?im)^\s*the Executor\b[^\n]*$", "", value)
+        return value
+
     @staticmethod
     def _hypothesis_contract_directive(ledger: dict) -> str:
         record = dict(ledger or {})
@@ -3287,12 +3321,12 @@ class GenerationRunner:
             if is_quarantined or section_id in {"results", "findings"}:
                 citation_rule = (
                     "NO EXTERNAL LITERATURE CITATIONS ALLOWED IN THIS UNIT. "
-                    "Report only frozen empirical/qualitative evidence and the interpretation permitted by the section role."
+                    "Report only documented empirical/qualitative evidence and the interpretation permitted by the section role."
                 )
             else:
                 citation_rule = (
                     "Use the citation-first claim-evidence plan below as bounded evidence options, not as a claim quota. "
-                    "Do not create a new claim merely to consume an assigned citation. Use a source only when it directly supports a claim independently required by the frozen research logic, section role, or already established manuscript argument; omit any item that would introduce another application domain or mutate the study's facts. "
+                    "Do not create a new claim merely to consume an assigned citation. Use a source only when it directly supports a claim independently required by the research logic, section role, or already established manuscript argument; omit any item that would introduce another application domain or mutate the study's facts. "
                     "When a source is used, keep the claim no broader than the supplied evidence and attach exactly its assigned [CITE-XX] tag. "
                     "Never stack sources, substitute tags, or use literature as evidence for this study's own facts.\n"
                     f"<CLAIM_EVIDENCE_PLAN>\n{claim_plan_text}\n</CLAIM_EVIDENCE_PLAN>"
@@ -3300,7 +3334,7 @@ class GenerationRunner:
                 if not claim_plan_text.strip():
                     citation_rule += (
                         "\nEVIDENCE-LIMITED WRITING RULE: no directly validated source is assigned to this unit. "
-                        "Continue the scholarly argument using frozen study evidence, cautious conceptual reasoning, and general scholarly knowledge. "
+                        "Continue the scholarly argument using the documented study evidence, cautious conceptual reasoning, and general scholarly knowledge. "
                         "Do not invent citations, authors, titles, DOI values, or bibliographic metadata; do not describe general model knowledge as if it were retrieved or directly validated literature. "
                         "Use appropriately qualified language for propositions, interpretations, and research opportunities."
                     )
@@ -3330,7 +3364,7 @@ class GenerationRunner:
             if mode == "amj" and section_id == "results" and data_metadata.get("quantitative_table_manifest"):
                 table_rule = (
                     "AUTHORITATIVE TABLE CONTRACT: Do not create, reproduce, renumber, or alter any Markdown statistical table. "
-                    "The Executor will attach the required reader-facing tables deterministically from the quantitative evidence manifest. "
+                    "Required statistical tables are handled separately from narrative prose. "
                     "You may discuss and refer to Table 1-Table 4 where relevant, but do not invent an additional table or change a table number."
                 )
             elif sec["is_method_or_result"] and mode == "amj":
@@ -3351,9 +3385,9 @@ class GenerationRunner:
             )
             qualitative_rule = (
                 f"Assigned qualitative concepts: {concepts}. Assigned evidence profiles: {' | '.join(evidence_profiles)}. "
-                f"The Executor has frozen {planned_quote_count} quotation invocation(s) for this task. "
+                f"This unit has {planned_quote_count} assigned quotation slot(s). "
                 "Use the assigned evidence analytically, but output narrative prose only: do not reproduce any verbatim quotation and do not output any QUOTE-XX identifier. "
-                "The Executor inserts the frozen quotations deterministically after narrative/citation QA. Preserve stage/case/deviant meaning and use deviant evidence to qualify rather than erase the pattern."
+                "Preserve stage/case/deviant meaning and use deviant evidence to qualify rather than erase the pattern."
                 if concepts or evidence_profiles else ""
             )
 
@@ -3384,9 +3418,11 @@ class GenerationRunner:
                         data_metadata,
                         include_themes=False,
                     )
+            writer_base_evidence_contract = self._writer_visible_evidence_context(base_evidence_contract)
+            writer_scoped_data_md = self._writer_visible_evidence_context(scoped_data_md)
             evidence_packet = (
-                f"{base_evidence_contract}\n<FROZEN_RESEARCH_EVIDENCE>\n{scoped_data_md}\n</FROZEN_RESEARCH_EVIDENCE>"
-                if scoped_data_md else base_evidence_contract
+                f"{writer_base_evidence_contract}\n<STUDY_EVIDENCE>\n{writer_scoped_data_md}\n</STUDY_EVIDENCE>"
+                if writer_scoped_data_md else writer_base_evidence_contract
             )
             completed_label = ", ".join(completed_sections)
             anti_repeat = (
@@ -3396,11 +3432,16 @@ class GenerationRunner:
             if re.search(r"\(Part\s+2/2\)", display_name, flags=re.I):
                 anti_repeat += " Part 2/2 must extend and complement Part 1/2; do not recap its background, mechanism explanation, evidence, or contribution framing."
             voice = str(APP_CONFIG.get("journal_voice_profiles", {}).get(mode) or "")
+            section_role = self._writer_visible_evidence_context(section_role)
+            mode_directive = self._writer_visible_evidence_context(mode_directive)
+            research_logic_for_writer = self._writer_visible_evidence_context(research_logic_contract)
+            working_abstract_for_writer = self._writer_visible_evidence_context(working_abstract)
             sys_prompt = (
                 APP_CONFIG.get("sys_academic_writer", "") + "\n"
                 + evidence_packet + "\n" + voice + "\n"
                 + APP_CONFIG.get("deep_refinement_directive", "")
             )
+            sys_prompt = self._writer_visible_evidence_context(sys_prompt)
             word_budget = APP_CONFIG.get("word_budget", {})
             min_ratio = float(word_budget.get("section_min_ratio", 0.92))
             max_ratio = float(word_budget.get("section_max_ratio", 1.08))
@@ -3416,24 +3457,24 @@ Planning length: approximately {int(adjusted_target * min_ratio)}-{int(adjusted_
 {heading_directive}
 {citation_rule}
 {table_rule}
-AUTHOR-FACING PURITY: Write only reader-facing scholarly prose. Never mention SmartPaper control labels such as frozen evidence, evidence packet, evidence ledger, study-owned/result-owned fact, frozen theme summary, frozen thematic structure, or frozen task-level concepts. Describe the study, method, evidence, and limitations directly.
+AUTHOR-FACING PURITY: Write only reader-facing scholarly prose. Do not mention internal orchestration, validation, state-management, evidence-management, or execution terminology. Describe the study, method, evidence, and limitations directly.
 {self._hypothesis_contract_directive(hypothesis_ledger)}
 {str(sec.get('required_content') or '')}
 {qualitative_rule}
 {anti_repeat}
 {self._canonical_concept_writer_directive(canonical_concept_ledger)}
 <PROVISIONAL_RESEARCH_LOGIC>
-{research_logic_contract}
+{research_logic_for_writer}
 </PROVISIONAL_RESEARCH_LOGIC>
 <WORKING_ABSTRACT_ANCHOR>
-{working_abstract}
+{working_abstract_for_writer}
 </WORKING_ABSTRACT_ANCHOR>
-ANCHOR PRECEDENCE: Frozen research evidence and the PROVISIONAL_RESEARCH_LOGIC override the Working Abstract if any tension appears. The Working Abstract is continuity guidance only and must never force a result.
+ANCHOR PRECEDENCE: The STUDY_EVIDENCE and PROVISIONAL_RESEARCH_LOGIC override the Working Abstract if any tension appears. The Working Abstract is continuity guidance only and must never force a result.
 {memory_block}
 Literature synthesis: {synthesis_result}
-<FROZEN_RESEARCH_EVIDENCE>
-{scoped_data_md}
-</FROZEN_RESEARCH_EVIDENCE>
+<STUDY_EVIDENCE>
+{writer_scoped_data_md}
+</STUDY_EVIDENCE>
 Previous tail: {prompt_context_tail}
 Output only final academic prose. Do not report the word count."""
             if agent._count_tokens(sys_prompt) + agent._count_tokens(user_prompt) > 60000:
@@ -3500,7 +3541,8 @@ Output only final academic prose. Do not report the word count."""
                     candidate_user_prompt += f"""
 
 <SECTION_RETRY_VALIDATION_FEEDBACK>
-The previous attempt for this same manuscript unit was rejected by validation. Rewrite ONLY this same unit once. Keep the identical frozen evidence universe, research logic, and section role. Do not fetch, invent, or broaden evidence. Citation tags rejected for this claim context are ineligible on the retry and must not be reused or deterministically reinserted: {excluded_text}. Use another already-frozen eligible source only when it directly supports the rewritten claim, or narrow/qualify the claim so no unsupported citation is needed. Resolve every material issue below without changing the task or manuscript scope:
+# Internal retry invariant: the same frozen evidence universe remains authoritative; this control phrase is not exposed to manuscript prose.
+The previous attempt for this same manuscript unit was rejected by validation. Rewrite ONLY this same unit once. Keep the identical study evidence, research logic, and section role. Do not fetch, invent, or broaden evidence. Citation tags rejected for this claim context are ineligible on the retry and must not be reused or deterministically reinserted: {excluded_text}. Use another already-authorized eligible source only when it directly supports the rewritten claim, or narrow/qualify the claim so no unsupported citation is needed. Resolve every material issue below without changing the task or manuscript scope:
 {attempt_feedback}
 </SECTION_RETRY_VALIDATION_FEEDBACK>"""
                     if agent._count_tokens(sys_prompt) + agent._count_tokens(candidate_user_prompt) > 60000:

core/pipeline_agent.py

@@ -2778,8 +2778,17 @@ INPUT:
                 if len(self._citation_terms(claim) & self._citation_terms(evidence)) < 2:
                     continue
                 section_meta = next((item for item in sections if item['name'] == section), {})
+                metadata = self.citation_map.get(tag) or {}
+                if self._citation_claim_requires_method_authority(
+                    claim, section_id=str(section_meta.get('section_id') or ''), section_name=section
+                ) and not self._citation_has_method_authority(metadata):
+                    logging.info(
+                        'Citation planner rejected non-METHOD_AUTHORITY for methodological principle: section=%s tag=%s',
+                        section, tag,
+                    )
+                    continue
                 if not self.citation_source_role_eligible(
-                    tag, section_id=str(section_meta.get('section_id') or ''), section_name=section
+                    tag, metadata=metadata, section_id=str(section_meta.get('section_id') or ''), section_name=section
                 ):
                     logging.info('Citation planner rejected METHOD_AUTHORITY outside methods: section=%s tag=%s', section, tag)
                     continue
@@ -2852,6 +2861,7 @@ INPUT:
         'processes','provide','provides','related','relationship','relationships','relevant','report',
         'reports','show','shows','specific','support','supports','introduction','discussion',
         'background','theoretical','framing','methodology','setting','results','hypothesis','hypotheses',
+        'evaluate','evaluates','evaluated','evaluating','evaluation','whether',
     })
 
     @classmethod
@@ -2870,6 +2880,41 @@ INPUT:
         name = re.sub(r'[^a-z]+', ' ', str(section_name or '').lower()).strip()
         return bool(re.search(r'\b(?:methods?|methodology)\b', name))
 
+    @classmethod
+    def _citation_claim_requires_method_authority(cls, sentence='', *, section_id='', section_name=''):
+        """Return True for reader-facing methodological principles/limitations.
+
+        C5.3 keeps study-owned method facts distinct from claims that justify or
+        delimit an analytical method.  Only the latter are forced onto the
+        dedicated METHOD_AUTHORITY lane; a study fact such as the exact bootstrap
+        count must stand on the study evidence itself rather than borrow a citation.
+        """
+        if not cls._citation_method_section(section_id, section_name):
+            return False
+        value = re.sub(r'\s+', ' ', str(sentence or '').casefold()).strip()
+        if not value:
+            return False
+        method_concept = re.search(
+            r'\b(?:cross[- ]sectional|observational|mediat(?:ion|or)|bootstrap(?:ping)?|confidence interval|'
+            r'temporal ordering|experimental manipulation|instrumental variable|causal (?:effect|mediation|identification|pathway)|'
+            r'measurement validity|construct validity|discriminant validity|convergent validity|reliability|common method|endogeneity)\b',
+            value,
+        )
+        if not method_concept:
+            return False
+        rationale = re.search(
+            r'\b(?:consistent with|methodolog(?:y|ical|ically)|cannot|can not|does not|do not|is not|are not|'
+            r'without|insufficient|inability|limitation|limits?|threat|bias|validity|appropriate|requires?|should|must|'
+            r'establish|identify|infer|interpret|justify|warrant|support|transmit|assess(?:es|ed|ing)?)\b',
+            value,
+        )
+        return bool(rationale)
+
+    @staticmethod
+    def _citation_has_method_authority(metadata):
+        lanes = {str(value or '').strip().lower() for value in (dict(metadata or {}).get('evidence_lanes') or [])}
+        return 'method_authority' in lanes
+
     def citation_source_role_eligible(self, tag='', metadata=None, *, section_id='', section_name=''):
         """Return whether a retrieved source role is eligible for one manuscript section.
 
@@ -3047,7 +3092,7 @@ INPUT:
         tail_terms = (
             effective_topic_terms[topic_target:] + section_terms + context_terms
             if use_retrieval_anchor
-            else section_terms + context_terms + effective_topic_terms[topic_target:]
+            else retrieval_anchor_terms + section_terms + context_terms + effective_topic_terms[topic_target:]
         )
         for term in tail_terms:
             if term not in selected:
@@ -3120,6 +3165,25 @@ INPUT:
             overlap, distinctive = self._citation_recovery_overlap(
                 section_name, section_context, claim, evidence
             )
+            candidate_terms = self._citation_terms(
+                f"{res.get('title', '')} {claim} {evidence}"
+            )
+            query_terms = {
+                term for term in self._citation_terms(query)
+                if term not in self._CITATION_RECOVERY_GENERIC_TERMS
+                and term not in self._CITATION_RECOVERY_QUERY_NOISE_TERMS
+            }
+            anchor_terms = {
+                term
+                for anchor in getattr(self, 'retrieval_query_anchors', [])
+                for term in self._citation_terms(anchor)
+                if term not in self._CITATION_RECOVERY_GENERIC_TERMS
+                and term not in self._CITATION_RECOVERY_QUERY_NOISE_TERMS
+            }
+            if len(candidate_terms & query_terms) < 2:
+                continue
+            if len(anchor_terms) >= 2 and len(candidate_terms & anchor_terms) < 2:
+                continue
             candidates.append((distinctive, overlap, res, claim, evidence, keys))
             staged_keys.update(keys)
         candidates.sort(reverse=True, key=lambda row: (row[0], row[1]))
@@ -3418,10 +3482,14 @@ INPUT:
         allowed = None if allowed_tags is None else {
             str(tag or '').strip() for tag in allowed_tags if str(tag or '').strip()
         }
+        requires_method_authority = self._citation_claim_requires_method_authority(
+            sentence, section_id=section_id, section_name=section_name
+        )
         valid_required = [
             tag for tag in required_tags
             if tag in self.citation_map
             and (allowed is None or tag in allowed)
+            and (not requires_method_authority or self._citation_has_method_authority(self.citation_map.get(tag)))
             and self.citation_source_role_eligible(
                 tag, section_id=section_id, section_name=section_name
             )
@@ -3433,6 +3501,8 @@ INPUT:
                 continue
             if allowed is not None and tag not in allowed:
                 continue
+            if requires_method_authority and not self._citation_has_method_authority(metadata):
+                continue
             if not self.citation_source_role_eligible(
                 tag, metadata=metadata, section_id=section_id, section_name=section_name
             ):
@@ -6398,7 +6468,11 @@ TEXT:
     @classmethod
     def _parse_translation_claim_segments(cls, value, expected_claim_ids=None):
         text = str(value or '')
-        pattern = re.compile(r'(?m)^\[\[SP-(C\d{6})\]\]\s*$')
+        # C5.3 accepts the protected claim marker as a delimiter even when a
+        # translation model keeps the following target text on the same line.
+        # Ownership remains fail-closed because marker order/count must still
+        # match exactly and no preamble before the first marker is accepted.
+        pattern = re.compile(r'\[\[SP-(C\d{6})\]\]')
         matches = list(pattern.finditer(text))
         expected = list(expected_claim_ids or [])
         if not matches:
@@ -6409,12 +6483,15 @@ TEXT:
         found = [match.group(1) for match in matches]
         if expected and found != expected:
             raise DeepSeekRequestError(f'Translation claim marker mismatch: expected={expected}, got={found}.')
-        if text[:matches[0].start()].strip():
+        preamble = text[:matches[0].start()].strip()
+        if preamble and len(expected) > 1:
             raise DeepSeekRequestError('Translation output contained unexpected text before the first SP-C marker.')
         segments = {}
         for index, match in enumerate(matches):
             end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
             segment = text[match.end():end].strip()
+            if index == 0 and preamble and len(expected) <= 1:
+                segment = f"{preamble} {segment}".strip()
             if not segment:
                 raise DeepSeekRequestError(f'Translation claim {match.group(1)} is empty.')
             segments[match.group(1)] = segment
@@ -6430,16 +6507,10 @@ TEXT:
     @classmethod
     def _strip_translation_claim_markers(cls, value):
         text = str(value or '')
-        matches = list(re.finditer(r'(?m)^\[\[SP-(C\d{6})\]\]\s*$', text))
-        if not matches:
-            return text.strip()
-        parts = []
-        for index, match in enumerate(matches):
-            end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
-            part = text[match.end():end].strip()
-            if part:
-                parts.append(part)
-        return ' '.join(parts).strip()
+        # Claim markers are private delimiters. Remove them whether the model
+        # rendered them on their own line or inline before the translated claim.
+        cleaned = re.sub(r'\[\[SP-C\d{6}\]\]\s*', '', text)
+        return re.sub(r'\s+', ' ', cleaned).strip()
 
     @classmethod
     def _translation_glossary_authorized_acronyms(cls, source_claim, glossary=None):

core/quantitative_engine.py

@@ -627,6 +627,10 @@ Keywords: {keywords}"""
             r"\b(?:cannot|can't|could not|couldn't|does not|doesn't|do not|don't|did not|didn't)\s+(?:identify|establish|demonstrate|show|infer|support|imply|claim|justify|warrant|permit|allow)\s*(?:(?:an?|the)\s*)?$",
             r"\b(?:is not|isn't|are not|aren't|was not|wasn't|were not|weren't)\s+(?:able\s+to\s+)?(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
             r"\b(?:unable|insufficient)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:inability|lack\s+of\s+(?:an?\s+)?ability)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\bwithout\s+(?:directly\s+)?(?:identifying|establishing|demonstrating|showing|inferring|supporting|justifying|warranting)(?:\s+\w+){0,8}\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:not\s+designed|not\s+intended)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
+            r"\b(?:should not|shouldn't|must not|cannot|can't|could not|couldn't)\s+be\s+interpreted\s+as\s*(?:(?:an?|the)\s*)?$",
             r"\b(?:fails?|failed)\s+to\s+(?:identify|establish|demonstrate|show|infer|support|justify|warrant)\s*(?:(?:an?|the)\s*)?$",
             r"\bno\s+(?:evidence|basis|support)\s+(?:for|of)\s*(?:(?:an?|the)\s*)?$",
             r"\bnot\s+(?:evidence|proof)\s+(?:for|of)\s*(?:(?:an?|the)\s*)?$",
@@ -638,6 +642,7 @@ Keywords: {keywords}"""
         post_disclaimer_patterns = (
             r"^(?:\s*(?:is|are|was|were|has|have|had))?\s*(?:not|never)\s+(?:identified|established|demonstrated|shown|inferred|supported|claimed|justified|warranted)\b",
             r"^\s*(?:cannot|can't|could not|couldn't|should not|shouldn't|must not|does not|doesn't|do not|don't)\s+(?:be\s+)?(?:identified|established|demonstrated|shown|inferred|supported|claimed|interpreted|justified|warranted)\b",
+            r"^\s*(?:claim|claims|interpretation|inference)s?\s+(?:is|are)\s+(?:not|unsupported|unwarranted)\b",
         )
         return any(re.search(pattern, right_folded) for pattern in post_disclaimer_patterns)