A5-R3-R7-R2C-R3 adaptive finalization recovery scoped deployment

core/generation_runner.py

@@ -5229,7 +5229,25 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             agent.enforce_resolved_claim_specific_citations(body_only)
             post_front_ledger = agent.finalize_resolved_citation_ledger(body_only)
             if set(post_front_ledger) != set(final_citation_ledger):
-                raise RuntimeError("final_front_matter_changed_citation_ledger")
+                logging.warning(
+                    "Adaptive finalization resealed citation ledger after Final Front Matter | before=%s after=%s",
+                    len(final_citation_ledger), len(post_front_ledger),
+                )
+            # Final Front Matter is allowed to add/remove an already-authoritative
+            # citation. Rebuild References deterministically from the post-front
+            # resolved body instead of discarding an otherwise complete manuscript.
+            # Orphan/ambiguous citations still fail closed inside ledger finalization.
+            final_citation_ledger = list(post_front_ledger)
+            references = agent.build_final_reference_lines(final_citation_ledger)
+            final_reference_count = len(references)
+            full_draft_en = body_only.rstrip() + "\n\n# References\n" + "\n\n".join(references)
+            coverage_summary = dict(state.get("evidence_coverage_summary") or {})
+            if coverage_summary:
+                coverage_summary["final_reference_count"] = final_reference_count
+                state["evidence_coverage_summary"] = coverage_summary
+            body_only, _reference_tail = agent.validate_reference_tail(
+                full_draft_en, minimum_references=final_reference_count
+            )
             agent.validate_final_citation_bijection(body_only, _reference_tail, final_citation_ledger)
             self._upsert_quality_diagnostic(
                 quality_diagnostics, self._validate_target_length(full_draft_en, target_words)
@@ -5451,12 +5469,31 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     )
             try:
                 agent.validate_translation_alignment(full_draft_en, full_draft_translated)
-                agent.validate_reference_preservation(full_draft_en, full_draft_translated, target_lang)
             except Exception as exc:
                 self._record_adaptive_completion_residual(
                     quality_notes, [{'type':'translation_final_alignment_review','reason':str(exc)[:500]}],
                     section_name='Target-language manuscript', stage='translation_final_review'
                 )
+            try:
+                agent.validate_reference_preservation(full_draft_en, full_draft_translated, target_lang)
+            except Exception as exc:
+                logging.warning(
+                    "Adaptive target References rebind | language=%s reason=%s",
+                    target_lang, str(exc)[:300],
+                )
+                full_draft_translated = agent.rebind_target_reference_tail(
+                    full_draft_translated, reference_tail, target_lang
+                )
+                # References are identity-bearing academic data. Recovery is
+                # deterministic and provider-free; if this still fails, package
+                # generation must stop rather than ship a corrupted bibliography.
+                agent.validate_reference_preservation(
+                    full_draft_en, full_draft_translated, target_lang
+                )
+                self._record_adaptive_completion_residual(
+                    quality_notes, [{'type':'target_reference_tail_rebound','reason':str(exc)[:500]}],
+                    section_name='Target-language manuscript', stage='translation_final_recovery'
+                )
             self._publish_target_preview(
                 full_draft_translated, 'translation_complete', force=True, complete=True
             )

core/pipeline_agent.py

@@ -2659,15 +2659,52 @@ If the immutable hypothesis contract is non-empty, preserve its H-identifiers an
         )
         return sorted(ledger, key=self._citation_tag_number)
 
