Step 4A-6-C-R3.2.8.4 Translation Fact Ledger and 60ms Streaming Fix

.gitattributes

@@ -33,4 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-core/__pycache__/pipeline_agent.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

core/generation_runner.py

@@ -33,6 +33,7 @@ ProgressCallback = Callable[..., None]
 MIN_FINAL_REFERENCES = 50
 LITERATURE_EVIDENCE_TARGET = 75
 CITATION_PLAN_TARGET = 70
+TRANSLATION_CONTRACT_VERSION = 'fact-ledger-v1'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -252,6 +253,14 @@ class GenerationRunner:
         encoded = json.dumps(dict(glossary or {}), ensure_ascii=False, sort_keys=True).encode('utf-8')
         return hashlib.sha256(encoded).hexdigest()[:16]
 
+    @staticmethod
+    def _translation_ledger_hash(agent, source: str) -> str:
+        method = getattr(agent, 'translation_fact_ledger_hash', None)
+        if callable(method):
+            return str(method(source) or '')
+        # Test doubles / legacy adapters still get deterministic invalidation.
+        return hashlib.sha256(str(source or '').encode('utf-8')).hexdigest()
+
     @staticmethod
     def _assemble_partial_translation(translation_sections, adaptive_structure, *, include_front=False) -> str:
         mapping = translation_sections if isinstance(translation_sections, dict) else {}
@@ -274,11 +283,15 @@ class GenerationRunner:
         if not source:
             return translation_sections, translation_glossary
         source_hash = self._text_hash(source)
+        contract_version = TRANSLATION_CONTRACT_VERSION
+        fact_ledger_hash = self._translation_ledger_hash(agent, source)
         existing = dict((translation_sections or {}).get(unit_key) or {})
         if (
             existing.get('qa_status') == 'passed'
             and existing.get('source_hash') == source_hash
             and existing.get('target_lang') == target_lang
+            and existing.get('translation_contract_version') == contract_version
+            and existing.get('fact_ledger_hash') == fact_ledger_hash
             and existing.get('translated_text')
         ):
             return translation_sections, translation_glossary
@@ -293,6 +306,8 @@ class GenerationRunner:
             'source_hash': source_hash,
             'target_lang': target_lang,
             'glossary_version': self._glossary_version(updated_glossary),
+            'translation_contract_version': str(result.get('translation_contract_version') or contract_version),
+            'fact_ledger_hash': str(result.get('fact_ledger_hash') or fact_ledger_hash),
             'translated_text': str(result.get('text') or '').strip(),
             'qa_status': 'passed',
             'attempts': int(result.get('attempts') or 1),

core/pipeline_agent.py

@@ -10,6 +10,7 @@ import random
 import tiktoken
 import sys
 import logging
+import hashlib
 import concurrent.futures
 from collections import Counter
 from datetime import datetime, timezone
@@ -55,6 +56,8 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
+    TRANSLATION_CONTRACT_VERSION = 'fact-ledger-v1'
+
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
         if not self.ds_key:
@@ -3448,14 +3451,78 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         text = re.sub(r'(?<!\d)(?:19|20)\d{2}\s+жылғы\s+\d{1,2}\s+(?:қаңтар|ақпан|наурыз|сәуір|мамыр|маусым|шілде|тамыз|қыркүйек|қазан|қараша|желтоқсан)', ' ', text, flags=re.I)
         return cls._numeric_tokens(text)
 
