R14-KK-G1 Grammar Evidence Continuity + Adaptive Translation Batch Controller

core/generation_runner.py

@@ -34,10 +34,16 @@ from utils.file_parser import extract_text_from_files
 
 ProgressCallback = Callable[..., None]
 
-MIN_FINAL_REFERENCES = 50
-LITERATURE_EVIDENCE_TARGET = 75
-CITATION_PLAN_TARGET = 70
-TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v5'
+CITATION_SEMANTIC_SURVIVAL_RATIO = 0.78
+CITATION_ROLE_RULES = {
+    "introduction": (3, 180),
+    "theory": (3, 180),
+    "theoretical_framing": (3, 180),
+    "methodology": (2, 280),
+    "methods": (2, 280),
+    "discussion": (2, 220),
+}
+TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v6'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -1493,6 +1499,66 @@ class GenerationRunner:
             "ratio": round(ratio, 4), "status": status, "recommendation": recommendation, "nonfatal": True,
         }
 
+    @staticmethod
+    def _citation_eligible_section_ids(mode: str) -> set[str]:
+        return (
+            {"introduction", "theoretical_framing", "methods", "discussion"}
+            if str(mode).lower() == "asq"
+            else {"introduction", "theory", "methodology", "discussion"}
+        )
+
+    @classmethod
+    def _adaptive_citation_requirements(cls, tasks, mode: str):
+        """Derive evidence demand and semantic-survival reserve from manuscript units."""
+        allowed = cls._citation_eligible_section_ids(mode)
+        minimums = {}
+        reserve_targets = {}
+        for task in tasks or []:
+            section_id = str(task.get("section_id") or "")
+            display_name = str(task.get("display_name") or "").strip()
+            if section_id not in allowed or not display_name:
+                continue
+            base, words_per_source = CITATION_ROLE_RULES.get(section_id, (2, 240))
+            target_words = max(1, int(task.get("target_words") or 1))
+            minimum = max(base, int(math.ceil(target_words / max(1, words_per_source))))
+            reserve = max(
+                minimum,
+                int(math.ceil(minimum / max(0.01, CITATION_SEMANTIC_SURVIVAL_RATIO))),
+            )
+            minimums[display_name] = minimum
+            reserve_targets[display_name] = reserve
+        return minimums, reserve_targets
+
+    @staticmethod
+    def _adaptive_literature_candidate_target(target_words: int, agent) -> int:
+        """Adaptive retrieval aspiration; never a final reference-count quota."""
+        dynamic = max(24, int(math.ceil(max(1, int(target_words or 1)) / 90.0)))
+        configured_cap = max(1, int(getattr(agent, "lit_target_papers", dynamic) or dynamic))
+        return min(configured_cap, dynamic)
+
+    @staticmethod
+    def _citation_task_context(task, research_logic_contract="", synthesis_result="") -> str:
+        parts = [
+            str(task.get("display_name") or ""),
+            str(task.get("required_content") or ""),
+            " ".join(str(value) for value in (task.get("concepts") or []) if str(value).strip()),
+            str(research_logic_contract or "")[:1600],
+            str(synthesis_result or "")[:1600],
+        ]
+        return re.sub(r"\s+", " ", " ".join(part for part in parts if part)).strip()
+
+    @staticmethod
+    def _literature_insufficient_error(shortfalls) -> RuntimeError:
+        details = "; ".join(
+            f"{name}={actual}/{required}"
+            for name, actual, required in (shortfalls or [])[:8]
+        )
+        return RuntimeError(
+            "E_LITERATURE_INSUFFICIENT: high-relevance claim-specific literature is insufficient "
+            f"for the planned manuscript units ({details}). Please revise the research topic or "
+            "keywords and try again; unrelated references will not be used to satisfy a quota."
+        )
+
     def _resolve_paths(self, items) -> list[str]:
         output = []
         for item in items or []:
@@ -1615,16 +1681,16 @@ class GenerationRunner:
         refs_text = str(state.get("refs_text") or "")
         if not refs_text:
             self._progress(8, "S2 + OpenAlex")
+            literature_candidate_target = self._adaptive_literature_candidate_target(target_words, agent)
             refs_text = agent.fetch_references_parallel(
                 topic,
                 keywords,
-                min_required=LITERATURE_EVIDENCE_TARGET,
+                min_required=literature_candidate_target,
                 progress_callback=lambda: self._progress(9, "S2 + OpenAlex"),
             )
