R14-TQ1-R4-R2: typed defect evidence and non-convergent claim recovery

core/generation_runner.py

@@ -1327,7 +1327,7 @@ class GenerationRunner:
                 'translated_text': '',
                 'qa_status': 'repair_pending',
                 'claim_states': dict(getattr(agent, '_last_translation_claim_states', {}) or {}),
-                'claim_state_version': 'translation-claim-state-v1',
+                'claim_state_version': 'translation-claim-state-v2',
                 'error_code': error_code,
                 'attempts': int(existing.get('attempts') or 0) + 1,
                 'deferred_at': datetime.now(timezone.utc).isoformat(),
@@ -1359,7 +1359,7 @@ class GenerationRunner:
             'language_adapter': str(result.get('language_adapter') or ''),
             'diagnostics': list(result.get('diagnostics') or [])[-20:],
             'claim_states': dict(result.get('claim_states') or {}),
-            'claim_state_version': str(result.get('claim_state_version') or 'translation-claim-state-v1'),
+            'claim_state_version': str(result.get('claim_state_version') or 'translation-claim-state-v2'),
             'attempts': int(result.get('attempts') or 1),
             'completed_at': datetime.now(timezone.utc).isoformat(),
         }

core/pipeline_agent.py

@@ -11,6 +11,7 @@ import tiktoken
 import sys
 import logging
 import hashlib
+import inspect
 import concurrent.futures
 from collections import Counter
 from datetime import datetime, timezone
@@ -5021,6 +5022,10 @@ SECTION: {section_name}
             'CONDITION_SCOPE_CHANGED','COMPARISON_DIRECTION_CHANGED','TEMPORAL_SCOPE_CHANGED',
             'CLAIM_MISSING','CLAIM_ADDED','MEANING_CHANGED',
         }
+        allowed_grammar_evidence = {
+            'CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM','WORD_ORDER',
+            'SYNTAX_STRUCTURE','PUNCTUATION','SYNTACTIC_COMPLETENESS','GRAMMAR_UNSPECIFIED',
+        }
         if not isinstance(getattr(self, '_translation_claim_qa_evidence', None), dict):
             self._translation_claim_qa_evidence = {}
         claim_rows = []
@@ -5062,7 +5067,7 @@ Review EACH claim independently. Do not rewrite and do not provide free-form exp
 LANGUAGE ADAPTER: {profile['adapter_id']}; morphology={profile['morphology']}. {profile['term_policy']} {profile['contamination_policy']}
 For Russian, do not flag a terminology error merely because a translated term is inflected for grammatical case/number/gender. Russian LANGUAGE_CONTAMINATION includes sustained unprotected English prose and ordinary untranslated English lexemes; never use it for protected acronyms, AI/LLM/SEM, model or tool names, variable names, citations, canonical glossary terms, or source-matched proper names/titles. For Chinese, ordinary untranslated English lexical words are contamination while protected technical objects remain legal. For Kazakh, do not flag a terminology error merely because productive suffixes attach to the correct term stem. Kazakh LANGUAGE_CONTAMINATION includes ordinary untranslated English lexemes and clearly Russian lexical/syntactic intrusions not justified by shared international terminology; Cyrillic script or absence of Kazakh-specific letters alone is never sufficient evidence.
 Return valid JSON only in this exact form: {{"items":[{{"id":"SP-P000001-C000001","ok":true,"codes":[],"evidence_codes":[]}}]}}.