+    @staticmethod
+    def _translation_number_word_regex():
+        # Conservative explicit English number-word quantities.  Restrict to
+        # phrases containing a magnitude word so ordinary prose such as "one of"
+        # is not rewritten as a numeric fact.
+        units = r'one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen'
+        tens = r'twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety'
+        magnitudes = r'hundred|thousand|million|billion'
+        word = rf'(?:{units}|{tens}|{magnitudes}|and)'
+        return rf'(?<![A-Za-z])(?=[A-Za-z -]*(?:{magnitudes})\b){word}(?:[ -]+{word})+(?![A-Za-z])'
+
+    @classmethod
+    def _canonicalize_translation_quantity(cls, value):
+        text = re.sub(r'[-]+', ' ', str(value or '').strip().casefold())
+        tokens = [t for t in text.split() if t != 'and']
+        small = {
+            'one':1,'two':2,'three':3,'four':4,'five':5,'six':6,'seven':7,'eight':8,'nine':9,
+            'ten':10,'eleven':11,'twelve':12,'thirteen':13,'fourteen':14,'fifteen':15,'sixteen':16,
+            'seventeen':17,'eighteen':18,'nineteen':19,'twenty':20,'thirty':30,'forty':40,'fifty':50,
+            'sixty':60,'seventy':70,'eighty':80,'ninety':90,
+        }
+        total = 0
+        current = 0
+        for token in tokens:
+            if token in small:
+                current += small[token]
+            elif token == 'hundred':
+                current = max(1, current) * 100
+            elif token in {'thousand','million','billion'}:
+                scale = {'thousand':1000,'million':1000000,'billion':1000000000}[token]
+                total += max(1, current) * scale
+                current = 0
+            else:
+                return ''
+        return str(total + current) if (total or current) else ''
+
+    @staticmethod
+    def _canonicalize_numeric_fact(value):
+        text = str(value or '').strip()
+        if not text:
+            return ''
+        return text.replace(',', '')
+
+    @classmethod
+    def _translation_fact_render_policy(cls, anchor_type):
+        if anchor_type == 'DATE':
+            return 'localized_date'
+        if anchor_type == 'QUANTITY':
+            return 'canonical_numeric'
+        return 'exact'
+
+    @classmethod
+    def _translation_fact_canonical(cls, token, anchor_type):
+        value = str(token or '')
+        if anchor_type == 'DATE':
+            return cls._canonicalize_translation_date(value)
+        if anchor_type == 'QUANTITY':
+            return cls._canonicalize_translation_quantity(value)
+        if anchor_type in {'NUMBER','STAT'}:
+            return cls._canonicalize_numeric_fact(value)
+        return value
+
     @classmethod
     def _translation_anchor_type(cls, token):
         value = str(token or '')
         if re.fullmatch(cls._translation_date_regex(), value, flags=re.I): return 'DATE'
+        if re.fullmatch(cls._translation_number_word_regex(), value, flags=re.I): return 'QUANTITY'
+        if re.fullmatch(r'(?i:(?:\d+(?:\.\d+)?%)?\s*CI\s*\[\s*[-+]?\.?\d+(?:\.\d+)?\s*,\s*[-+]?\.?\d+(?:\.\d+)?\s*\])', value): return 'STAT'
         if re.fullmatch(r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)', value, flags=re.I): return 'CITATION'
         if re.fullmatch(r'(?i:https?://[^\s)>]+|doi:\s*[^\s)>]+|10\.\d{4,9}/[-._;()/:A-Z0-9]+)', value): return 'DOI_URL'
         if re.fullmatch(r'(?i:H\d+[A-Za-z]?)', value): return 'HYPOTHESIS'
-        if re.search(r'(?:p|t|f|z|r|β|χ²|R²|ΔR²)\s*(?:<=|>=|=|<|>|≤|≥)', value, flags=re.I): return 'STAT'
+        if re.search(r'(?:p|t|f|z|r|β|χ²|R²|ΔR²|N|n)\s*(?:<=|>=|=|<|>|≤|≥)', value, flags=re.I): return 'STAT'
         if re.fullmatch(r'(?:fsQCA|SmartPLS|Mplus|OpenAlex|DeepSeek|ChatGPT|RStudio|SPSS|AMOS|Stata)', value): return 'NAME'
         if re.fullmatch(cls._translation_acronym_regex(), value): return 'ACRONYM'
         if re.fullmatch(r'(?:QUOTE|CASE|RESP|P)-\d+', value, flags=re.I): return 'QUOTE_ID'
@@ -3487,19 +3554,21 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @classmethod
     def _translation_protected_pattern(cls):
-        # One-pass alternation prevents a placeholder created for a citation or
-        # URL from being matched again as an acronym/number. Keep this list
-        # conservative: protect immutable research objects, not prose.
+        # One-pass alternation prevents a placeholder created for a compound
+        # statistical/date object from being split into unrelated numbers.
         acronym = cls._translation_acronym_regex()
         numeric = cls._translation_numeric_regex()
         date_pattern = cls._translation_date_regex()