-            if len(agent.citation_map) < MIN_FINAL_REFERENCES:
-                raise RuntimeError(
-                    f"Insufficient eligible references: {len(agent.citation_map)}/{MIN_FINAL_REFERENCES}"
-                )
+            if not agent.citation_map:
+                raise self._literature_insufficient_error([("retrieved literature pool", 0, 1)])
+            state["literature_candidate_target"] = literature_candidate_target
             if user_lit_context:
                 core_refs = agent.parse_user_core_literature(user_lit_context)
                 if core_refs:
@@ -1699,29 +1765,86 @@ class GenerationRunner:
             if jit_texts:
                 rag_engine._initialize_chunks([jit_texts])
             self._progress(15, "citation_planning")
-            citation_plan = agent.build_claim_evidence_plan(
-                adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
+            citation_minimums, citation_reserve_targets = self._adaptive_citation_requirements(
+                adaptive_structure, mode
             )
-            canonical_concept_ledger = self._build_canonical_concept_ledger(
-                mode, data_metadata, keywords=keywords, adaptive_structure=adaptive_structure,
-                research_logic_contract=research_logic_contract,
+            citation_plan_target = sum(citation_reserve_targets.values())
+            citation_plan = agent.build_claim_evidence_plan(
+                adaptive_structure, topic, synthesis_result, mode=mode,
+                target_unique=max(1, citation_plan_target),
             )
-            planned_unique = {
-                item.get("tag")
+
+            # Fill unit-specific reserve gaps before expensive drafting. Existing
+            # retrieved evidence is preferred; bounded contextual JIT is last resort.
+            planned_tags = {
+                str(item.get("tag") or "")
                 for items in citation_plan.values()
                 for item in items
                 if item.get("tag")
             }
-            if len(planned_unique) < MIN_FINAL_REFERENCES:
-                raise RuntimeError(
-                    "Insufficient claim-evidence plan before drafting: "
-                    f"{len(planned_unique)}/{MIN_FINAL_REFERENCES}."
+            task_by_name = {
+                str(task.get("display_name") or ""): task
+                for task in adaptive_structure
+                if str(task.get("display_name") or "")
+            }
+            for display_name, reserve_target in citation_reserve_targets.items():
+                planned_items = citation_plan.setdefault(display_name, [])
+                shortfall = max(0, reserve_target - len(planned_items))
+                if shortfall <= 0:
+                    continue
+                section_context = self._citation_task_context(
+                    task_by_name.get(display_name, {}), research_logic_contract, synthesis_result
+                )
+                recovery_items = agent.select_contextual_citation_recovery_items(
+                    [], section_name=display_name, section_context=section_context,
+                    needed=shortfall, excluded_tags=planned_tags,
                 )
+                for item in recovery_items:
+                    tag = str(item.get("tag") or "")
+                    if tag and tag not in planned_tags:
+                        planned_items.append(item)
+                        planned_tags.add(tag)
+                # External JIT is not used merely to hit the reserve target.
+                # It is triggered only when the unit remains below its actual
+                # evidence-demand minimum after exhausting already retrieved
+                # relevant literature.
+                minimum_shortfall = max(
+                    0, int(citation_minimums.get(display_name, 0)) - len(planned_items)
+                )
+                if minimum_shortfall > 0:
+                    jit_items = agent.fetch_contextual_jit_recovery_items(
+                        topic=topic, section_name=display_name, section_context=section_context,
+                        needed=minimum_shortfall, excluded_tags=planned_tags,
+                    )
+                    for item in jit_items:
+                        tag = str(item.get("tag") or "")
+                        if tag and tag not in planned_tags:
+                            planned_items.append(item)
+                            planned_tags.add(tag)
+
+            shortfalls = [
+                (name, len(citation_plan.get(name) or []), required)
+                for name, required in citation_minimums.items()
+                if len(citation_plan.get(name) or []) < required
+            ]
+            if shortfalls:
+                raise self._literature_insufficient_error(shortfalls)
+            logging.info(
+                "Adaptive citation feasibility passed: minimum_total=%s reserve_target=%s planned_unique=%s units=%s",
+                sum(citation_minimums.values()), citation_plan_target, len(planned_tags), len(citation_minimums),
+            )
+            canonical_concept_ledger = self._build_canonical_concept_ledger(
+                mode, data_metadata, keywords=keywords, adaptive_structure=adaptive_structure,
+                research_logic_contract=research_logic_contract,
+            )
             state.update(
                 {
                     "adaptive_structure": adaptive_structure,
                     "quote_invocation_plan": quote_invocation_plan,
                     "citation_plan": citation_plan,
+                    "citation_minimums": citation_minimums,
+                    "citation_reserve_targets": citation_reserve_targets,
+                    "citation_validated_tags_by_unit": {},
                     "research_logic_contract": research_logic_contract,
                     "working_abstract": working_abstract,
                     "working_keywords": working_keywords,
@@ -1753,6 +1876,16 @@ class GenerationRunner:
             state.get("research_logic_contract") or agent.global_memory.get("research_logic_contract") or ""
         )
         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 {})
+        citation_validated_tags_by_unit = {
+            str(name): list(tags or [])
+            for name, tags in dict(state.get("citation_validated_tags_by_unit") or {}).items()
+        }
+        if not citation_minimums:
+            citation_minimums, citation_reserve_targets = self._adaptive_citation_requirements(
+                adaptive_structure, mode
+            )
         translation_sections = dict(state.get('translation_sections') or {})
         translation_glossary = dict(state.get('translation_glossary') or {})
         canonical_concept_ledger = state.get('canonical_concept_ledger')
@@ -1866,9 +1999,20 @@ class GenerationRunner:
         if not citation_plan:
             self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
-                adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
+                adaptive_structure, topic, synthesis_result, mode=mode,
+                target_unique=max(1, sum(citation_reserve_targets.values())),
             )
+            shortfalls = [
+                (name, len(citation_plan.get(name) or []), required)
+                for name, required in citation_minimums.items()
+                if len(citation_plan.get(name) or []) < required
+            ]
+            if shortfalls:
+                raise self._literature_insufficient_error(shortfalls)
             state["citation_plan"] = citation_plan
+            state["citation_minimums"] = citation_minimums
+            state["citation_reserve_targets"] = citation_reserve_targets
+            state["citation_validated_tags_by_unit"] = citation_validated_tags_by_unit
 
         quote_invocation_plan = (
             dict(state.get("quote_invocation_plan") or {}) if mode == "asq" else {}
@@ -2105,9 +2249,13 @@ Output only final academic prose. Do not report the word count."""
             used_after = set(agent.used_citations)
             survived = used_after - used_before
             if assigned_tag_list and not is_quarantined:
+                adaptive_minimum = max(1, int(citation_minimums.get(display_name, 1)))
                 required_survival = min(
                     len(assigned_tag_list),
-                    max(1, int(math.ceil(len(assigned_tag_list) * 0.78))),
+                    max(
+                        adaptive_minimum,
+                        int(math.ceil(len(assigned_tag_list) * CITATION_SEMANTIC_SURVIVAL_RATIO)),
+                    ),
                 )
                 if len(survived) < required_survival:
                     missing_items = [
@@ -2127,6 +2275,13 @@ Output only final academic prose. Do not report the word count."""
                                 excluded_tags=used_after | {str(item.get("tag") or "") for item in recovery_items},
                             )
                         )
+                    planned_tags_for_unit = {str(item.get("tag") or "") for item in planned_items}
+                    for recovery_item in recovery_items[:needed]:
+                        tag = str(recovery_item.get("tag") or "")
+                        if tag and tag not in planned_tags_for_unit:
+                            planned_items.append(recovery_item)
+                            planned_tags_for_unit.add(tag)
+                    citation_plan[display_name] = planned_items
                     supplemental_raw = agent.build_citation_recovery_paragraph(
                         recovery_items[:needed], section_name=display_name, section_context=en_resolved
                     )
@@ -2140,6 +2295,15 @@ Output only final academic prose. Do not report the word count."""
                             en_resolved = en_resolved.rstrip() + "\n\n" + supplemental_resolved.strip()
                         used_after = set(agent.used_citations)
                         survived = used_after - used_before
+            if assigned_tag_list and not is_quarantined:
+                adaptive_minimum = max(1, int(citation_minimums.get(display_name, 1)))
+                if len(survived) < adaptive_minimum:
+                    raise self._literature_insufficient_error(
+                        [(display_name, len(survived), adaptive_minimum)]
+                    )
+                citation_validated_tags_by_unit[display_name] = sorted(
+                    survived, key=agent._citation_tag_number
+                )
             if mode == "asq" and section_id == "findings":
                 en_resolved = self._render_planned_qualitative_quotes(
                     en_resolved,
@@ -2188,6 +2352,10 @@ Output only final academic prose. Do not report the word count."""
                     "context_tail": context_tail,
                     "accumulated_deviation": accumulated_deviation,
                     "quality_diagnostics": quality_diagnostics,
+                    "citation_plan": citation_plan,
+                    "citation_minimums": citation_minimums,
+                    "citation_reserve_targets": citation_reserve_targets,
+                    "citation_validated_tags_by_unit": citation_validated_tags_by_unit,
                     "agent_state": agent.export_state(),
                     "data_metadata": data_metadata,
                 }
@@ -2215,18 +2383,33 @@ Output only final academic prose. Do not report the word count."""
                 if ref and ref not in seen_refs:
                     references.append(f"- {ref}")
                     seen_refs.add(ref)
-            if len(references) < MIN_FINAL_REFERENCES:
-                raise RuntimeError(
-                    "Insufficient final cited references after semantic validation: "
-                    f"{len(references)}/{MIN_FINAL_REFERENCES}."
-                )
+            if not references:
+                raise self._literature_insufficient_error([("final validated references", 0, 1)])
+            final_shortfalls = []
+            for name, minimum in citation_minimums.items():
+                validated_tags = set(citation_validated_tags_by_unit.get(name) or [])
+                if not validated_tags:
+                    validated_tags = {
+                        str(item.get("tag") or "")
+                        for item in (citation_plan.get(name) or [])
+                        if str(item.get("tag") or "") in agent.used_citations
+                    }
+                if len(validated_tags) < int(minimum):
+                    final_shortfalls.append((name, len(validated_tags), int(minimum)))
+            if final_shortfalls:
+                raise self._literature_insufficient_error(final_shortfalls)
+            final_reference_count = len(references)
+            logging.info(
+                "Adaptive citation final Gate passed: validated_references=%s units=%s",
+                final_reference_count, len(citation_minimums),
+            )
             full_draft_en = full_draft_en.rstrip() + "\n\n# References\n" + "\n\n".join(references)
             actual_words = self._english_count_for_target(full_draft_en)
             self._upsert_quality_diagnostic(
                 quality_diagnostics, self._validate_target_length(full_draft_en, target_words)
             )
             body_only, _reference_tail = agent.validate_reference_tail(
-                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+                full_draft_en, minimum_references=max(1, final_reference_count)
             )
             agent.validate_manuscript_structure(body_only, adaptive_structure, translated=False)
             agent.enforce_resolved_claim_specific_citations(body_only)
@@ -2245,7 +2428,7 @@ Output only final academic prose. Do not report the word count."""
             full_draft_en = replace_abstract(full_draft_en, final_abstract)
             full_draft_en = self._replace_keywords(full_draft_en, final_keywords)
             body_only, _reference_tail = agent.validate_reference_tail(
-                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+                full_draft_en, minimum_references=max(1, final_reference_count)
             )
             agent.validate_manuscript_structure(body_only, adaptive_structure, translated=False)
             agent.enforce_resolved_claim_specific_citations(body_only)
@@ -2282,6 +2465,11 @@ Output only final academic prose. Do not report the word count."""
                     "final_abstract": final_abstract,
                     "final_keywords": final_keywords,
                     "front_matter_phase": "final",
+                    "final_reference_count": final_reference_count,
+                    "citation_plan": citation_plan,
+                    "citation_minimums": citation_minimums,
+                    "citation_reserve_targets": citation_reserve_targets,
+                    "citation_validated_tags_by_unit": citation_validated_tags_by_unit,
                     "quality_diagnostics": quality_diagnostics,
                     "english_finalized": True,
                     "translation_complete": False,
@@ -2305,7 +2493,7 @@ Output only final academic prose. Do not report the word count."""
             )
             self._shutdown_translation_worker(wait=True)
             body_only, reference_tail = agent.validate_reference_tail(
-                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+                full_draft_en, minimum_references=max(1, int(state.get("final_reference_count") or 1))
             )
             section_order = self._unique_top_level_sections(adaptive_structure)
             if not section_order:

