Step 4A-6-C-R3.2.3 Translation Marker Robustness Fix

core/__pycache__/pipeline_agent.cpython-313.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:185a6cfe4441c00b83aab3c8b7990c30043a17525472b3d01b78350d99d8e2b7
-size 158928
+oid sha256:576dd3905d2ec79e768e26b13790a53de0568073c16ef7e03c9dda6fcc26d5f7
+size 158942

core/pipeline_agent.py

@@ -2074,7 +2074,6 @@ Return ONLY a valid JSON array of strings."""
 
         cfg = self.citation_semantic_audit
         enabled = bool(cfg.get("enabled", True))
-        fail_closed = bool(cfg.get("fail_closed", True))
         spans = self._citation_sentence_spans(text)
         if not spans:
             return text
@@ -2282,6 +2281,11 @@ Return exactly:
                     f"[{tag.upper()}]"
                     for tag in re.findall(r"CITE-\d+", revised, flags=re.IGNORECASE)
                 }
+                if status in {"ok", "split"} and not revised_tags:
+                    raise DeepSeekRequestError(
+                        f"Citation semantic audit removed all citation tags for {record['id']} "
+                        f"while status={status}."
+                    )
                 disallowed = revised_tags - set(record["allowed_tags"])
                 if disallowed:
                     raise DeepSeekRequestError(
@@ -2469,6 +2473,8 @@ Return exactly:
             except PipelineCancelledError:
                 raise
             except CitationAuditError as error:
+                if bool(self.citation_semantic_audit.get('fail_closed', False)):
+                    raise
                 logging.warning(
                     'Citation semantic audit technical fallback: section=%s code=%s detail=%s',
                     section_name,
@@ -2477,6 +2483,8 @@ Return exactly:
                 )
                 value = self._local_citation_recovery(value, section_name)
             except Exception as error:
+                if bool(self.citation_semantic_audit.get('fail_closed', False)):
+                    raise
                 logging.warning(
                     'Citation semantic audit fallback: section=%s error=%s',
                     section_name,
@@ -2806,6 +2814,83 @@ 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 _translate_marked_batch_with_recovery(self, batch, system_prompt, target_lang):
+        """Translate one marked batch with a conservative marker-recovery path.
+
+        A multi-block response must preserve every marker exactly. If the model
+        omits or reorders markers, retry each source block independently so no
+        paragraph-to-translation mapping is guessed. For a single-source retry,
+        a marker-free response can be bound safely to that sole source block,
+        but it must still pass the existing deterministic translation guards.
+        """
+        expected_ids = [block_id for block_id, _ in batch]
+        marked_source = '\n\n'.join(
+            f'[[SP-P{block_id}]]\n{source}' for block_id, source in batch
+        )
+        result = self.call_deepseek(
+            system_prompt,
+            marked_source,
+            max_tokens=max(1800, min(9000, self._count_tokens(marked_source) * 2 + 1200)),
+            temp=0.0,
+            model_role='translation',
+            thinking=False,
+            allow_fallback=False,
+        )
+        result = self._remove_ai_meta_traces(result)
+
+        try:
+            parsed = self._parse_marked_translation(result, expected_ids)
+        except DeepSeekRequestError as error:
+            if not str(error).startswith('Translation marker mismatch:'):
+                raise
+
+            if len(batch) > 1:
+                logging.warning(
+                    'Translation marker recovery: batch_size=%s expected=%s; retrying blocks independently.',
+                    len(batch),
+                    expected_ids,
+                )
+                recovered = {}
+                for item in batch:
+                    recovered.update(
+                        self._translate_marked_batch_with_recovery(
+                            [item], system_prompt, target_lang
+                        )
+                    )
+                return recovered
+
+            block_id, source = batch[0]
+            unexpected_markers = re.findall(
+                r'(?m)^\[\[SP-P(\d{6})\]\]\s*$',
+                str(result or ''),
+            )
+            if unexpected_markers:
+                raise DeepSeekRequestError(
+                    'Single-block translation returned an unexpected marker: '
+                    f'expected={block_id}, got={unexpected_markers}.'
+                ) from error
+
+            translated = str(result or '').strip()
+            if not translated:
+                raise DeepSeekRequestError(
+                    f'Single-block translation recovery returned empty text for SP-P{block_id}.'
+                ) from error
+            self._validate_translation_block(
+                source, translated, f'SP-P{block_id}', target_lang
+            )
+            logging.info(
+                'Translation marker recovery accepted marker-free single block: SP-P%s',
+                block_id,
+            )
+            return {block_id: translated}
+
+        for block_id, source in batch:
+            translated = parsed[block_id]
+            self._validate_translation_block(
+                source, translated, f'SP-P{block_id}', target_lang
+            )
+        return parsed
+
     def translate_locked_manuscript(self, manuscript, target_lang):
         value = str(manuscript or '').strip()
         if not value:
@@ -2839,24 +2924,10 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         system_prompt = self._translation_prompt(target_lang) + '\nUse this terminology glossary consistently:\n' + json.dumps(glossary, ensure_ascii=False)
         for batch in batches:
             self._check_cancelled()
-            marked_source = '\n\n'.join(
-                f'[[SP-P{block_id}]]\n{source}' for block_id, source in batch
-            )
-            result = self.call_deepseek(
-                system_prompt,
-                marked_source,
-                max_tokens=max(1800, min(9000, self._count_tokens(marked_source) * 2 + 1200)),
-                temp=0.0,
-                model_role='translation',
-                thinking=False,
-                allow_fallback=False,
+            parsed = self._translate_marked_batch_with_recovery(
+                batch, system_prompt, target_lang
             )
-            result = self._remove_ai_meta_traces(result)
-            parsed = self._parse_marked_translation(result, [block_id for block_id, _ in batch])
-            for block_id, source in batch:
-                translated = parsed[block_id]
-                self._validate_translation_block(source, translated, f'SP-P{block_id}', target_lang)
-                translations[block_id] = translated
+            translations.update(parsed)
 
         output_units = []
         body_index = 0