+        quantity_words = cls._translation_number_word_regex()
+        compound_ci = r'(?i:(?:\d+(?:\.\d+)?%)?\s*CI\s*\[\s*[-+]?\.?\d+(?:\.\d+)?\s*,\s*[-+]?\.?\d+(?:\.\d+)?\s*\])'
         return re.compile(
             rf'(?:{date_pattern})'
-            r'|'
-            r'(?i:https?://[^\s)>]+)'
+            rf'|(?:{compound_ci})'
+            rf'|(?:{quantity_words})'
+            r'|(?i:https?://[^\s)>]+)'
             r'|(?i:\bdoi:\s*[^\s)>]+)'
             r'|(?i:\b10\.\d{4,9}/[-._;()/:A-Z0-9]+)'
-            r'|(?i:\b(?:p|t|f|z|r)\s*(?:<=|>=|=|<|>|≤|≥)\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+))'
+            r'|(?i:\b(?:p|t|f|z|r|n)\s*(?:<=|>=|=|<|>|≤|≥)\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+))'
             r'|(?:β|χ²|R²|ΔR²)\s*(?:<=|>=|=|<|>|≤|≥)\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+)'
             r'|\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)'
             r'|`[^`\n]+`'
@@ -3515,6 +3584,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @classmethod
     def _protect_translation_tokens(cls, value):
+        """Build a private fact ledger and replace model-inaccessible values."""
         source = str(value or '')
         mapping = {}
         counter = 0
@@ -3526,13 +3596,13 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             placeholder = f'[[SP-T{counter:06d}]]'
             original = match.group(0)
             anchor_type = cls._translation_anchor_type(original)
-            manifest = {'source': original, 'type': anchor_type}
-            if anchor_type == 'DATE':
-                manifest['canonical'] = cls._canonicalize_translation_date(original)
-            left = source[max(0, match.start() - 80):match.start()]
-            right = source[match.end():min(len(source), match.end() + 60)]
-            manifest['owner_hint'] = (left + '{ANCHOR}' + right).replace('\n', ' ')
-            mapping[placeholder] = manifest
+            mapping[placeholder] = {
+                'fact_id': f'F{counter:06d}',
+                'source': original,                    # private server ledger only
+                'type': anchor_type,
+                'canonical': cls._translation_fact_canonical(original, anchor_type),
+                'render_policy': cls._translation_fact_render_policy(anchor_type),
+            }
             return placeholder
 
         protected = pattern.sub(replace, source)
@@ -3542,32 +3612,129 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         return protected, mapping
 
     @classmethod
-    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang=''):
-        text = str(value or '')
-        found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
-        expected = Counter(mapping.keys())
+    def _model_safe_translation_manifest(cls, mapping):
+        """Expose only placement metadata; factual values remain server-private."""
+        safe = []
+        for placeholder, raw in (mapping or {}).items():
+            item = raw if isinstance(raw, dict) else {'type':'IMMUTABLE'}
+            anchor_type = str(item.get('type') or 'IMMUTABLE')
+            safe.append({
+                'id': placeholder,
+                'fact_id': str(item.get('fact_id') or placeholder),
+                'type': anchor_type,
+                'sentence_index': int(item.get('sentence_index') or 0),
+                'mobility': 'same_sentence' if anchor_type in {'DATE','CITATION'} else 'same_owner',
+            })
+        return safe
+
+    @classmethod
+    def _fact_ledger_hash(cls, ledger):
+        records = []
+        for block_id, mapping in sorted((ledger or {}).items()):
+            for placeholder, raw in sorted((mapping or {}).items()):
+                item = raw if isinstance(raw, dict) else {'source':str(raw),'type':'IMMUTABLE'}
+                records.append({
+                    'block_id': str(block_id),
+                    'fact_id': str(item.get('fact_id') or placeholder),
+                    'type': str(item.get('type') or 'IMMUTABLE'),
+                    'canonical': str(item.get('canonical') or item.get('source') or ''),
+                    'sentence_index': int(item.get('sentence_index') or 0),
+                    'render_policy': str(item.get('render_policy') or 'exact'),
+                })
+        payload = json.dumps(records, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode('utf-8')
+        return hashlib.sha256(payload).hexdigest()
+
+    @classmethod
+    def translation_fact_ledger_hash(cls, section_text):
+        """Deterministic source ledger hash used by translation checkpoint reuse."""
+        units = cls._translation_body_units(section_text)
+        ledger = {}
+        body_index = 0
+        for unit in units:
+            if unit.get('kind') != 'body':
+                continue
+            body_index += 1
+            _protected, mapping = cls._protect_translation_tokens(unit.get('text') or '')
+            ledger[f'{body_index:06d}'] = mapping
+        return cls._fact_ledger_hash(ledger)
+
+    @classmethod
+    def _render_translation_fact(cls, manifest, target_lang):
+        item = manifest if isinstance(manifest, dict) else {'source':str(manifest), 'type':'IMMUTABLE'}
+        policy = str(item.get('render_policy') or 'exact')
+        if policy == 'localized_date' and item.get('canonical'):
+            return cls._render_translation_date(item.get('canonical'), target_lang)
+        if policy == 'canonical_numeric' and item.get('canonical'):
+            return str(item.get('canonical'))
+        return str(item.get('source') or '')
+
+    @classmethod
+    def _translation_unowned_objects(cls, protected_target):
+        """Find factual objects invented by the model outside SP-T anchors."""
+        text = re.sub(r'\[\[SP-T\d{6}\]\]', ' ', str(protected_target or ''))
+        text = re.sub(r'\[\[SP-P\d{6}\]\]', ' ', text)
+        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()),
+        }
+        names = re.findall(r'\b(?:fsQCA|SmartPLS|Mplus|OpenAlex|DeepSeek|ChatGPT|RStudio|SPSS|AMOS|Stata)\b', text)
+        if names:
+            unowned['name'] = names
+        urls = re.findall(r'(?i:https?://[^\s)>]+|\bdoi:\s*[^\s)>]+|\b10\.\d{4,9}/[-._;()/:A-Z0-9]+)', text)
+        if urls:
+            unowned['doi_url'] = urls
+        return {key: values for key, values in unowned.items() if values}
+
+    @classmethod
+    def _validate_translation_skeleton(cls, value, mapping, block_id=''):
+        found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', str(value or '')))
+        expected = Counter((mapping or {}).keys())
         if found != expected:
             missing = list((expected - found).elements())[:8]
             added = list((found - expected).elements())[:8]
             raise DeepSeekRequestError(
                 f'Translation protected placeholder mismatch in {block_id}: missing={missing}, added={added}.'
             )