+    @staticmethod
+    def _canonical_reference_text(value):
+        """Canonicalize formatting-only reference variance without changing identity.
+
+        Provider metadata can legally contain embedded CR/LF, tabs, Unicode line
+        separators, non-breaking spaces, or zero-width formatting characters. A
+        reference is one bibliographic object, so those transport/layout artifacts
+        must never turn one source into multiple Markdown lines at finalization.
+        """
+        text = str(value or '')
+        text = text.replace('\r\n', '\n').replace('\r', '\n')
+        text = re.sub(r'[\u200b\u2060\ufeff]+', '', text)
+        return re.sub(r'\s+', ' ', text).strip()
+
+    @classmethod
+    def _canonical_reference_entries_from_tail(cls, reference_tail):
+        """Parse bullet references while deterministically joining wrapped lines."""
+        entries = []
+        current = []
+        for raw_line in str(reference_tail or '').replace('\r\n', '\n').replace('\r', '\n').split('\n'):
+            line = raw_line.strip()
+            if not line:
+                continue
+            if line.startswith('- '):
+                if current:
+                    entries.append(cls._canonical_reference_text(' '.join(current)))
+                current = [line[2:].strip()]
+            elif current:
+                current.append(line)
+            else:
+                raise DeepSeekRequestError(
+                    'Final References contains non-entry text before the first reference bullet.'
+                )
+        if current:
+            entries.append(cls._canonical_reference_text(' '.join(current)))
+        return entries
+
     def build_final_reference_lines(self, ledger_tags):
-        """Build one English reference entry per authoritative ledger source."""
+        """Build one canonical single-line English reference per ledger source."""
         references = {}
         for tag in ledger_tags or []:
             metadata = self.citation_map.get(str(tag)) or {}
-            ref = str(metadata.get('ref') or '').strip()
+            ref = self._canonical_reference_text(metadata.get('ref') or '')
             if not ref:
                 raise DeepSeekRequestError(f'Final citation ledger metadata missing reference text: {tag}')
-            references.setdefault(re.sub(r'\s+', ' ', ref).casefold(), ref)
+            references.setdefault(ref.casefold(), ref)
         # Reader-facing References follow the conventional alphabetical order.
         return [f"- {ref}" for ref in sorted(references.values(), key=lambda value: value.casefold())]
 
@@ -2680,18 +2717,14 @@ If the immutable hypothesis contract is non-empty, preserve its H-identifiers an
         for tag in ledger:
             metadata = self.citation_map.get(str(tag)) or {}
             marker = str(metadata.get('in_text') or '').strip()
-            ref = str(metadata.get('ref') or '').strip()
+            ref = self._canonical_reference_text(metadata.get('ref') or '')
             if not marker or not ref:
                 raise DeepSeekRequestError(f'Final citation ledger is incomplete: {tag}')
             if marker not in body:
                 raise DeepSeekRequestError(f'Final citation ledger contains a citation absent from body: {tag}')
-            expected.append(re.sub(r'\s+', ' ', ref).strip())
+            expected.append(ref)
 
-        actual = [
-            re.sub(r'\s+', ' ', line[2:]).strip()
-            for line in tail.splitlines()
-            if line.strip().startswith('- ')
-        ]
+        actual = self._canonical_reference_entries_from_tail(tail)
         if len(actual) != len(set(actual)):
             raise DeepSeekRequestError('Final References contains duplicate entries.')
         if set(actual) != set(expected):
@@ -2708,6 +2741,18 @@ If the immutable hypothesis contract is non-empty, preserve its H-identifiers an
             )
         return True
 
+    @classmethod
+    def rebind_target_reference_tail(cls, translated_text, frozen_reference_tail, target_lang):
+        """Replace a target References tail from frozen English bytes, without LLM use."""
+        target = str(translated_text or '').strip()
+        heading = cls._localized_reference_heading(target_lang)
+        matches = list(re.finditer(rf'(?m)^#\s+{re.escape(heading)}\s*$', target))
+        body = target[:matches[0].start()].rstrip() if matches else target.rstrip()
+        tail = str(frozen_reference_tail or '').strip()
+        if not tail:
+            return body + f"\n\n# {heading}\n"
+        return body + f"\n\n# {heading}\n" + tail
+
     @classmethod
     def validate_reference_preservation(cls, english_text, translated_text, target_lang):
         """References are immutable English data in ZH/RU/KK deliverables."""