R14-TQ1-R1 evidence-carrying lexical-purity claim repair

core/pipeline_agent.py

@@ -5453,17 +5453,36 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 restored[block_id] = recovered[block_id]
         return restored
 
-    def _translate_single_claim_with_recovery(self, block_id, claim_id, source_claim, system_prompt, target_lang, issue_codes):
-        """Regenerate one failed claim using bounded QA codes only."""
+    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,
+    ):
+        """Regenerate one failed claim using bounded QA codes plus detector evidence."""
         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 {})
+        lexical_tokens = [
+            str(token or '').strip() for token in (supplied_evidence.get('detected_unprotected_english_tokens') or [])
+            if str(token or '').strip()
+        ]
+        if lexical_tokens:
+            evidence_payload['detected_unprotected_english_tokens'] = lexical_tokens[:8]
         effective_prompt = system_prompt + (
             '\nCLAIM QUALITY RETRY. Repair only this one claim. The only permitted repair signals are the following bounded issue codes: '
             + json.dumps(codes[:5], ensure_ascii=False)
-            + '. Do not infer any examples or numbered instructions from those codes. 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.'
+            + '. 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. '
+              '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)
+            + '\n</CLAIM_REPAIR_EVIDENCE>'
             + '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
             + json.dumps({block_id: safe_manifest}, ensure_ascii=False)
             + '\n</SEMANTIC_ANCHOR_MANIFEST>'
@@ -5785,9 +5804,41 @@ 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)
-                        segments[claim_id] = self._translate_single_claim_with_recovery(
-                            block_id, claim_id, source_claims[claim_id], system_prompt, target_lang, codes
+                        current_target_claim = segments[claim_id]
+                        repair_evidence = {}
+                        if 'LANGUAGE_CONTAMINATION' in {str(code or '').strip().upper() for code in (codes or [])}:
+                            lexical = self._translation_lexical_purity_evidence(
+                                source_claims[claim_id], current_target_claim, target_lang, frozen_glossary
+                            )
+                            if lexical.get('confirmed'):
+                                repair_evidence['detected_unprotected_english_tokens'] = list(lexical.get('tokens') or [])[:8]
+                                self._record_translation_assurance(
+                                    'LEXICAL_PURITY_REPAIR_EVIDENCE', target_lang=target_lang,
+                                    block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='REPAIR_LOCAL',
+                                    detail={
+                                        'token_count': int(lexical.get('token_count') or 0),
+                                        'sample': ','.join(lexical.get('tokens') or [])[:120],
+                                    },
+                                )
+                        repaired_claim = self._translate_single_claim_with_recovery(
+                            block_id, claim_id, source_claims[claim_id], system_prompt, target_lang, codes,
+                            current_target_claim=current_target_claim, repair_evidence=repair_evidence,
                         )
+                        if 'LANGUAGE_CONTAMINATION' in {str(code or '').strip().upper() for code in (codes or [])}:
+                            post_repair_lexical = self._translation_lexical_purity_evidence(
+                                source_claims[claim_id], repaired_claim, target_lang, frozen_glossary
+                            )
+                            self._record_translation_assurance(
+                                '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',
+                                detail={
+                                    'token_count': int(post_repair_lexical.get('token_count') or 0),
+                                    'sample': ','.join(post_repair_lexical.get('tokens') or [])[:120],
+                                },
+                            )
+                        segments[claim_id] = repaired_claim
                         translations[block_id] = self._compose_translation_claim_segments(claim_order, segments)
                         touched_blocks.add(block_id)
                     emit_stage('qa')