-        for placeholder, raw_manifest in mapping.items():
-            manifest = raw_manifest if isinstance(raw_manifest, dict) else {'source': str(raw_manifest), 'type': 'IMMUTABLE'}
+        unowned = cls._translation_unowned_objects(value)
+        if unowned:
+            safe_summary = {key: len(values) for key, values in unowned.items()}
+            logging.warning('Translation fact integrity failed: block=%s unowned=%s', block_id, safe_summary)
+            raise DeepSeekRequestError(f'Translation introduced unowned factual content in {block_id}: {safe_summary}.')
+        target_text = str(value or '')
+        for placeholder, raw_manifest in (mapping or {}).items():
+            manifest = raw_manifest if isinstance(raw_manifest, dict) else {'type':'IMMUTABLE'}
             source_sentence = int(manifest.get('sentence_index') or 0)
-            target_sentence = cls._translation_sentence_index(text, text.find(placeholder))
-            if manifest.get('type') in {'DATE','CITATION','STAT','HYPOTHESIS','ACRONYM','NAME'} and target_sentence != source_sentence:
+            target_sentence = cls._translation_sentence_index(target_text, target_text.find(placeholder))
+            if target_sentence != source_sentence:
                 raise DeepSeekRequestError(
-                    f'Translation semantic anchor moved across sentence boundary in {block_id}: {placeholder}.'
+                    f'Translation fact moved across sentence boundary in {block_id}: {manifest.get("fact_id") or placeholder}.'
                 )
