R14-TQ1-KK-A2: typed contamination authority and glossary-aware fact ownership

core/pipeline_agent.py

@@ -4631,16 +4631,44 @@ Output only the repaired section."""
         return ' '.join(parts).strip()
 
     @classmethod
-    def _translation_unowned_objects(cls, protected_target):
-        """Find non-anchor factual surfaces; numeric candidates are adjudicated per claim."""
+    def _translation_glossary_authorized_acronyms(cls, source_claim, glossary=None):
+        """Return claim-local target acronyms authorized by a frozen glossary."""
+        source_value = str(source_claim or '')
+        allowed = Counter()
+        for source_term, target_term in dict(glossary or {}).items():
+            source_key = str(source_term or '').strip()
+            target_value = str(target_term or '').strip()
+            if not source_key or not target_value:
+                continue
+            occurrences = len(re.findall(
+                rf'(?<![A-Za-z0-9_]){re.escape(source_key)}(?![A-Za-z0-9_])',
+                source_value, flags=re.I,
+            ))
+            if occurrences <= 0:
+                continue
+            for acronym, count in cls._translation_acronym_tokens(target_value).items():
+                allowed[acronym] += int(count) * int(occurrences)
+        return allowed
+
+    @classmethod
+    def _translation_unowned_objects(cls, protected_target, source_claim='', glossary=None):
+        """Find non-anchor factual surfaces with claim-local glossary authorization."""
         text = re.sub(r'\[\[SP-T\d{6}\]\]', ' ', str(protected_target or ''))
         text = re.sub(r'\[\[SP-P\d{6}\]\]', ' ', text)
         text = re.sub(r'\[\[SP-C\d{6}\]\]', ' ', text)
+        acronym_tokens = cls._translation_acronym_tokens(text)
+        authorized_acronyms = cls._translation_glossary_authorized_acronyms(source_claim, glossary)
+        for acronym, count in authorized_acronyms.items():
+            if acronym_tokens.get(acronym, 0) <= 0:
+                continue
+            acronym_tokens[acronym] -= min(int(count), int(acronym_tokens[acronym]))
+            if acronym_tokens[acronym] <= 0:
+                del acronym_tokens[acronym]
         unowned = {
             'numeric': list(cls._numeric_tokens(text).elements()),
             'citation': list(cls._translation_citation_tokens(text).elements()),
             'hypothesis': list(cls._translation_hypothesis_tokens(text).elements()),
-            'acronym': list(cls._translation_acronym_tokens(text).elements()),
+            'acronym': list(acronym_tokens.elements()),
         }
         names = re.findall(r'\b(?:fsQCA|SmartPLS|Mplus|OpenAlex|DeepSeek|ChatGPT|RStudio|SPSS|AMOS|Stata)\b', text)
         if names:
@@ -4700,7 +4728,7 @@ Output only the repaired section."""
         )
 
     @classmethod
-    def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None):
+    def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None, glossary=None):
         text = str(value or '')
         found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
         expected = Counter((mapping or {}).keys())
@@ -4746,7 +4774,9 @@ Output only the repaired section."""
                         f'Translation order-sensitive relation changed within owner claim in {block_id}: claim={claim_id}.'
                     )
 
-            unowned = cls._translation_unowned_objects(target_claim)
+            unowned = cls._translation_unowned_objects(
+                target_claim, source_claim=source_claim, glossary=glossary
+            )
             numeric = list(unowned.pop('numeric', []))
             if unowned:
                 safe_summary = {key: len(values) for key, values in unowned.items()}
@@ -4775,9 +4805,14 @@ Output only the repaired section."""
         return True
 
     @classmethod
-    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang='', claim_sources=None, keep_claim_markers=False):
+    def _restore_translation_tokens(
+        cls, value, mapping, block_id='', target_lang='', claim_sources=None,
+        keep_claim_markers=False, glossary=None,
+    ):
         text = str(value or '')