-If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANTIC_DRIFT, NEGATION_DRIFT, CAUSALITY_STRENGTH_DRIFT, UNCERTAINTY_DRIFT, OMITTED_CLAIM, or ADDED_CLAIM, evidence_codes should identify the affected semantic dimension using only: {sorted(allowed_semantic_evidence)}. Use the narrowest supported evidence; do not invent an error dimension. Never return numbered prose, examples, quotes, or corrective wording. Never return replacement text. Return every supplied id exactly once."""
+If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANTIC_DRIFT, NEGATION_DRIFT, CAUSALITY_STRENGTH_DRIFT, UNCERTAINTY_DRIFT, OMITTED_CLAIM, or ADDED_CLAIM, evidence_codes should identify the affected semantic dimension using only: {sorted(allowed_semantic_evidence)}. For GRAMMAR, evidence_codes should identify the narrow grammatical defect using only: {sorted(allowed_grammar_evidence)}. Use the narrowest supported evidence; use MEANING_CHANGED or GRAMMAR_UNSPECIFIED only when the narrower dimension cannot be identified from the pair. Do not invent an error dimension. Never return numbered prose, examples, quotes, or corrective wording. Never return replacement text. Return every supplied id exactly once."""
             response = self.call_deepseek(
                 system_prompt, json.dumps(payload, ensure_ascii=False),
                 max_tokens=max(1200, min(3600, 650 + 260 * len(rows))),
@@ -5083,10 +5088,12 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                 meta = row_lookup[row_id]
                 raw_codes = [str(code or '').strip().upper() for code in (returned_row.get('codes') or [])]
                 codes = [code for code in raw_codes if code in allowed_codes]
-                evidence_codes = [
+                raw_evidence_codes = [
                     str(code or '').strip().upper() for code in (returned_row.get('evidence_codes') or [])
-                    if str(code or '').strip().upper() in allowed_semantic_evidence
+                    if str(code or '').strip()
                 ]
+                evidence_codes = [code for code in raw_evidence_codes if code in allowed_semantic_evidence]
+                grammar_evidence_codes = [code for code in raw_evidence_codes if code in allowed_grammar_evidence]
                 semantic_code_set = {
                     'SEMANTIC_DRIFT','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
                     'UNCERTAINTY_DRIFT','OMITTED_CLAIM','ADDED_CLAIM',
@@ -5103,9 +5110,19 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                         fallback = derived.get(issue_code)
                         if fallback and fallback not in evidence_codes:
                             evidence_codes.append(fallback)
-                    self._translation_claim_qa_evidence[(meta['block_id'], meta['claim_id'])] = {
-                        'semantic_delta_codes': evidence_codes[:6],
-                    }
+                    if 'SEMANTIC_DRIFT' in codes and not evidence_codes:
+                        evidence_codes.append('MEANING_CHANGED')
+                    evidence_row = self._translation_claim_qa_evidence.setdefault(
+                        (meta['block_id'], meta['claim_id']), {}
+                    )
+                    evidence_row['semantic_delta_codes'] = evidence_codes[:6]
+                if 'GRAMMAR' in codes:
+                    if not grammar_evidence_codes:
+                        grammar_evidence_codes = ['GRAMMAR_UNSPECIFIED']
+                    evidence_row = self._translation_claim_qa_evidence.setdefault(
+                        (meta['block_id'], meta['claim_id']), {}
+                    )
+                    evidence_row['grammar_evidence_codes'] = grammar_evidence_codes[:4]
                 model_contamination = 'LANGUAGE_CONTAMINATION' in codes
                 lexical = self._translation_lexical_purity_evidence(
                     meta['english'], meta['target'], target_lang, relevant_glossary
@@ -5497,20 +5514,78 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 restored[block_id] = recovered[block_id]
         return restored
 
+    @staticmethod
+    def _translation_repair_evidence_signature(issue_codes, repair_evidence=None):
+        """Stable signature for one claim defect so repeated strategies cannot loop across Final Gate."""
+        evidence = dict(repair_evidence or {})
+        bounded = {
+            'issue_codes': sorted({str(code or '').strip().upper() for code in (issue_codes or []) if str(code or '').strip()}),
+            'semantic_delta_codes': sorted({str(code or '').strip().upper() for code in (evidence.get('semantic_delta_codes') or []) if str(code or '').strip()}),
+            'grammar_evidence_codes': sorted({str(code or '').strip().upper() for code in (evidence.get('grammar_evidence_codes') or []) if str(code or '').strip()}),
+            'detected_unprotected_english_tokens': sorted({str(token or '').strip().casefold() for token in (evidence.get('detected_unprotected_english_tokens') or []) if str(token or '').strip()}),
+        }
+        payload = json.dumps(bounded, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
+        return hashlib.sha256(payload.encode('utf-8')).hexdigest()
+
+    def _decompose_translation_semantic_delta(
+        self, source_claim, current_target_claim, target_lang, issue_codes=None, section_name=''
+    ):
+        """Verification-only decomposition of generic MEANING_CHANGED into repairable semantic dimensions."""
+        allowed = {
+            'ACTOR_CHANGED','RELATION_CHANGED','OBJECT_CHANGED','POLARITY_CHANGED',
+            'CAUSALITY_STRENGTH_CHANGED','MODALITY_UNCERTAINTY_CHANGED',
+            'CONDITION_SCOPE_CHANGED','COMPARISON_DIRECTION_CHANGED','TEMPORAL_SCOPE_CHANGED',
+            'CLAIM_MISSING','CLAIM_ADDED','UNRESOLVED_SEMANTIC_DELTA',
+        }
+        payload = {
+            'target_language': target_lang,
+            'section': str(section_name or 'section'),
+            'issue_codes': [str(code or '').strip().upper() for code in (issue_codes or []) if str(code or '').strip()][:5],
+            'english': str(source_claim or '').strip(),
+            'target': str(current_target_claim or '').strip(),
+        }
+        prompt = f"""You are a bilingual semantic-delta classifier for academic translation into {target_lang}.
+Verification only. Do not rewrite, suggest wording, explain, or return replacement text. The pair has already been flagged with a generic semantic problem. Identify ONLY the narrow semantic dimensions that differ between the frozen English source and the current target claim.
+Return valid JSON only: {{"delta_codes":["RELATION_CHANGED"]}}.
+Each code must be one of: {sorted(allowed)}. Return one or more specific dimensions when supported. Return only UNRESOLVED_SEMANTIC_DELTA when the pair supports a meaning difference but the changed dimension cannot be narrowed safely."""
+        try:
+            response = self.call_deepseek(
+                prompt, json.dumps(payload, ensure_ascii=False), max_tokens=900, temp=0.0,
+                model_role='reasoning', thinking=False, allow_fallback=False,
+            )
+            parsed = self._extract_json_from_text(response)
+            raw = parsed.get('delta_codes', []) if isinstance(parsed, dict) else []
+            codes = [str(code or '').strip().upper() for code in raw if str(code or '').strip().upper() in allowed]
+            codes = list(dict.fromkeys(codes))[:6]
+            specific = [code for code in codes if code != 'UNRESOLVED_SEMANTIC_DELTA']
+            if specific:
+                return specific
+        except PipelineCancelledError:
+            raise
+        except Exception as error:
+            self._record_translation_assurance(
+                'SEMANTIC_DECOMPOSITION_UNCERTAIN', target_lang=target_lang,
+                block_id=section_name or 'claim', severity='diagnostic', decision='SOURCE_REGENERATE',
+                detail={'error_type': type(error).__name__},
+            )
+        return ['UNRESOLVED_SEMANTIC_DELTA']
+
     def _translate_single_claim_with_recovery(
         self, block_id, claim_id, source_claim, system_prompt, target_lang, issue_codes,
-        current_target_claim=None, repair_evidence=None,
+        current_target_claim=None, repair_evidence=None, repair_strategy='LOCAL_EDIT',
     ):
-        """Regenerate one failed claim using bounded QA codes plus detector evidence."""
+        """Repair one failed claim with bounded evidence; escalate to source-only regeneration when needed."""
         protected_claim, mapping = self._protect_translation_tokens(source_claim, claim_id=claim_id)
         marked_source = f'[[SP-P{block_id}]]\n[[SP-{claim_id}]]\n{protected_claim}'
         safe_manifest = self._model_safe_translation_manifest(mapping)
         codes = [str(code or '').strip().upper() for code in (issue_codes or []) if str(code or '').strip()]
-        evidence_payload = {
-            'issue_codes': codes[:5],
-            'current_target_claim': str(current_target_claim or '').strip(),
-        }
         supplied_evidence = dict(repair_evidence or {})
+        strategy = str(repair_strategy or 'LOCAL_EDIT').strip().upper()
+        if strategy not in {'LOCAL_EDIT', 'SOURCE_REGENERATE'}:
+            strategy = 'LOCAL_EDIT'
+        evidence_payload = {'issue_codes': codes[:5], 'repair_strategy': strategy}
+        if strategy == 'LOCAL_EDIT':
+            evidence_payload['current_target_claim'] = str(current_target_claim or '').strip()
         lexical_tokens = [
             str(token or '').strip() for token in (supplied_evidence.get('detected_unprotected_english_tokens') or [])
             if str(token or '').strip()
@@ -5523,13 +5598,25 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         ]
         if semantic_delta_codes:
             evidence_payload['semantic_delta_codes'] = semantic_delta_codes[:6]
-        effective_prompt = system_prompt + (
-            '\nCLAIM QUALITY RETRY. Repair only this one claim. The only permitted repair signals are the following bounded issue codes: '
+        grammar_evidence_codes = [
+            str(code or '').strip().upper() for code in (supplied_evidence.get('grammar_evidence_codes') or [])
+            if str(code or '').strip()
+        ]
+        if grammar_evidence_codes:
+            evidence_payload['grammar_evidence_codes'] = grammar_evidence_codes[:4]
+        retry_mode = (
+            '\nCLAIM SOURCE REGENERATION. The previous target wording has failed bounded repair and MUST NOT be used as drafting context. Generate a fresh translation of only this one claim directly from the frozen marked English source. '
+            if strategy == 'SOURCE_REGENERATE' else
+            '\nCLAIM QUALITY RETRY. Repair only this one claim. '
+        )
+        effective_prompt = system_prompt + retry_mode + (
+            'The only permitted repair signals are the following bounded issue codes: '
             + json.dumps(codes[:5], ensure_ascii=False)
             + '. Use the bounded detector evidence below only to repair the supplied claim; do not invent additional defects. '
-              'The current target claim is context, not authority: the frozen English source remains authoritative. '
-              'If detected_unprotected_english_tokens is non-empty, every listed token is deterministic lexical-purity evidence and MUST be translated or removed from ordinary target-language prose; do not preserve it unless it is represented by a protected SP-T anchor. '
-              'If semantic_delta_codes is non-empty, repair ONLY those evidenced semantic dimensions against the frozen English source and preserve all unaffected actor, relation, object, polarity, modality, condition, comparison, temporal scope, and evidentiary strength. Do not freely paraphrase a claim that only needs a bounded semantic correction. '
+              'For LOCAL_EDIT, the current target claim is context, not authority; for SOURCE_REGENERATE it is intentionally absent. The frozen English source is always authoritative. '
+              'If detected_unprotected_english_tokens is non-empty, every listed token is deterministic lexical-purity evidence from a prior target and MUST NOT survive as ordinary untranslated target-language prose unless represented by a protected SP-T anchor. '
+              'If semantic_delta_codes is non-empty, enforce ONLY those evidenced semantic dimensions against the frozen English source and preserve all unaffected actor, relation, object, polarity, modality, condition, comparison, temporal scope, and evidentiary strength. UNRESOLVED_SEMANTIC_DELTA is a signal to regenerate faithfully from source, not an instruction to guess a specific correction. '
+              'If grammar_evidence_codes is non-empty, repair or avoid only those bounded grammatical defect classes; GRAMMAR_UNSPECIFIED requires a fresh natural target-language rendering rather than blind micro-editing. '
               'Preserve every SP-P, SP-C, and SP-T marker byte-for-byte. Do not add claims or factual content. Return only the marked translated claim.'
             + '\n<CLAIM_REPAIR_EVIDENCE>\n'
             + json.dumps(evidence_payload, ensure_ascii=False)
@@ -5605,10 +5692,13 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         return segments[claim_id]
 
     @classmethod
-    def _snapshot_translation_claim_states(cls, source_blocks, translations, pending_issues=None, repair_evidence=None):
-        """Freeze claim-level target text so a deferred section never needs wholesale retranslation."""
+    def _snapshot_translation_claim_states(
+        cls, source_blocks, translations, pending_issues=None, repair_evidence=None, repair_meta=None
+    ):
+        """Freeze claim text plus bounded repair history so Final Gate cannot restart a failed strategy."""
         pending = dict(pending_issues or {})
         evidence_map = dict(repair_evidence or {})
+        meta_map = dict(repair_meta or {})
         states = {}
         for block_id, source_block in dict(source_blocks or {}).items():
             if block_id not in dict(translations or {}):
@@ -5625,6 +5715,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 if not target_text:
                     continue
                 codes = list((pending.get(block_id) or {}).get(claim_id) or [])
+                meta = dict(meta_map.get((block_id, claim_id)) or {})
                 states[f'SP-P{block_id}-{claim_id}'] = {
                     'block_id': str(block_id),
                     'claim_id': str(claim_id),
@@ -5633,6 +5724,11 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                     'qa_status': 'repair_pending' if codes else 'passed',
                     'issue_codes': [str(code or '').strip().upper() for code in codes if str(code or '').strip()][:5],
                     'repair_evidence': dict(evidence_map.get((block_id, claim_id)) or {}),
+                    'repair_attempt_count': int(meta.get('repair_attempt_count') or 0),
+                    'last_issue_codes': [str(code or '').strip().upper() for code in (meta.get('last_issue_codes') or []) if str(code or '').strip()][:5],
+                    'last_evidence_signature': str(meta.get('last_evidence_signature') or ''),
+                    'last_strategy': str(meta.get('last_strategy') or ''),
+                    'nonconvergent_state': str(meta.get('nonconvergent_state') or ''),
                 }
         return states
 
@@ -5704,17 +5800,22 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                         lexical = self._translation_lexical_purity_evidence(
                             source_claims[claim_id], target_claims[claim_id], target_lang, glossary
                         )
-                        deterministic = bool(lexical.get('confirmed'))
+                        lexical_confirmed = bool(lexical.get('confirmed'))
+                        deterministic = lexical_confirmed
+                        deterministic_evidence_code = 'UNTRANSLATED_LEXEME' if lexical_confirmed else ''
                         if profile.get('language_code') == 'ru' and not deterministic:
                             evidence = self._russian_contamination_evidence(
                                 source_claims[claim_id], target_claims[claim_id], glossary
                             )
                             deterministic = bool(evidence.get('confirmed'))
+                            if deterministic:
+                                deterministic_evidence_code = 'UNTRANSLATED_PROSE'
                         if deterministic:
                             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': True,
+                                'deterministic_evidence_code': deterministic_evidence_code,
                             })
                             continue
                     rows.append({
@@ -5731,7 +5832,10 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 self._record_translation_assurance(
                     'QA_ADJUDICATION_CONFIRMED', target_lang=target_lang, block_id=row['id'],
                     severity='critical', decision='HOLD_FINAL',
-                    detail={'issue_code': row['code'], 'evidence_code': 'UNTRANSLATED_PROSE'},
+                    detail={
+                        'issue_code': row['code'],
+                        'evidence_code': str(row.get('deterministic_evidence_code') or 'UNTRANSLATED_PROSE'),
+                    },
                 )
 
         if not model_rows:
@@ -5888,6 +5992,21 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
         last_error = None
         self._last_translation_claim_states = {}
         self._translation_claim_qa_evidence = {}
+        self._translation_claim_repair_meta = {}
+        for row in dict(claim_states or {}).values():
+            if not isinstance(row, dict):
+                continue
+            block_key = str(row.get('block_id') or '')
+            claim_key = str(row.get('claim_id') or '')
+            if not block_key or not claim_key:
+                continue
+            self._translation_claim_repair_meta[(block_key, claim_key)] = {
+                'repair_attempt_count': int(row.get('repair_attempt_count') or 0),
+                'last_issue_codes': [str(code or '').strip().upper() for code in (row.get('last_issue_codes') or []) if str(code or '').strip()][:5],
+                'last_evidence_signature': str(row.get('last_evidence_signature') or ''),
+                'last_strategy': str(row.get('last_strategy') or '').strip().upper(),
+                'nonconvergent_state': str(row.get('nonconvergent_state') or ''),
+            }
 
         def emit_stage(stage):
             if not callable(stage_callback):
@@ -5931,7 +6050,8 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                         section_name=section_name or 'frozen section', max_attempts=2,
                     )
                 self._last_translation_claim_states = self._snapshot_translation_claim_states(
-                    source_blocks, translations, quality_issues, self._translation_claim_qa_evidence
+                    source_blocks, translations, quality_issues, self._translation_claim_qa_evidence,
+                    self._translation_claim_repair_meta,
                 )
                 local_round = 0
                 while quality_issues and local_round < 2:
@@ -5951,6 +6071,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                     )
                     emit_stage('repairing')
                     touched_blocks = set()
+                    carried_exhausted = {}
                     for block_id, claim_id, codes in failed_pairs:
                         source_claims = {
                             item['claim_id']: item['text'] for item in self._translation_claim_units(source_blocks[block_id])
@@ -5962,16 +6083,56 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                         claim_order = list(source_claims)
                         _order, segments = self._parse_translation_claim_segments(translations[block_id], claim_order)
                         current_target_claim = segments[claim_id]
-                        repair_evidence = dict(
-                            self._translation_claim_qa_evidence.get((block_id, claim_id)) or {}
-                        )
+                        evidence_key = (block_id, claim_id)
+                        repair_evidence = dict(self._translation_claim_qa_evidence.get(evidence_key) or {})
+                        code_set = {str(code or '').strip().upper() for code in (codes or [])}
+
+                        semantic_deltas = [
+                            str(code or '').strip().upper() for code in (repair_evidence.get('semantic_delta_codes') or [])
+                            if str(code or '').strip()
+                        ]
+                        semantic_issue = bool(code_set & {
+                            'SEMANTIC_DRIFT','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
+                            'UNCERTAINTY_DRIFT','OMITTED_CLAIM','ADDED_CLAIM',
+                        })
+                        derived_semantic = {
+                            'NEGATION_DRIFT': 'POLARITY_CHANGED',
+                            'CAUSALITY_STRENGTH_DRIFT': 'CAUSALITY_STRENGTH_CHANGED',
+                            'UNCERTAINTY_DRIFT': 'MODALITY_UNCERTAINTY_CHANGED',
+                            'OMITTED_CLAIM': 'CLAIM_MISSING',
+                            'ADDED_CLAIM': 'CLAIM_ADDED',
+                        }
+                        for issue_code in code_set:
+                            fallback = derived_semantic.get(issue_code)
+                            if fallback and fallback not in semantic_deltas:
+                                semantic_deltas.append(fallback)
+                        if semantic_deltas:
+                            repair_evidence['semantic_delta_codes'] = list(dict.fromkeys(semantic_deltas))[:6]
+                        specific_semantic = [code for code in semantic_deltas if code != 'MEANING_CHANGED']
+                        if semantic_issue and (not specific_semantic or 'MEANING_CHANGED' in semantic_deltas):
+                            specific_semantic = self._decompose_translation_semantic_delta(
+                                source_claims[claim_id], current_target_claim, target_lang,
+                                issue_codes=codes, section_name=f'SP-P{block_id}-{claim_id}',
+                            )
+                            repair_evidence['semantic_delta_codes'] = list(specific_semantic)[:6]
                         if repair_evidence.get('semantic_delta_codes'):
                             self._record_translation_assurance(
                                 'SEMANTIC_REPAIR_EVIDENCE', target_lang=target_lang,
                                 block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='REPAIR_LOCAL',
                                 detail={'deltas': '|'.join(repair_evidence.get('semantic_delta_codes') or [])[:180]},
                             )
-                        if 'LANGUAGE_CONTAMINATION' in {str(code or '').strip().upper() for code in (codes or [])}:
+                        if 'GRAMMAR' in code_set:
+                            grammar_codes = [
+                                str(code or '').strip().upper() for code in (repair_evidence.get('grammar_evidence_codes') or [])
+                                if str(code or '').strip()
+                            ] or ['GRAMMAR_UNSPECIFIED']
+                            repair_evidence['grammar_evidence_codes'] = grammar_codes[:4]
+                            self._record_translation_assurance(
+                                'GRAMMAR_REPAIR_EVIDENCE', target_lang=target_lang,
+                                block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='REPAIR_LOCAL',
+                                detail={'classes': '|'.join(grammar_codes)[:180]},
+                            )
+                        if 'LANGUAGE_CONTAMINATION' in code_set:
                             lexical = self._translation_lexical_purity_evidence(
                                 source_claims[claim_id], current_target_claim, target_lang, frozen_glossary
                             )
@@ -5985,11 +6146,70 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                         'sample': ','.join(lexical.get('tokens') or [])[:120],
                                     },
                                 )
-                        repaired_claim = self._translate_single_claim_with_recovery(
+                        self._translation_claim_qa_evidence[evidence_key] = dict(repair_evidence)
+                        signature = self._translation_repair_evidence_signature(codes, repair_evidence)
+                        meta = self._translation_claim_repair_meta.setdefault(evidence_key, {
+                            'repair_attempt_count': 0, 'last_issue_codes': [], 'last_evidence_signature': '',
+                            'last_strategy': '', 'nonconvergent_state': '',
+                        })
+                        prior_codes = set(meta.get('last_issue_codes') or [])
+                        same_defect = (
+                            str(meta.get('last_evidence_signature') or '') == signature
+                            and bool(prior_codes & code_set)
+                        )
+                        if (
+                            str(meta.get('nonconvergent_state') or '').startswith('exhausted')
+                            and bool(prior_codes & code_set)
+                        ) or (same_defect and str(meta.get('last_strategy') or '').upper() == 'SOURCE_REGENERATE'):
+                            meta['nonconvergent_state'] = 'exhausted_after_source_regenerate'
+                            carried_exhausted.setdefault(block_id, {})[claim_id] = list(codes)
+                            self._record_translation_assurance(
+                                'CLAIM_REPAIR_EXHAUSTED', target_lang=target_lang,
+                                block_id=f'SP-P{block_id}-{claim_id}', severity='critical', decision='ADJUDICATE',
+                                detail={'attempts': int(meta.get('repair_attempt_count') or 0), 'strategy': 'SOURCE_REGENERATE'},
+                            )
+                            continue
+
+                        force_source_regenerate = (
+                            'UNRESOLVED_SEMANTIC_DELTA' in set(repair_evidence.get('semantic_delta_codes') or [])
+                            or 'GRAMMAR_UNSPECIFIED' in set(repair_evidence.get('grammar_evidence_codes') or [])
+                        )
+                        strategy = 'SOURCE_REGENERATE' if (
+                            force_source_regenerate
+                            or (same_defect and str(meta.get('last_strategy') or '').upper() == 'LOCAL_EDIT')
+                        ) else 'LOCAL_EDIT'
+                        if strategy == 'SOURCE_REGENERATE':
+                            self._record_translation_assurance(
+                                'CLAIM_REPAIR_ESCALATED', target_lang=target_lang,
+                                block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='SOURCE_REGENERATE',
+                                detail={'reason': 'nonconvergent_or_unresolved_evidence'},
+                            )
+                        self._translation_claim_qa_evidence[evidence_key] = dict(repair_evidence)
+                        repair_method = self._translate_single_claim_with_recovery
+                        repair_kwargs = {
+                            'current_target_claim': current_target_claim,
+                            'repair_evidence': repair_evidence,
+                        }
+                        try:
+                            repair_parameters = list(inspect.signature(repair_method).parameters.values())
+                            supports_strategy = any(
+                                item.name == 'repair_strategy' or item.kind == inspect.Parameter.VAR_KEYWORD
+                                for item in repair_parameters
+                            )
+                        except (TypeError, ValueError):
+                            supports_strategy = False
+                        if supports_strategy:
+                            repair_kwargs['repair_strategy'] = strategy
+                        repaired_claim = repair_method(
                             block_id, claim_id, source_claims[claim_id], system_prompt, target_lang, codes,
-                            current_target_claim=current_target_claim, repair_evidence=repair_evidence,
+                            **repair_kwargs,
                         )
-                        if 'LANGUAGE_CONTAMINATION' in {str(code or '').strip().upper() for code in (codes or [])}:
+                        meta['repair_attempt_count'] = int(meta.get('repair_attempt_count') or 0) + 1
+                        meta['last_issue_codes'] = sorted(code_set)[:5]
+                        meta['last_evidence_signature'] = signature
+                        meta['last_strategy'] = strategy
+                        meta['nonconvergent_state'] = 'source_regenerated' if strategy == 'SOURCE_REGENERATE' else ''
+                        if 'LANGUAGE_CONTAMINATION' in code_set:
                             post_repair_lexical = self._translation_lexical_purity_evidence(
                                 source_claims[claim_id], repaired_claim, target_lang, frozen_glossary
                             )
@@ -5997,7 +6217,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                 'LEXICAL_PURITY_REPAIR_RESIDUAL' if post_repair_lexical.get('confirmed') else 'LEXICAL_PURITY_REPAIR_CLEARED',
                                 target_lang=target_lang, block_id=f'SP-P{block_id}-{claim_id}',
                                 severity='repair' if post_repair_lexical.get('confirmed') else 'diagnostic',
-                                decision='REPAIR_LOCAL' if post_repair_lexical.get('confirmed') else 'PASS_WITH_WARNING',
+                                decision='SOURCE_REGENERATE' if post_repair_lexical.get('confirmed') and strategy == 'SOURCE_REGENERATE' else ('REPAIR_LOCAL' if post_repair_lexical.get('confirmed') else 'PASS_WITH_WARNING'),
                                 detail={
                                     'token_count': int(post_repair_lexical.get('token_count') or 0),
                                     'sample': ','.join(post_repair_lexical.get('tokens') or [])[:120],
@@ -6007,14 +6227,35 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                         translations[block_id] = self._compose_translation_claim_segments(claim_order, segments)
                         touched_blocks.add(block_id)
                     emit_stage('qa')
-                    quality_issues = self._audit_translation_blocks_with_retry(
-                        {block_id: source_blocks[block_id] for block_id in sorted(touched_blocks)},
-                        {block_id: translations[block_id] for block_id in sorted(touched_blocks)},
-                        target_lang, frozen_glossary, section_name=section_name or 'frozen section', max_attempts=2,
-                    )
+                    refreshed = {}
+                    if touched_blocks:
+                        refreshed = self._audit_translation_blocks_with_retry(
+                            {block_id: source_blocks[block_id] for block_id in sorted(touched_blocks)},
+                            {block_id: translations[block_id] for block_id in sorted(touched_blocks)},
+                            target_lang, frozen_glossary, section_name=section_name or 'frozen section', max_attempts=2,
+                        )
+                    for block_id, claim_map in carried_exhausted.items():
+                        for claim_id, codes in claim_map.items():
+                            refreshed.setdefault(block_id, {})[claim_id] = list(codes)
+                    quality_issues = refreshed
                     self._last_translation_claim_states = self._snapshot_translation_claim_states(
-                        source_blocks, translations, quality_issues, self._translation_claim_qa_evidence
+                        source_blocks, translations, quality_issues, self._translation_claim_qa_evidence,
+                        self._translation_claim_repair_meta,
                     )
+                    if not touched_blocks and carried_exhausted:
+                        break
+
+                if quality_issues:
+                    for block_id, claim_map in quality_issues.items():
+                        for claim_id, codes in (claim_map or {}).items():
+                            meta = self._translation_claim_repair_meta.get((block_id, claim_id))
+                            if not isinstance(meta, dict):
+                                continue
+                            if str(meta.get('last_strategy') or '').upper() == 'SOURCE_REGENERATE':
+                                prior = set(meta.get('last_issue_codes') or [])
+                                current = {str(code or '').strip().upper() for code in (codes or [])}
+                                if prior & current:
+                                    meta['nonconvergent_state'] = 'exhausted_after_source_regenerate'
                 if quality_issues:
                     emit_stage('qa')
                     quality_issues = self._adjudicate_persistent_translation_issues(
@@ -6022,7 +6263,8 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                         section_name=section_name or 'frozen section',
                     )
                 self._last_translation_claim_states = self._snapshot_translation_claim_states(
-                    source_blocks, translations, quality_issues, self._translation_claim_qa_evidence
+                    source_blocks, translations, quality_issues, self._translation_claim_qa_evidence,
+                    self._translation_claim_repair_meta,
                 )
                 if quality_issues:
                     detail = '; '.join(
@@ -6061,7 +6303,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                     'language_adapter': profile['adapter_id'],
                     'diagnostics': diagnostics[-20:],
                     'claim_states': dict(self._last_translation_claim_states),
-                    'claim_state_version': 'translation-claim-state-v1',
+                    'claim_state_version': 'translation-claim-state-v2',
                 }
             except PipelineCancelledError:
                 raise