S0-R1-C5.5-R6-R9 Translation Semantic Object Frame

core/generation_runner.py

@@ -45,7 +45,7 @@ CITATION_ROLE_RULES = {
     "methods": (2, 280),
     "discussion": (2, 220),
 }
-TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v8'
+TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v9'
 FINAL_CITATION_LEDGER_VERSION = 'resolved-final-ledger-v1'
 ENGLISH_SECTION_SEAL_VERSION = 'english-section-integrity-seal-v1'
 

core/pipeline_agent.py

@@ -70,7 +70,8 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v8'
+    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v9'
+    TRANSLATION_SEMANTIC_OBJECT_VERSION = 'translation-semantic-object-v1'
     MAX_TRANSLATION_CLAIM_REPAIR_ATTEMPTS = 2
     MAX_TRANSLATION_CLAIM_TOTAL_REPAIRS = 6
     PROTECTED_ENTITY_LEDGER_VERSION = 'protected-entity-ledger-v2'
@@ -6890,6 +6891,116 @@ TEXT:
         frame["frame_hash"] = hashlib.sha256(canonical.encode("utf-8")).hexdigest()
         return frame
 
+    @classmethod
+    def _translation_semantic_object_frame(cls, source_claim, section_name='', glossary=None):
+        """Compile one frozen English claim into a versioned semantic object.
+
+        R6-R9 moves translation QA away from an untyped whole-sentence verdict.
+        The server owns this object before any target-language judgment: claim
+        identity, evidence/causal/modality contract, protected factual object
+        types, and canonical terminology ownership are frozen once and hashed.
+        The model may judge target realization, but it cannot redefine source
+        semantics or invent a new object schema on retry/resume.
+        """
+        source = re.sub(r"\s+", " ", str(source_claim or '')).strip()
+        semantic_frame = cls._source_semantic_claim_frame(source, section_name)
+        _protected, mapping = cls._protect_translation_tokens(source, claim_id='C000001')
+        type_counts = Counter(str(item.get('type') or 'IMMUTABLE') for item in mapping.values())
+        render_counts = Counter(str(item.get('render_policy') or 'exact') for item in mapping.values())
+        glossary_value = dict(glossary or {})
+        canonical_terms = []
+        folded = source.casefold()
+        for source_term, target_term in sorted(glossary_value.items(), key=lambda item: str(item[0]).casefold()):
+            source_term = re.sub(r"\s+", " ", str(source_term or '')).strip()
+            target_term = re.sub(r"\s+", " ", str(target_term or '')).strip()
+            if source_term and source_term.casefold() in folded:
+                canonical_terms.append({
+                    'source': source_term,
+                    'target': target_term,
+                    'identity': hashlib.sha256(source_term.casefold().encode('utf-8')).hexdigest()[:16],
+                })
+        semantic_contract = {
+            key: semantic_frame.get(key)
+            for key in (
+                'polarity','causal_strength','modality','claim_provenance','evidence_owner',
+                'citation_requirement','citation_scope','citation_count'
+            )
+        }
+        obj = {
+            'version': cls.TRANSLATION_SEMANTIC_OBJECT_VERSION,
+            'source_hash': hashlib.sha256(source.encode('utf-8')).hexdigest(),
+            'semantic_contract': semantic_contract,
+            'protected_object_counts': dict(sorted(type_counts.items())),
+            'render_policy_counts': dict(sorted(render_counts.items())),
+        }
+        # Identity is source-owned. Target glossary realization is useful QA
+        # context but must not change the semantic-object hash across languages.
+        canonical = json.dumps(obj, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
+        obj['object_hash'] = hashlib.sha256(canonical.encode('utf-8')).hexdigest()
+        obj['canonical_terms'] = canonical_terms[:16]
+        return obj
+
+    @staticmethod
+    def _translation_semantic_delta_objects(source_claim, target_claim, raw_deltas):
+        """Validate model-reported semantic deltas as source/target-bound objects.
+
+        A generic ``SEMANTIC_DRIFT`` label is not evidence.  R6-R9 requires a
+        narrow semantic dimension plus spans that actually belong to the frozen
+        source and current target (except claim-added/missing, where one side may
+        be empty).  Invalid or over-broad evidence is ignored rather than being
+        promoted to a fatal repair lineage.
+        """
+        allowed = {
+            'ACTOR_CHANGED','RELATION_CHANGED','OBJECT_CHANGED','CONDITION_SCOPE_CHANGED',
+            'COMPARISON_DIRECTION_CHANGED','TEMPORAL_SCOPE_CHANGED','CLAIM_MISSING','CLAIM_ADDED',
+        }
+        source = re.sub(r"\s+", " ", str(source_claim or '')).strip()
+        target = re.sub(r"\s+", " ", str(target_claim or '')).strip()
+        source_folded, target_folded = source.casefold(), target.casefold()
+        objects = []
+        for raw in (raw_deltas or []):
+            if not isinstance(raw, dict):
+                continue
+            dimension = str(raw.get('dimension') or '').strip().upper()
+            if dimension not in allowed:
+                continue
+            source_span = re.sub(r"\s+", " ", str(raw.get('source_span') or '')).strip()
+            target_span = re.sub(r"\s+", " ", str(raw.get('target_span') or '')).strip()
+            if dimension == 'CLAIM_MISSING':
+                if not source_span or source_span.casefold() not in source_folded:
+                    continue
+            elif dimension == 'CLAIM_ADDED':
+                if not target_span or target_span.casefold() not in target_folded:
+                    continue
+            else:
+                if not source_span or not target_span:
+                    continue
+                if source_span.casefold() not in source_folded or target_span.casefold() not in target_folded:
+                    continue
+            # Whole-sentence restatement is not narrow evidence except for very
+            # short claims, where a smaller span may not exist naturally.
+            if len(source) > 180 and source_span and len(source_span) > max(180, int(len(source) * 0.80)):
+                continue
+            if len(target) > 180 and target_span and len(target_span) > max(180, int(len(target) * 0.80)):
+                continue
+            identity_payload = json.dumps(
+                {'dimension': dimension, 'source_span': source_span.casefold(), 'target_span': target_span.casefold()},
+                ensure_ascii=False, sort_keys=True, separators=(',', ':')
+            )
+            objects.append({
+                'dimension': dimension, 'source_span': source_span, 'target_span': target_span,
+                'object_id': hashlib.sha256(identity_payload.encode('utf-8')).hexdigest()[:20],
+            })
+        deduped = []
+        seen = set()
+        for item in objects:
+            key = (item['dimension'], item['object_id'])
+            if key in seen:
+                continue
+            seen.add(key)
+            deduped.append(item)
+        return deduped[:6]
+
     @classmethod
     def _translation_claim_units(cls, value):
         """Create stable source-side claim IDs without constraining target punctuation."""
@@ -8201,7 +8312,7 @@ SECTION: {section_name}
             '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','MEANING_CHANGED',
+            'CLAIM_MISSING','CLAIM_ADDED',
         }
         allowed_grammar_evidence = {
             'CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM','WORD_ORDER',
@@ -8228,6 +8339,7 @@ SECTION: {section_name}
                     'english': item['text'],
                     'target': target_claims[claim_id],
                     'source_semantic_frame': self._source_semantic_claim_frame(item['text'], section_name),
+                    'semantic_object': self._translation_semantic_object_frame(item['text'], section_name, glossary_value),
                 })
 
         issues = {}