-        for placeholder, raw_manifest in mapping.items():
-            manifest = raw_manifest if isinstance(raw_manifest, dict) else {'source': str(raw_manifest), 'type': 'IMMUTABLE'}
-            original = str(manifest.get('source') or '')
-            if target_lang and manifest.get('type') == 'DATE' and manifest.get('canonical'):
-                replacement = cls._render_translation_date(manifest.get('canonical'), target_lang)
-            else:
-                replacement = original
-            text = text.replace(placeholder, replacement)
+        # Preserve the relative order of hard quantitative/identifier facts
+        # inside each claim. DATE/CITATION/NAME may legitimately move for target
+        # grammar, but two sample/statistical values must never trade owners.
+        ordered_types = {'NUMBER','QUANTITY','STAT','HYPOTHESIS','DOI_URL','FORMULA','QUOTE_ID'}
+        for sentence_index in sorted({int((m if isinstance(m, dict) else {}).get('sentence_index') or 0) for m in (mapping or {}).values()}):
+            expected_order = [
+                ph for ph, raw in (mapping or {}).items()
+                if int((raw if isinstance(raw, dict) else {}).get('sentence_index') or 0) == sentence_index
+                and str((raw if isinstance(raw, dict) else {}).get('type') or '') in ordered_types
+            ]
+            if len(expected_order) > 1:
+                actual_order = sorted(expected_order, key=lambda ph: target_text.find(ph))
+                if actual_order != expected_order:
+                    raise DeepSeekRequestError(
+                        f'Translation fact order changed within owner sentence in {block_id}: sentence={sentence_index}.'
+                    )
+        return True
+
+    @classmethod
+    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang=''):
+        text = str(value or '')
+        cls._validate_translation_skeleton(text, mapping, block_id)
+        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):
             raise DeepSeekRequestError(f'Translation left unresolved protected placeholders in {block_id}.')
         return text
@@ -3827,23 +3994,11 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         return parsed
 
     def _validate_translation_block(self, source, translated, block_id, target_lang):
-        if self._translation_date_canonicals(source) != self._translation_date_canonicals(translated):
-            raise DeepSeekRequestError(f'Translation changed date content in {block_id}.')
-        if self._numeric_tokens_without_dates(source) != self._numeric_tokens_without_dates(translated):
-            raise DeepSeekRequestError(f'Translation changed numerical content in {block_id}.')
-        if self._translation_citation_tokens(source) != self._translation_citation_tokens(translated):
-            raise DeepSeekRequestError(f'Translation changed citations in {block_id}.')
-        if self._translation_hypothesis_tokens(source) != self._translation_hypothesis_tokens(translated):
-            raise DeepSeekRequestError(f'Translation changed hypothesis labels in {block_id}.')
-        source_acronyms = self._translation_acronym_tokens(source)
-        target_acronyms = self._translation_acronym_tokens(translated)
-        if source_acronyms != target_acronyms:
-            missing = list((source_acronyms - target_acronyms).elements())
-            added = list((target_acronyms - source_acronyms).elements())
-            raise DeepSeekRequestError(
-                f'Translation changed variable abbreviations in {block_id}: '
-                f'missing={missing}, added={added}.'
-            )
+        # R3.2.8.4: factual equality is enforced on the protected skeleton /
+        # private Fact Ledger.  This routine now owns language/coverage and the
+        # long-form/acronym adjacency check only; raw numeric Counter equality is
+        # deliberately non-authoritative because it creates multilingual false
+        # failures and can miss value swaps.
         for _long_form, acronym in self._translation_longform_acronym_pairs(source):
             if not re.search(rf'[（(]\s*{re.escape(acronym)}\s*[）)]', str(translated or '')):
                 raise DeepSeekRequestError(
@@ -3871,8 +4026,8 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             if not is_chinese and not re.search(r'[А-Яа-яЁёӘәҒғҚқҢңӨөҰұҮүҺһІі]', translated):
                 raise DeepSeekRequestError(f'Translation block {block_id} contains no Cyrillic target-language text.')
 
-    def _validate_translation_block_protected(self, block_id, source, translated, target_lang):
-        """Validate one restored block; recovery is owned by the protected gateway."""
+    def _validate_translation_block_protected(self, block_id, source, translated, target_lang, mapping=None):
+        """Validate one restored block after Fact Ledger integrity passed."""
         self._validate_translation_block(source, translated, f'SP-P{block_id}', target_lang)
         return translated
 
@@ -3896,18 +4051,16 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             for block_id, _, protected_source in protected_batch
         )
         semantic_manifest = {
-            block_id: [
-                {'id': placeholder, **manifest}
-                for placeholder, manifest in protected_maps.get(block_id, {}).items()
-            ]
+            block_id: self._model_safe_translation_manifest(protected_maps.get(block_id, {}))
             for block_id, _source, _protected in protected_batch
         }
         effective_prompt = system_prompt + (
             '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
             + json.dumps(semantic_manifest, ensure_ascii=False)
             + '\n</SEMANTIC_ANCHOR_MANIFEST>\n'
-              'Use anchor type, canonical value, sentence_index, and owner_hint only to keep each placeholder attached to its original semantic owner. '
-              'Do not print the manifest. DATE anchors may change local word order inside their sentence; CITATION anchors must remain with their original claim.'
+              'This manifest intentionally contains no factual values. Use only fact type and sentence ownership to place each placeholder. '
+              'Never infer, spell out, calculate, or recreate a hidden number, date, citation, acronym, name, formula, or identifier. '
+              'Do not print the manifest. DATE and CITATION anchors may move only within their original sentence when grammar requires it.'
         )
         if _strict:
             effective_prompt += (
@@ -4113,6 +4266,8 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                     'glossary': frozen_glossary,
                     'attempts': attempt,
                     'qa_status': 'passed',
+                    'translation_contract_version': self.TRANSLATION_CONTRACT_VERSION,
+                    'fact_ledger_hash': self.translation_fact_ledger_hash(value),
                 }
             except PipelineCancelledError:
                 raise