-        cls._validate_translation_skeleton(text, mapping, block_id, claim_sources=claim_sources)
+        cls._validate_translation_skeleton(
+            text, mapping, block_id, claim_sources=claim_sources, glossary=glossary
+        )
         for placeholder, manifest in (mapping or {}).items():
             text = text.replace(placeholder, cls._render_translation_fact(manifest, target_lang))
         if re.search(r'\[\[SP-T\d{6}\]\]', text):
@@ -5047,6 +5082,10 @@ SECTION: {section_name}
             'CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM','WORD_ORDER',
             'SYNTAX_STRUCTURE','PUNCTUATION','SYNTACTIC_COMPLETENESS','GRAMMAR_UNSPECIFIED',
         }
+        allowed_contamination_evidence = {
+            'UNTRANSLATED_LEXEME','UNTRANSLATED_PROSE',
+            'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION',
+        }
         if not isinstance(getattr(self, '_translation_claim_qa_evidence', None), dict):
             self._translation_claim_qa_evidence = {}
         claim_rows = []
@@ -5089,7 +5128,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']} {lexical_contract} {profile['contamination_policy']}
 For Russian, do not flag a terminology error merely because a translated term is inflected for grammatical case/number/gender; sustained non-Russian prose remains an additional contamination signal. For Kazakh, do not flag a terminology error merely because productive suffixes attach to the correct term stem; clearly Russian lexical/syntactic intrusion remains an additional language-specific signal when the pair supports that conclusion. 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)}. 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."""
+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)}. For LANGUAGE_CONTAMINATION, evidence_codes MUST identify the supported subtype using only: {sorted(allowed_contamination_evidence)}. Use UNTRANSLATED_LEXEME/UNTRANSLATED_PROSE only for Latin/English residue. For Kazakh, use KK_RUSSIAN_LEXICAL_INTRUSION or KK_RUSSIAN_SYNTACTIC_INTRUSION only when the English/target pair itself clearly supports Russian substitution or a Russian syntactic calque; Cyrillic script or absence of Kazakh-specific letters is never sufficient. 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))),
@@ -5116,6 +5155,9 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                 ]
                 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]
+                contamination_evidence_codes = [
+                    code for code in raw_evidence_codes if code in allowed_contamination_evidence
+                ]
                 semantic_code_set = {
                     'SEMANTIC_DRIFT','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
                     'UNCERTAINTY_DRIFT','OMITTED_CLAIM','ADDED_CLAIM',
@@ -5145,6 +5187,11 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                         (meta['block_id'], meta['claim_id']), {}
                     )
                     evidence_row['grammar_evidence_codes'] = grammar_evidence_codes[:4]
+                if 'LANGUAGE_CONTAMINATION' in codes and contamination_evidence_codes:
+                    evidence_row = self._translation_claim_qa_evidence.setdefault(
+                        (meta['block_id'], meta['claim_id']), {}
+                    )
+                    evidence_row['contamination_evidence_codes'] = contamination_evidence_codes[:4]
                 model_contamination = 'LANGUAGE_CONTAMINATION' in codes
                 lexical = self._translation_lexical_purity_evidence(
                     meta['english'], meta['target'], target_lang, relevant_glossary
@@ -5185,15 +5232,41 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                             'RU_LANGUAGE_CONTAMINATION_UNCONFIRMED', target_lang=target_lang, block_id=row_id,
                             severity='diagnostic', decision='PASS_WITH_WARNING', detail=contamination,
                         )
+                elif language_code == 'zh' and model_contamination and not deterministic_contamination:
+                    codes = [code for code in codes if code != 'LANGUAGE_CONTAMINATION']
+                    self._record_translation_assurance(
+                        'ZH_LANGUAGE_CONTAMINATION_UNCONFIRMED', target_lang=target_lang, block_id=row_id,
+                        severity='diagnostic', decision='PASS_WITH_WARNING',
+                        detail={'deterministic_token_count': int(lexical.get('token_count') or 0)},
+                    )
+                elif language_code == 'kk' and model_contamination and not deterministic_contamination:
+                    russian_intrusion = [
+                        code for code in contamination_evidence_codes
+                        if code in {'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION'}
+                    ]
+                    if russian_intrusion:
+                        evidence_row = self._translation_claim_qa_evidence.setdefault(
+                            (meta['block_id'], meta['claim_id']), {}
+                        )
+                        evidence_row['contamination_evidence_codes'] = russian_intrusion[:2]
+                    else:
+                        codes = [code for code in codes if code != 'LANGUAGE_CONTAMINATION']
+                        self._record_translation_assurance(
+                            'KK_LANGUAGE_CONTAMINATION_UNCONFIRMED', target_lang=target_lang, block_id=row_id,
+                            severity='diagnostic', decision='PASS_WITH_WARNING',
+                            detail={'deterministic_token_count': int(lexical.get('token_count') or 0)},
+                        )
 
                 # Deterministic lexical residue can override an LLM false negative
-                # in ZH/RU/KK. Russian LLM-only contamination remains suppressed
-                # when neither sustained-prose nor lexical evidence confirms it.
+                # in ZH/RU/KK. LLM-only English/Latin contamination is suppressed
+                # when deterministic evidence is absent; Kazakh Russian intrusion
+                # survives only with its dedicated typed evidence.
                 if returned_row.get('ok') is True and not deterministic_contamination and not deterministic_issue:
                     continue
                 if not codes:
                     only_suppressed_contamination = (
-                        language_code == 'ru' and model_contamination and not deterministic_contamination
+                        language_code in {'zh','ru','kk'} and model_contamination and not deterministic_contamination
+                        and 'LANGUAGE_CONTAMINATION' not in codes
                         and bool(raw_codes) and all(code == 'LANGUAGE_CONTAMINATION' for code in raw_codes)
                     )
                     if only_suppressed_contamination:
@@ -5485,6 +5558,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 translated_with_claims = self._restore_translation_tokens(
                     parsed[block_id], protected_maps.get(block_id, {}), f'SP-P{block_id}', target_lang,
                     claim_sources=claim_sources_by_block.get(block_id, {}), keep_claim_markers=True,
+                    glossary=getattr(self, '_active_translation_glossary', {}),
                 )
                 clean_translation = self._strip_translation_claim_markers(translated_with_claims)
                 self._validate_translation_block_protected(block_id, source, clean_translation, target_lang)
@@ -5519,6 +5593,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                         translated_with_claims = self._restore_translation_tokens(
                             repaired, protected_maps.get(block_id, {}), f'SP-P{block_id}', target_lang,
                             claim_sources=source_claims, keep_claim_markers=True,
+                            glossary=getattr(self, '_active_translation_glossary', {}),
                         )
                         clean_translation = self._strip_translation_claim_markers(translated_with_claims)
                         self._validate_translation_block_protected(
@@ -5544,6 +5619,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             '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()}),
+            'contamination_evidence_codes': sorted({str(code or '').strip().upper() for code in (evidence.get('contamination_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=(',', ':'))
@@ -5626,6 +5702,12 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
         ]
         if grammar_evidence_codes:
             evidence_payload['grammar_evidence_codes'] = grammar_evidence_codes[:4]
+        contamination_evidence_codes = [
+            str(code or '').strip().upper() for code in (supplied_evidence.get('contamination_evidence_codes') or [])
+            if str(code or '').strip()
+        ]
+        if contamination_evidence_codes:
+            evidence_payload['contamination_evidence_codes'] = contamination_evidence_codes[:4]
         lexical_contract = self._translation_lexical_retention_contract(target_lang)
         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. '
@@ -5640,6 +5722,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
               '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. '
+              'If contamination_evidence_codes identifies KK_RUSSIAN_LEXICAL_INTRUSION or KK_RUSSIAN_SYNTACTIC_INTRUSION, remove only the evidenced Russian substitution/calque while preserving the frozen English meaning; do not invent an English lexical defect when deterministic English-token evidence is absent. '
               '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)
@@ -5658,6 +5741,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
             restored = self._restore_translation_tokens(
                 parsed[block_id], mapping, f'SP-P{block_id}', target_lang,
                 claim_sources={claim_id: source_claim}, keep_claim_markers=True,
+                glossary=getattr(self, '_active_translation_glossary', {}),
             )
         except DeepSeekRequestError as error:
             if str(error or '').startswith('Translation protected placeholder mismatch'):
@@ -5682,6 +5766,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                 restored = self._restore_translation_tokens(
                     strict_parsed[block_id], mapping, f'SP-P{block_id}', target_lang,
                     claim_sources={claim_id: source_claim}, keep_claim_markers=True,
+                    glossary=getattr(self, '_active_translation_glossary', {}),
                 )
             elif self._is_translation_unowned_numeric_error(error):
                 logging.warning(
@@ -5706,6 +5791,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                 restored = self._restore_translation_tokens(
                     retry_parsed[block_id], mapping, f'SP-P{block_id}', target_lang,
                     claim_sources={claim_id: source_claim}, keep_claim_markers=True,
+                    glossary=getattr(self, '_active_translation_glossary', {}),
                 )
             else:
                 raise
@@ -5820,15 +5906,20 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                     # supported target languages. Russian sustained Latin prose
                     # retains its existing independent deterministic authority.
                     if code == 'LANGUAGE_CONTAMINATION':
+                        relevant_glossary = {
+                            str(source_term): str(target_term)
+                            for source_term, target_term in dict(glossary or {}).items()
+                            if source_term and str(source_term).casefold() in source_claims[claim_id].casefold()
+                        }
                         lexical = self._translation_lexical_purity_evidence(
-                            source_claims[claim_id], target_claims[claim_id], target_lang, glossary
+                            source_claims[claim_id], target_claims[claim_id], target_lang, relevant_glossary
                         )
                         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
+                                source_claims[claim_id], target_claims[claim_id], relevant_glossary
                             )
                             deterministic = bool(evidence.get('confirmed'))
                             if deterministic:
@@ -5839,8 +5930,37 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                                 '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,
+                                'lexical_evidence': lexical, 'glossary': relevant_glossary,
                             })
                             continue
+                        repair_evidence = dict(
+                            getattr(self, '_translation_claim_qa_evidence', {}).get((block_id, claim_id), {}) or {}
+                        )
+                        typed = [
+                            str(item or '').strip().upper()
+                            for item in (repair_evidence.get('contamination_evidence_codes') or [])
+                            if str(item or '').strip()
+                        ]
+                        kk_typed = [
+                            item for item in typed
+                            if item in {'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION'}
+                        ]
+                        if profile.get('language_code') in {'zh','kk'} and not kk_typed:
+                            self._record_translation_assurance(
+                                f"{profile.get('language_code','').upper()}_QA_ADJUDICATION_LEXICAL_UNCONFIRMED",
+                                target_lang=target_lang, block_id=f'SP-P{block_id}-{claim_id}',
+                                severity='diagnostic', decision='PASS_WITH_WARNING',
+                                detail={'deterministic_token_count': int(lexical.get('token_count') or 0)},
+                            )
+                            continue
+                        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,
+                            'lexical_evidence': lexical, 'glossary': relevant_glossary,
+                            'contamination_evidence_codes': kk_typed[:2],
+                        })
+                        continue
                     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],
@@ -5868,6 +5988,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
             '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',
+            'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION',
             'ACCEPTABLE_VARIANT','MORPHOLOGICAL_VARIANT','STYLISTIC_PREFERENCE',
             'QA_DISAGREEMENT','NO_BLOCKING_EVIDENCE',
         }
@@ -5877,16 +5998,23 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
             'language_adapter': profile.get('adapter_id'),
             'morphology': profile.get('morphology'),
             'term_policy': profile.get('term_policy'),
-            'items': [
-                {'id': row['id'], 'issue_code': row['code'], 'english': row['english'], 'target': row['target']}
-                for row in model_rows
-            ],
+            'items': [{
+                'id': row['id'], 'issue_code': row['code'], 'english': row['english'], 'target': row['target'],
+                'glossary': dict(row.get('glossary') or {}),
+                'deterministic_lexical': {
+                    'confirmed': bool((row.get('lexical_evidence') or {}).get('confirmed')),
+                    'token_count': int((row.get('lexical_evidence') or {}).get('token_count') or 0),
+                    'tokens': list((row.get('lexical_evidence') or {}).get('tokens') or [])[:8],
+                },
+                'contamination_evidence_codes': list(row.get('contamination_evidence_codes') or [])[:2],
+            } for row in model_rows],
         }
         lexical_contract = self._translation_lexical_retention_contract(target_lang)
         system_prompt = f"""You are an independent bilingual translation QA adjudicator for {target_lang}.
 This is verification-only: do not rewrite, suggest wording, or emit free-form explanations. Each supplied issue already survived two bounded claim-local repair rounds. Confirm a BLOCKING defect only when the English/target pair itself provides clear evidence. Do not treat stylistic preference or a legitimate grammatical/morphological variant as blocking.
 {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"}}]}}.
 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:
@@ -5914,6 +6042,15 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                 evidence_code = str(item.get('evidence_code') or '').strip().upper()
                 if decision not in {'CONFIRMED_BLOCKING', 'NOT_CONFIRMED'} or evidence_code not in allowed_evidence:
                     raise DeepSeekRequestError(f'Translation QA adjudication returned invalid bounded decision for {row["id"]}.')
+                if row['code'] == 'LANGUAGE_CONTAMINATION':
+                    lexical = dict(row.get('lexical_evidence') or {})
+                    typed = set(row.get('contamination_evidence_codes') or [])
+                    if not bool(lexical.get('confirmed')) and evidence_code in {'UNTRANSLATED_LEXEME','UNTRANSLATED_PROSE'}:
+                        decision = 'NOT_CONFIRMED'
+                        evidence_code = 'QA_DISAGREEMENT'
+                    if typed and evidence_code not in typed and decision == 'CONFIRMED_BLOCKING':
+                        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(
@@ -5989,6 +6126,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
         assurance_start = len(self.translation_assurance_log)
         profile = self._translation_language_profile(target_lang)
         frozen_glossary = self.extend_translation_glossary(value, target_lang, glossary)
+        self._active_translation_glossary = dict(frozen_glossary)
         units = self._translation_body_units(value)
         body_units = [unit for unit in units if unit['kind'] == 'body']
         if not body_units:
@@ -6163,6 +6301,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                             )
                             if lexical.get('confirmed'):
                                 repair_evidence['detected_unprotected_english_tokens'] = list(lexical.get('tokens') or [])[:8]
+                                repair_evidence['contamination_evidence_codes'] = ['UNTRANSLATED_LEXEME']
                                 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',
@@ -6171,6 +6310,21 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                         'sample': ','.join(lexical.get('tokens') or [])[:120],
                                     },
                                 )
+                            elif self._translation_language_profile(target_lang).get('language_code') == 'kk':
+                                kk_intrusion = [
+                                    str(code or '').strip().upper()
+                                    for code in (repair_evidence.get('contamination_evidence_codes') or [])
+                                    if str(code or '').strip().upper() in {
+                                        'KK_RUSSIAN_LEXICAL_INTRUSION','KK_RUSSIAN_SYNTACTIC_INTRUSION'
+                                    }
+                                ]
+                                if kk_intrusion:
+                                    repair_evidence['contamination_evidence_codes'] = kk_intrusion[:2]
+                                    self._record_translation_assurance(
+                                        'KK_RUSSIAN_INTRUSION_REPAIR_EVIDENCE', target_lang=target_lang,
+                                        block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='REPAIR_LOCAL',
+                                        detail={'classes': '|'.join(kk_intrusion)[:120]},
+                                    )
                         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, {
@@ -6371,6 +6525,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
             raise DeepSeekRequestError('English manuscript contains no translatable content.')
 
         glossary = self._build_translation_glossary(body, target_lang)
+        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)))