@@ -8245,16 +8357,18 @@ SECTION: {section_name}
                 'target_language': target_lang,
                 'glossary': relevant_glossary,
                 'allowed_issue_codes': sorted(allowed_codes),
-                'items': [{'id': row['id'], 'english': row['english'], 'target': row['target'], 'source_semantic_frame': row['source_semantic_frame']} for row in rows],
+                'semantic_object_version': self.TRANSLATION_SEMANTIC_OBJECT_VERSION,
+                'items': [{'id': row['id'], 'english': row['english'], 'target': row['target'], 'source_semantic_frame': row['source_semantic_frame'], 'semantic_object': row['semantic_object']} for row in rows],
             }
             profile = self._translation_language_profile(target_lang)
             lexical_contract = self._translation_lexical_retention_contract(target_lang)
             system_prompt = f"""You are a bilingual academic translation QA classifier for {target_lang}.
-Review EACH claim independently. Do not rewrite and do not provide free-form explanations. The supplied source_semantic_frame is server-frozen source authority: the target must preserve its polarity, causal_strength, modality, claim_provenance, evidence_owner, citation_scope, and citation_count. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
+Review EACH claim independently. Do not rewrite and do not provide free-form explanations. The supplied semantic_object is the server-frozen source authority. Preserve its semantic_contract, protected-object ownership, and canonical terminology identities. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
+For a generic SEMANTIC_DRIFT finding, a label alone is NOT evidence. You MUST also return one or more narrow semantic_deltas. Each delta must use dimension ACTOR_CHANGED, RELATION_CHANGED, OBJECT_CHANGED, CONDITION_SCOPE_CHANGED, COMPARISON_DIRECTION_CHANGED, TEMPORAL_SCOPE_CHANGED, CLAIM_MISSING, or CLAIM_ADDED and quote short exact source_span/target_span evidence from the supplied pair. For CLAIM_MISSING target_span may be empty; for CLAIM_ADDED source_span may be empty. Do not return the whole sentence as a pseudo-span when a narrower phrase identifies the changed object. If you cannot identify a source/target-bound semantic object, do NOT emit SEMANTIC_DRIFT.
 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)}. 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."""