@@ -4207,14 +4362,10 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             raise DeepSeekRequestError(
                 f'Translation heading-tree mismatch: English={en_tree}, target={tr_tree}.'
             )
-        if SSciPipelineAgent._numeric_tokens(source) != SSciPipelineAgent._numeric_tokens(target):
-            raise DeepSeekRequestError('Translation numerical alignment failed.')
-        if SSciPipelineAgent._translation_citation_tokens(source) != SSciPipelineAgent._translation_citation_tokens(target):
-            raise DeepSeekRequestError('Translation citation alignment failed.')
-        if SSciPipelineAgent._translation_hypothesis_tokens(source) != SSciPipelineAgent._translation_hypothesis_tokens(target):
-            raise DeepSeekRequestError('Translation hypothesis-label alignment failed.')
-        if SSciPipelineAgent._translation_acronym_tokens(source) != SSciPipelineAgent._translation_acronym_tokens(target):
-            raise DeepSeekRequestError('Translation abbreviation alignment failed.')
+        # Fact integrity is authoritative at the protected-block ledger gate.
+        # Whole-unit raw Counter equality is intentionally not used here: valid
+        # localized dates/number words can change surface digits, while swapped
+        # values can preserve the same Counter.
         source_body = re.split(r'(?m)^#\s+References\s*$', source, maxsplit=1)[0]
         target_body = re.split(r'(?m)^#\s+(?:参考文献|Литература|Пайдаланылған әдебиеттер)\s*$', target, maxsplit=1)[0]
         source_chars = len(re.sub(r'\s+', '', source_body))

smartpaper_restore_bridge/frontend/index.html

@@ -311,7 +311,7 @@
     if (!channel.queue.length) return;
     const stream = ensureStreamNode(parentDocument, target, channel);
     const backlog = channel.queue.length;
-    const perTick = backlog > 260 ? 5 : backlog > 140 ? 3 : backlog > 70 ? 2 : 1;
+    const perTick = backlog > 220 ? 3 : backlog > 90 ? 2 : 1;
     let chunk = "";
     for (let i=0; i<perTick && channel.queue.length; i++) chunk += channel.queue.shift();
     if (chunk) {
@@ -319,7 +319,7 @@
       channel.displayed += chunk;
       if (shell && shell.dataset.spAutoFollow !== "0") shell.scrollTop = shell.scrollHeight;
     }
-    channel.timer = window.setTimeout(() => pumpRenderQueue(parentDocument, target, shell, channel), 34);
+    channel.timer = window.setTimeout(() => pumpRenderQueue(parentDocument, target, shell, channel), 60);
   }
 
   function renderBufferedPreview(parentDocument, target, shell, text, channel) {