core/pipeline_agent.py

@@ -62,7 +62,7 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v5'
+    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v6'
 
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
@@ -2698,9 +2698,9 @@ INPUT:
 
         At most one query is issued to each literature backend. New references
         are admitted only when title/abstract evidence has distinctive lexical
-        overlap with the current manuscript unit; otherwise the final >=50 gate
-        is allowed to fail rather than padding the manuscript with irrelevant
-        literature.
+        overlap with the current manuscript unit; otherwise the adaptive
+        evidence-sufficiency Gate is allowed to fail rather than padding the
+        manuscript with irrelevant literature.
         """
         needed = max(0, int(needed or 0))
         if needed <= 0:
@@ -3751,6 +3751,88 @@ Output only the repaired section."""
             'contamination_policy': 'Treat sustained untranslated English prose as a repair signal; normal acronyms, model names and protected terms are allowed.',
         }
 
+    def _translation_batch_damage_score(self, target_lang):
+        """Runtime-only structural damage score used to shrink later translation batches."""
+        language_code = self._translation_language_profile(target_lang).get('language_code') or 'zh'
+        scores = getattr(self, '_translation_batch_damage_scores', None)
+        if not isinstance(scores, dict):
+            scores = {}
+            self._translation_batch_damage_scores = scores
+        return max(0, int(scores.get(language_code) or 0))
+
+    def _record_translation_batch_damage(self, target_lang, reason='structure'):
+        language_code = self._translation_language_profile(target_lang).get('language_code') or 'zh'
+        scores = getattr(self, '_translation_batch_damage_scores', None)
+        if not isinstance(scores, dict):
+            scores = {}
+            self._translation_batch_damage_scores = scores
+        scores[language_code] = min(6, max(0, int(scores.get(language_code) or 0)) + 1)
+        logging.warning(
+            'Translation adaptive batch damage | language=%s score=%s reason=%s',
+            language_code, scores[language_code], str(reason or 'structure')[:80],
+        )
+        return scores[language_code]
+
+    def _relax_translation_batch_damage(self, target_lang):
+        language_code = self._translation_language_profile(target_lang).get('language_code') or 'zh'
+        scores = getattr(self, '_translation_batch_damage_scores', None)
+        if not isinstance(scores, dict):
+            return 0
+        scores[language_code] = max(0, int(scores.get(language_code) or 0) - 1)
+        return scores[language_code]
+
+    def _translation_batch_block_cost(self, source, target_lang):
+        """Estimate output/structure pressure without another model call."""
+        text = str(source or '')
+        source_tokens = max(1, self._count_tokens(text))
+        ir = self._compile_translation_ir(text)
+        claim_count = max(1, len(ir.get('claim_ids') or []))
+        anchor_count = len(ir.get('fact_ledger') or {})
+        language_code = self._translation_language_profile(target_lang).get('language_code') or 'zh'
+        # Output pressure differs by target morphology/script, while source tokens
+        # remain the common baseline. These are planning weights, not quality Gates.
+        output_factor = {'zh': 0.90, 'ru': 1.12, 'kk': 1.32}.get(language_code, 1.0)
+        structural_overhead = claim_count * 24 + anchor_count * 18
+        damage_score = self._translation_batch_damage_score(target_lang)
+        damage_multiplier = 1.0 + min(0.90, 0.18 * damage_score)
+        risk_cost = int(max(1, round((source_tokens * output_factor + structural_overhead) * damage_multiplier)))
+        return risk_cost, {
+            'source_tokens': source_tokens,
+            'claim_count': claim_count,
+            'anchor_count': anchor_count,
+            'risk_cost': risk_cost,
+            'damage_score': damage_score,
+        }
+
+    def _take_adaptive_translation_batch(self, pending, target_lang, configured_budget):
+        """Take the next ordered batch using output pressure + structural density."""
+        remaining = list(pending or [])
+        if not remaining:
+            return [], []
+        budget = max(800, min(2200, int(configured_budget or 2000)))
+        batch, total_cost = [], 0
+        aggregate = {'source_tokens': 0, 'claim_count': 0, 'anchor_count': 0}
+        for item in remaining:
+            block_id, source = item
+            cost, metrics = self._translation_batch_block_cost(source, target_lang)
+            if batch and total_cost + cost > budget:
+                break
+            batch.append((block_id, source))
+            total_cost += cost
+            for key in aggregate:
+                aggregate[key] += int(metrics.get(key) or 0)
+            if total_cost >= budget:
+                break
+        if not batch:
+            batch = [remaining[0]]
+        logging.info(
+            'Translation adaptive batch | language=%s blocks=%s source_tokens=%s claims=%s anchors=%s risk=%s budget=%s damage=%s',
+            self._translation_language_profile(target_lang).get('language_code'), len(batch),
+            aggregate['source_tokens'], aggregate['claim_count'], aggregate['anchor_count'],
+            total_cost, budget, self._translation_batch_damage_score(target_lang),
+        )
+        return batch, remaining[len(batch):]
+
     @staticmethod
     def _translation_lexical_retention_contract(target_lang):
         """Single prompt-side authority for legal Latin retention in ZH/RU/KK.
@@ -5519,6 +5601,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             if not str(error).startswith('Translation marker mismatch:'):
                 raise
             if len(batch) > 1:
+                self._record_translation_batch_damage(target_lang, 'paragraph_marker_mismatch')
                 found_ids = set(re.findall(r'(?m)^\[\[SP-P(\d{6})\]\]\s*$', str(result or '')))
                 if not found_ids:
                     logging.warning(
@@ -5601,6 +5684,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                         )
                         restored[block_id] = translated_with_claims
                         continue
+                self._record_translation_batch_damage(target_lang, 'protected_or_claim_integrity')
                 logging.warning(
                     'Translation protected block recovery: block=SP-P%s error=%s; strict isolated retry.',
                     block_id, self._safe_source_error(error),
@@ -5961,10 +6045,21 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                             'contamination_evidence_codes': kk_typed[:2],
                         })
                         continue
+                    repair_evidence = dict(
+                        getattr(self, '_translation_claim_qa_evidence', {}).get((block_id, claim_id), {}) or {}
+                    )
+                    grammar_evidence_codes = []
+                    if code == 'GRAMMAR':
+                        grammar_evidence_codes = [
+                            str(item or '').strip().upper()
+                            for item in (repair_evidence.get('grammar_evidence_codes') or [])
+                            if str(item or '').strip()
+                        ] or ['GRAMMAR_UNSPECIFIED']
                     rows.append({
                         'id': f'SP-P{block_id}-{claim_id}', 'block_id': block_id,
                         'claim_id': claim_id, 'code': code, 'english': source_claims[claim_id],
                         'target': target_claims[claim_id], 'deterministic_confirmed': False,
+                        'grammar_evidence_codes': grammar_evidence_codes[:4],
                     })
 
         confirmed = {}
@@ -5987,7 +6082,10 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
         allowed_evidence = {
             'CLAIM_MISSING','CLAIM_ADDED','POLARITY_CHANGED','CAUSALITY_CHANGED',
             'UNCERTAINTY_CHANGED','MEANING_CHANGED','CITATION_MOVED','ACRONYM_MISATTACHED',
-            'GRAMMATICAL_VIOLATION','GLOSSARY_CONCEPT_MISMATCH','UNTRANSLATED_PROSE','UNTRANSLATED_LEXEME',
+            'GRAMMATICAL_VIOLATION','CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM',
+            'SYNTAX_STRUCTURE','PUNCTUATION','SYNTACTIC_COMPLETENESS','GRAMMAR_UNSPECIFIED',
+            'WORD_ORDER_UNGRAMMATICAL','WORD_ORDER_SEMANTIC_SCOPE_CHANGED',
+            'GLOSSARY_CONCEPT_MISMATCH','UNTRANSLATED_PROSE','UNTRANSLATED_LEXEME',
             'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION',
             'ACCEPTABLE_VARIANT','MORPHOLOGICAL_VARIANT','STYLISTIC_PREFERENCE',
             'QA_DISAGREEMENT','NO_BLOCKING_EVIDENCE',
@@ -6007,6 +6105,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                     'tokens': list((row.get('lexical_evidence') or {}).get('tokens') or [])[:8],
                 },
                 'contamination_evidence_codes': list(row.get('contamination_evidence_codes') or [])[:2],
+                'grammar_evidence_codes': list(row.get('grammar_evidence_codes') or [])[:4],
             } for row in model_rows],
         }
         lexical_contract = self._translation_lexical_retention_contract(target_lang)
@@ -6015,7 +6114,8 @@ This is verification-only: do not rewrite, suggest wording, or emit free-form ex
 {lexical_contract}
 For Russian, allow required case/number/gender inflection and retain sustained non-Russian prose as an additional contamination signal. For Kazakh, allow productive case, possessive, person/plural and vowel-harmony suffixes on the correct term stem, but treat clearly Russian lexical/syntactic substitution as blocking only when the pair itself supports that conclusion. For Chinese, allow natural reordering and sentence reshaping inside the same claim while preserving meaning.
 For LANGUAGE_CONTAMINATION, deterministic_lexical is authoritative for ordinary English/Latin residue: when confirmed=false and token_count=0, you MUST NOT confirm UNTRANSLATED_LEXEME or UNTRANSLATED_PROSE. For Kazakh, a non-Latin contamination blocker may be confirmed only when contamination_evidence_codes contains KK_RUSSIAN_LEXICAL_INTRUSION or KK_RUSSIAN_SYNTACTIC_INTRUSION, and the evidence_code must match one of those supplied typed codes. The per-item glossary lists the frozen target terms that are legal for that source claim.
-Return valid JSON only: {{"items":[{{"id":"SP-P000001-C000001","issue_code":"GRAMMAR","decision":"CONFIRMED_BLOCKING","evidence_code":"GRAMMATICAL_VIOLATION"}}]}}.
+For GRAMMAR, grammar_evidence_codes is the typed defect history and must remain continuous into this final decision. Never use generic GRAMMATICAL_VIOLATION as final blocking evidence when a typed grammar history exists. If WORD_ORDER is supplied, non-canonical or stylistically different ordering is NOT blocking. Confirm only when the target itself is ungrammatical because of ordering (WORD_ORDER_UNGRAMMATICAL) or when ordering changes modifier/negation/modality/condition/relation scope relative to the English claim (WORD_ORDER_SEMANTIC_SCOPE_CHANGED). For CASE_GOVERNMENT, AGREEMENT, MORPHOLOGY, VERB_FORM, SYNTAX_STRUCTURE, PUNCTUATION, or SYNTACTIC_COMPLETENESS, a blocking evidence_code must match the supplied typed class. If only GRAMMAR_UNSPECIFIED was supplied, you may narrow it to one of those specific classes or one of the two WORD_ORDER consequence codes; do not confirm a generic grammar label.
+Return valid JSON only: {{"items":[{{"id":"SP-P000001-C000001","issue_code":"GRAMMAR","decision":"CONFIRMED_BLOCKING","evidence_code":"AGREEMENT"}}]}}.
 Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one of: {sorted(allowed_evidence)}. Return every supplied id+issue_code pair exactly once."""
         try:
             response = self.call_deepseek(
@@ -6051,6 +6151,23 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                     if typed and evidence_code not in typed and decision == 'CONFIRMED_BLOCKING':
                         decision = 'NOT_CONFIRMED'
                         evidence_code = 'QA_DISAGREEMENT'
+                if row['code'] == 'GRAMMAR' and decision == 'CONFIRMED_BLOCKING':
+                    typed = {str(code or '').strip().upper() for code in (row.get('grammar_evidence_codes') or []) if str(code or '').strip()}
+                    specific_grammar = {
+                        'CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM',
+                        'SYNTAX_STRUCTURE','PUNCTUATION','SYNTACTIC_COMPLETENESS',
+                    }
+                    if typed == {'GRAMMAR_UNSPECIFIED'} or not typed:
+                        matching = set(specific_grammar) | {
+                            'WORD_ORDER_UNGRAMMATICAL','WORD_ORDER_SEMANTIC_SCOPE_CHANGED'
+                        }
+                    else:
+                        matching = set(typed) & specific_grammar
+                        if 'WORD_ORDER' in typed:
+                            matching.update({'WORD_ORDER_UNGRAMMATICAL','WORD_ORDER_SEMANTIC_SCOPE_CHANGED'})
+                    if evidence_code not in matching:
+                        decision = 'NOT_CONFIRMED'
+                        evidence_code = 'QA_DISAGREEMENT'
                 if decision == 'CONFIRMED_BLOCKING':
                     confirmed.setdefault(row['block_id'], {}).setdefault(row['claim_id'], []).append(row['code'])
                     self._record_translation_assurance(
@@ -6132,25 +6249,15 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
         if not body_units:
             raise DeepSeekRequestError('Frozen English translation unit contains no translatable body.')
         token_budget = max(800, min(2000, int(APP_CONFIG.get('translation_batch_tokens', 2500))))
-        batches, current, current_tokens = [], [], 0
-        for index, unit in enumerate(body_units, start=1):
-            block_id = f'{index:06d}'
-            tokens = max(1, self._count_tokens(unit['text']))
-            if current and current_tokens + tokens > token_budget:
-                batches.append(current); current = []; current_tokens = 0
-            current.append((block_id, unit['text'])); current_tokens += tokens
-        if current:
-            batches.append(current)
+        pending_blocks = [
+            (f'{index:06d}', unit['text']) for index, unit in enumerate(body_units, start=1)
+        ]
         system_prompt = (
             self._translation_prompt(target_lang)
             + '\nUse this frozen terminology glossary consistently. Never remap an existing term:\n'
             + json.dumps(frozen_glossary, ensure_ascii=False)
         )
-        source_blocks = {
-            block_id: source
-            for batch in batches
-            for block_id, source in batch
-        }
+        source_blocks = {block_id: source for block_id, source in pending_blocks}
         attempts = max(1, int(max_attempts or 1))
         last_error = None
         self._last_translation_claim_states = {}
@@ -6205,8 +6312,15 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                         sum(len(v or {}) for v in quality_issues.values()),
                     )
                 else:
-                    for batch in batches:
+                    pending = list(pending_blocks)
+                    while pending:
+                        batch, pending = self._take_adaptive_translation_batch(
+                            pending, target_lang, token_budget
+                        )
+                        damage_before = self._translation_batch_damage_score(target_lang)
                         translations.update(self._translate_marked_batch_with_recovery(batch, system_prompt, target_lang))
+                        if self._translation_batch_damage_score(target_lang) == damage_before and damage_before > 0:
+                            self._relax_translation_batch_damage(target_lang)
                     emit_stage('qa')
                     quality_issues = self._audit_translation_blocks_with_retry(
                         source_blocks, translations, target_lang, frozen_glossary,
@@ -6528,29 +6642,20 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
         self._active_translation_glossary = dict(glossary)
         body_units = [unit for unit in units if unit['kind'] == 'body']
         translations = {}
-        token_budget = max(800, int(APP_CONFIG.get('translation_batch_tokens', 2500)))
-        batches = []
-        current = []
-        current_tokens = 0
-        for index, unit in enumerate(body_units, start=1):
-            block_id = f'{index:06d}'
-            tokens = max(1, self._count_tokens(unit['text']))
-            if current and current_tokens + tokens > token_budget:
-                batches.append(current)
-                current = []
-                current_tokens = 0
-            current.append((block_id, unit['text']))
-            current_tokens += tokens
-        if current:
-            batches.append(current)
+        token_budget = max(800, min(2200, int(APP_CONFIG.get('translation_batch_tokens', 2500))))
+        pending = [(f'{index:06d}', unit['text']) for index, unit in enumerate(body_units, start=1)]
 
         system_prompt = self._translation_prompt(target_lang) + '\nUse this terminology glossary consistently:\n' + json.dumps(glossary, ensure_ascii=False)
-        for batch in batches:
+        while pending:
             self._check_cancelled()
+            batch, pending = self._take_adaptive_translation_batch(pending, target_lang, token_budget)
+            damage_before = self._translation_batch_damage_score(target_lang)
             parsed = self._translate_marked_batch_with_recovery(
                 batch, system_prompt, target_lang
             )
             translations.update(parsed)
+            if self._translation_batch_damage_score(target_lang) == damage_before and damage_before > 0:
+                self._relax_translation_batch_damage(target_lang)
 
         output_units = []
         body_index = 0