+Return valid JSON only in this exact form: {{"items":[{{"id":"SP-P000001-C000001","ok":true,"codes":[],"evidence_codes":[],"semantic_deltas":[]}}]}}.
+If ok=false, codes MUST contain only values from allowed_issue_codes. For 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)}. SEMANTIC_DRIFT additionally requires validated semantic_deltas as described above; never use a generic MEANING_CHANGED fallback. 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 GRAMMAR_UNSPECIFIED only when a grammatical defect is clear but cannot be narrowed. 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))),
@@ -8288,6 +8402,14 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                     'SEMANTIC_DRIFT','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
                     'UNCERTAINTY_DRIFT','OMITTED_CLAIM','ADDED_CLAIM',
                 }
+                semantic_objects = self._translation_semantic_delta_objects(
+                    meta['english'], meta['target'], returned_row.get('semantic_deltas') or []
+                )
+                if semantic_objects:
+                    object_dimensions = [item['dimension'] for item in semantic_objects]
+                    for dimension in object_dimensions:
+                        if dimension not in evidence_codes:
+                            evidence_codes.append(dimension)
                 if any(code in semantic_code_set for code in codes):
                     derived = {
                         'NEGATION_DRIFT': 'POLARITY_CHANGED',
@@ -8300,12 +8422,22 @@ 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)
-                    if 'SEMANTIC_DRIFT' in codes and not evidence_codes:
-                        evidence_codes.append('MEANING_CHANGED')
+                    # R6-R9: a generic semantic verdict cannot create a repair
+                    # lineage without a source/target-bound semantic object.
+                    if 'SEMANTIC_DRIFT' in codes and not semantic_objects:
+                        codes = [code for code in codes if code != 'SEMANTIC_DRIFT']
+                        self._record_translation_assurance(
+                            'SEMANTIC_OBJECT_UNTYPED_QA_UNCONFIRMED', target_lang=target_lang, block_id=row_id,
+                            severity='diagnostic', decision='PASS_WITH_WARNING',
+                            detail={'semantic_object_version': self.TRANSLATION_SEMANTIC_OBJECT_VERSION},
+                        )
                     evidence_row = self._translation_claim_qa_evidence.setdefault(
                         (meta['block_id'], meta['claim_id']), {}
                     )
                     evidence_row['semantic_delta_codes'] = evidence_codes[:6]
+                    evidence_row['semantic_object_deltas'] = semantic_objects[:6]
+                    evidence_row['semantic_object_hash'] = str(meta['semantic_object'].get('object_hash') or '')
+                    evidence_row['semantic_object_version'] = self.TRANSLATION_SEMANTIC_OBJECT_VERSION
                 if 'GRAMMAR' in codes:
                     if not grammar_evidence_codes:
                         grammar_evidence_codes = ['GRAMMAR_UNSPECIFIED']
@@ -8440,7 +8572,15 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                     )
                     if only_suppressed_contamination:
                         continue
-                    codes = ['SEMANTIC_DRIFT']
+                    # R6-R9: model rejection without a typed actionable defect is
+                    # uncertainty, not evidence. Deterministic skeleton/fact/entity
+                    # validators remain authoritative and already ran.
+                    self._record_translation_assurance(
+                        'TRANSLATION_QA_NO_TYPED_BLOCKER', target_lang=target_lang, block_id=row_id,
+                        severity='diagnostic', decision='PASS_WITH_WARNING',
+                        detail={'semantic_object_version': self.TRANSLATION_SEMANTIC_OBJECT_VERSION},
+                    )
+                    continue
                 issues.setdefault(meta['block_id'], {})[meta['claim_id']] = list(dict.fromkeys(codes))[:5]
         return issues
 
@@ -8804,6 +8944,12 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             '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()}),
+            'semantic_object_version': str(evidence.get('semantic_object_version') or ''),
+            'semantic_object_delta_ids': sorted({
+                str(item.get('object_id') or item.get('dimension') or '').strip()
+                for item in (evidence.get('semantic_object_deltas') or []) if isinstance(item, dict)
+                and str(item.get('object_id') or item.get('dimension') or '').strip()
+            }),
         }
         payload = json.dumps(bounded, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
         return hashlib.sha256(payload.encode('utf-8')).hexdigest()
@@ -8864,7 +9010,12 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
         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}
+        evidence_payload = {
+            'issue_codes': codes[:5], 'repair_strategy': strategy,
+            'semantic_object': self._translation_semantic_object_frame(
+                source_claim, getattr(self, '_translation_section_name', '')
+            ),
+        }
         if strategy == 'LOCAL_EDIT':
             evidence_payload['current_target_claim'] = str(current_target_claim or '').strip()
         lexical_tokens = [
@@ -8879,6 +9030,12 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
         ]
         if semantic_delta_codes:
             evidence_payload['semantic_delta_codes'] = semantic_delta_codes[:6]
+        semantic_object_deltas = [
+            dict(item) for item in (supplied_evidence.get('semantic_object_deltas') or [])
+            if isinstance(item, dict) and str(item.get('dimension') or '').strip()
+        ]
+        if semantic_object_deltas:
+            evidence_payload['semantic_object_deltas'] = semantic_object_deltas[:6]
         grammar_evidence_codes = [
             str(code or '').strip().upper() for code in (supplied_evidence.get('grammar_evidence_codes') or [])
             if str(code or '').strip()
@@ -8903,7 +9060,7 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
             + '. Use the bounded detector evidence below only to repair the supplied claim; do not invent additional defects. '
               '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 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. When semantic_object_deltas is present, its source_span/target_span pairs are the narrow object-bound evidence; repair that object relation only and do not reinterpret the rest of the claim. 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.'
@@ -9014,6 +9171,9 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                     'source_hash': hashlib.sha256(str(item['text']).encode('utf-8')).hexdigest(),
                     'semantic_frame': cls._source_semantic_claim_frame(item['text'], section_name),
                     'semantic_frame_hash': cls._source_semantic_claim_frame(item['text'], section_name).get('frame_hash', ''),
+                    'semantic_object': cls._translation_semantic_object_frame(item['text'], section_name),
+                    'semantic_object_hash': cls._translation_semantic_object_frame(item['text'], section_name).get('object_hash', ''),
+                    'semantic_object_version': cls.TRANSLATION_SEMANTIC_OBJECT_VERSION,
                     'target_text': target_text,
                     '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],
@@ -9058,11 +9218,16 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                 row = states.get(key)
                 expected_hash = hashlib.sha256(str(item['text']).encode('utf-8')).hexdigest()
                 expected_semantic_hash = cls._source_semantic_claim_frame(item['text'], section_name).get('frame_hash', '')
+                expected_object_hash = cls._translation_semantic_object_frame(item['text'], section_name).get('object_hash', '')
                 if not isinstance(row, dict) or row.get('source_hash') != expected_hash or not str(row.get('target_text') or '').strip():
                     return {}, {}, False
-                # R6-R1: new states are semantic-frame bound.  Pre-R6 states do
-                # not carry this optional field and retain legacy fail-closed
-                # repair history instead of being silently "revived".
+                # R6-R9: durable target claims are semantic-object bound. Any
+                # pre-v1 object state is target-only stale and must be rebuilt;
+                # sealed English remains untouched.
+                if str(row.get('semantic_object_version') or '') != cls.TRANSLATION_SEMANTIC_OBJECT_VERSION:
+                    return {}, {}, False
+                if str(row.get('semantic_object_hash') or '') != expected_object_hash:
+                    return {}, {}, False
                 stored_semantic_hash = str(row.get('semantic_frame_hash') or '')
                 if stored_semantic_hash and stored_semantic_hash != expected_semantic_hash:
                     return {}, {}, False
@@ -9177,11 +9342,25 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                             for item in (repair_evidence.get('grammar_evidence_codes') or [])
                             if str(item or '').strip()
                         ] or ['GRAMMAR_UNSPECIFIED']
+                    semantic_evidence_codes = [
+                        str(item or '').strip().upper()
+                        for item in (repair_evidence.get('semantic_delta_codes') or [])
+                        if str(item or '').strip()
+                    ]
+                    semantic_object_deltas = [
+                        dict(item) for item in (repair_evidence.get('semantic_object_deltas') or [])
+                        if isinstance(item, dict)
+                    ]
                     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],
+                        'semantic_evidence_codes': semantic_evidence_codes[:6],
+                        'semantic_object_deltas': semantic_object_deltas[:6],
+                        'semantic_object': self._translation_semantic_object_frame(
+                            source_claims[claim_id], section_name, glossary
+                        ),
                     })
 
         confirmed = {}
@@ -9202,8 +9381,10 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
             return confirmed
 
         allowed_evidence = {
-            'CLAIM_MISSING','CLAIM_ADDED','POLARITY_CHANGED','CAUSALITY_CHANGED',
-            'UNCERTAINTY_CHANGED','MEANING_CHANGED','CITATION_MOVED','ACRONYM_MISATTACHED',
+            'CLAIM_MISSING','CLAIM_ADDED','ACTOR_CHANGED','RELATION_CHANGED','OBJECT_CHANGED',
+            'CONDITION_SCOPE_CHANGED','COMPARISON_DIRECTION_CHANGED','TEMPORAL_SCOPE_CHANGED',
+            'POLARITY_CHANGED','CAUSALITY_STRENGTH_CHANGED','MODALITY_UNCERTAINTY_CHANGED',
+            'CITATION_MOVED','ACRONYM_MISATTACHED',
             'GRAMMATICAL_VIOLATION','CASE_GOVERNMENT','AGREEMENT','MORPHOLOGY','VERB_FORM',
             'SYNTAX_STRUCTURE','PUNCTUATION','SYNTACTIC_COMPLETENESS','GRAMMAR_UNSPECIFIED',
             'WORD_ORDER_UNGRAMMATICAL','WORD_ORDER_SEMANTIC_SCOPE_CHANGED',
@@ -9228,6 +9409,9 @@ Each code must be one of: {sorted(allowed)}. Return one or more specific dimensi
                 },
                 'contamination_evidence_codes': list(row.get('contamination_evidence_codes') or [])[:2],
                 'grammar_evidence_codes': list(row.get('grammar_evidence_codes') or [])[:4],
+                'semantic_evidence_codes': list(row.get('semantic_evidence_codes') or [])[:6],
+                'semantic_object_deltas': list(row.get('semantic_object_deltas') or [])[:6],
+                'semantic_object': dict(row.get('semantic_object') or {}),
             } for row in model_rows],
         }
         lexical_contract = self._translation_lexical_retention_contract(target_lang)
@@ -9236,6 +9420,7 @@ 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.
+For semantic issues, semantic_object is immutable source authority and semantic_evidence_codes/semantic_object_deltas are the only admissible semantic defect lineage. A generic claim that meaning changed is NOT sufficient. For SEMANTIC_DRIFT, confirm blocking only when the evidence_code exactly matches one of the supplied object-bound semantic dimensions. If the prior semantic object evidence is absent, invalid, or the current pair no longer supports the same dimension, return NOT_CONFIRMED. For NEGATION_DRIFT, CAUSALITY_STRENGTH_DRIFT, UNCERTAINTY_DRIFT, OMITTED_CLAIM, and ADDED_CLAIM, evidence_code must remain continuous with the corresponding supplied semantic_evidence_codes.
 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."""
@@ -9264,6 +9449,25 @@ 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'] in {
+                    'SEMANTIC_DRIFT','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
+                    'UNCERTAINTY_DRIFT','OMITTED_CLAIM','ADDED_CLAIM',
+                } and decision == 'CONFIRMED_BLOCKING':
+                    typed = {
+                        str(code or '').strip().upper()
+                        for code in (row.get('semantic_evidence_codes') or []) if str(code or '').strip()
+                    }
+                    if not typed or evidence_code not in typed:
+                        decision = 'NOT_CONFIRMED'
+                        evidence_code = 'QA_DISAGREEMENT'
+                    elif row['code'] == 'SEMANTIC_DRIFT':
+                        object_dims = {
+                            str(item.get('dimension') or '').strip().upper()
+                            for item in (row.get('semantic_object_deltas') or []) if isinstance(item, dict)
+                        }
+                        if evidence_code not in object_dims:
+                            decision = 'NOT_CONFIRMED'
+                            evidence_code = 'QA_DISAGREEMENT'
                 if row['code'] == 'LANGUAGE_CONTAMINATION':
                     lexical = dict(row.get('lexical_evidence') or {})
                     typed = set(row.get('contamination_evidence_codes') or [])
@@ -9643,13 +9847,14 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                 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]
+                        specific_semantic = list(dict.fromkeys(semantic_deltas))[:6]
+                        # R6-R9: generic semantic drift cannot arrive here without
+                        # a source/target-bound semantic object. Specific semantic
+                        # codes (polarity/causality/modality/claim add-missing) are
+                        # derived directly above and do not require a second free
+                        # semantic-decomposition model call.
+                        if semantic_issue and not specific_semantic:
+                            repair_evidence['semantic_delta_codes'] = ['UNRESOLVED_SEMANTIC_DELTA']
                         if repair_evidence.get('semantic_delta_codes'):
                             self._record_translation_assurance(
                                 'SEMANTIC_REPAIR_EVIDENCE', target_lang=target_lang,