S0-R1-C5.5-R2 Deterministic Target-Language Quantitative Table Binding

core/generation_runner.py

@@ -4063,9 +4063,21 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 section_integrity_seals[section_key] = self._build_section_integrity_seal(
                     section_key, sec_title, frozen_section
                 )
+                translation_source = frozen_section
+                if (
+                    mode == "amj"
+                    and str(section_key).strip().casefold() == "results"
+                    and data_metadata.get("quantitative_table_manifest")
+                ):
+                    # Table values are manifest-owned and must never be handed to the
+                    # translation model as mutable prose. The target tables are rebound
+                    # deterministically after Results translation QA.
+                    translation_source = quant_engine._strip_target_quantitative_markdown_tables(
+                        frozen_section
+                    )
                 self._enqueue_translation_unit(
                     translation_agent,
-                    unit_key=section_key, unit_name=sec_title, source_text=frozen_section,
+                    unit_key=section_key, unit_name=sec_title, source_text=translation_source,
                     translation_sections=translation_sections,
                     english_commit_text=full_draft_en,
                 )
@@ -4423,13 +4435,41 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             for key, title in section_order:
                 final_units.append((key, title, self._extract_top_level_section(body_only, title)))
             for index, (unit_key, unit_name, source_text) in enumerate(final_units, start=1):
+                translation_source = source_text
+                if (
+                    mode == "amj"
+                    and str(unit_key).strip().casefold() == "results"
+                    and data_metadata.get("quantitative_table_manifest")
+                ):
+                    translation_source = quant_engine._strip_target_quantitative_markdown_tables(
+                        source_text
+                    )
                 translation_sections, translation_glossary = self._translate_frozen_unit(
-                    translation_agent, unit_key=unit_key, unit_name=unit_name, source_text=source_text,
+                    translation_agent, unit_key=unit_key, unit_name=unit_name, source_text=translation_source,
                     target_lang=target_lang, translation_sections=translation_sections,
                     translation_glossary=translation_glossary, adaptive_structure=adaptive_structure,
                     include_front=True, defer_failures=False,
                     english_commit_text=full_draft_en, final_gate=True,
                 )
+                # R2: quantitative tables are manifest-owned artifacts, not translation-model output.
+                # Rebind them only after the frozen Results translation has passed its language/semantic QA.
+                # Re-running this block is idempotent because the engine first removes any prior/model table block.
+                if mode == "amj" and str(unit_key).strip().casefold() == "results":
+                    table_manifest = dict(data_metadata.get("quantitative_table_manifest") or {})
+                    current_result_translation = dict(translation_sections.get(unit_key) or {})
+                    if (
+                        table_manifest
+                        and current_result_translation.get("qa_status") in {"passed", "passed_with_warning"}
+                        and current_result_translation.get("translated_text")
+                    ):
+                        current_result_translation["translated_text"] = quant_engine.bind_target_language_quantitative_tables(
+                            current_result_translation.get("translated_text"),
+                            table_manifest, target_lang, translation_glossary,
+                        )
+                        current_result_translation["quantitative_table_binding_version"] = (
+                            quant_engine.TARGET_TABLE_BINDING_VERSION
+                        )
+                        translation_sections[unit_key] = current_result_translation
                 partial = self._assemble_partial_translation(
                     translation_sections, adaptive_structure, include_front=True
                 )

core/quantitative_engine.py

@@ -20,6 +20,91 @@ class QuantitativeEngine:
     QUANTITATIVE_EVIDENCE_LEDGER_VERSION = "quantitative-evidence-ledger-v2"
     QUANTITATIVE_TABLE_MANIFEST_VERSION = "quantitative-table-manifest-v1"
     HYPOTHESIS_LEDGER_VERSION = "quantitative-hypothesis-ledger-v1"
+    TARGET_TABLE_BINDING_VERSION = "target-quantitative-table-binding-v1"
+
+    _TARGET_TABLE_LOCALIZATION = {
+        "zh": {
+            "caption": "表 {number}：{title}",
+            "titles": {
+                1: "信度与收敛效度",
+                2: "描述性统计与判别效度（Fornell-Larcker 准则）",
+                3: "关联模型结果",
+                4: "秩次稳健性相关（Spearman）",
+            },
+            "cells": {
+                "Construct": "构念", "Items": "题项数", "Cronbach's α": "Cronbach α",
+                "Mean": "均值", "SD": "SD", "Association": "关联关系",
+                "Standardized estimate": "标准化估计", "R² of outcome": "结果变量的 R²",
+                "Path": "路径", "Beta": "Beta", "Estimate": "估计量",
+                "Point estimate": "点估计", "95% bootstrap CI lower": "95% bootstrap CI 下限",
+                "95% bootstrap CI upper": "95% bootstrap CI 上限",
+            },
+            "phrases": {
+                "Indirect association:": "间接关联：",
+                "Indirect association": "间接关联",
+                "Residual direct association": "剩余直接关联",
+                "controlling": "控制",
+            },
+            "notes": {
+                "Diagonal elements in parentheses are the square roots of AVE.": "括号中的对角线元素为 AVE 的平方根。",
+            },
+            "note_prefix": "注：",
+        },
+        "ru": {
+            "caption": "Таблица {number}: {title}",
+            "titles": {
+                1: "Надёжность и конвергентная валидность",
+                2: "Описательная статистика и дискриминантная валидность (критерий Форнелла–Ларкера)",
+                3: "Результаты модели ассоциаций",
+                4: "Ранговые корреляции для проверки устойчивости (Спирмен)",
+            },
+            "cells": {
+                "Construct": "Конструкт", "Items": "Пункты", "Cronbach's α": "α Кронбаха",
+                "Mean": "Среднее", "SD": "SD", "Association": "Ассоциация",
+                "Standardized estimate": "Стандартизированная оценка", "R² of outcome": "R² результата",
+                "Path": "Связь", "Beta": "Beta", "Estimate": "Оценка",
+                "Point estimate": "Точечная оценка", "95% bootstrap CI lower": "Нижняя граница 95% bootstrap CI",
+                "95% bootstrap CI upper": "Верхняя граница 95% bootstrap CI",
+            },
+            "phrases": {
+                "Indirect association:": "Косвенная ассоциация:",
+                "Indirect association": "Косвенная ассоциация",
+                "Residual direct association": "Остаточная прямая ассоциация",
+                "controlling": "при контроле",
+            },
+            "notes": {
+                "Diagonal elements in parentheses are the square roots of AVE.": "Диагональные элементы в скобках представляют квадратные корни из AVE.",
+            },
+            "note_prefix": "Примечание:",
+        },
+        "kk": {
+            "caption": "{number}-кесте: {title}",
+            "titles": {
+                1: "Сенімділік және конвергенттік валидтілік",
+                2: "Сипаттамалық статистика және дискриминанттық валидтілік (Форнелл–Ларкер критерийі)",
+                3: "Байланыстар моделінің нәтижелері",
+                4: "Орнықтылықты тексеруге арналған рангтік корреляциялар (Спирмен)",
+            },
+            "cells": {
+                "Construct": "Конструкт", "Items": "Тармақтар", "Cronbach's α": "Кронбах α",
+                "Mean": "Орташа", "SD": "SD", "Association": "Байланыс",
+                "Standardized estimate": "Стандартталған бағалау", "R² of outcome": "Нәтиженің R²",
+                "Path": "Байланыс", "Beta": "Beta", "Estimate": "Бағалау",
+                "Point estimate": "Нүктелік бағалау", "95% bootstrap CI lower": "95% bootstrap CI төменгі шегі",
+                "95% bootstrap CI upper": "95% bootstrap CI жоғарғы шегі",
+            },
+            "phrases": {
+                "Indirect association:": "Жанама байланыс:",
+                "Indirect association": "Жанама байланыс",
+                "Residual direct association": "Қалдық тікелей байланыс",
+                "controlling": "бақылау кезінде",
+            },
+            "notes": {
+                "Diagonal elements in parentheses are the square roots of AVE.": "Жақшадағы диагональ элементтер AVE квадрат түбірлерін көрсетеді.",
+            },
+            "note_prefix": "Ескертпе:",
+        },
+    }
 
     @classmethod
     def build_hypothesis_ledger(cls, constructs):
@@ -126,6 +211,180 @@ class QuantitativeEngine:
         ]
         return {"version": cls.QUANTITATIVE_TABLE_MANIFEST_VERSION, "tables": rows}
 
+    @staticmethod
+    def _target_table_language_code(target_lang):
+        value = str(target_lang or "").strip().casefold().replace("_", "-")
+        if value.startswith("zh") or "chinese" in value or "中文" in value or "简体" in value:
+            return "zh"
+        if value.startswith("ru") or "russian" in value or "рус" in value:
+            return "ru"
+        if value.startswith("kk") or value.startswith("kz") or "kazakh" in value or "қазақ" in value:
+            return "kk"
+        return "en"
+
+    @staticmethod
+    def _replace_glossary_terms(value, glossary):
+        text = str(value or "")
+        pairs = []
+        for source, target in dict(glossary or {}).items():
+            source = re.sub(r"\s+", " ", str(source or "")).strip()
+            target = re.sub(r"\s+", " ", str(target or "")).strip()
+            if not source or not target or source == target:
+                continue
+            if not re.search(r"[A-Za-z]", source):
+                continue
+            pairs.append((source, target))
+        for source, target in sorted(pairs, key=lambda row: len(row[0]), reverse=True):
+            pattern = re.compile(
+                rf"(?<![A-Za-z0-9_]){re.escape(source)}(?![A-Za-z0-9_])",
+                flags=re.I,
+            )
+            text = pattern.sub(lambda _match, replacement=target: replacement, text)
+        return text
+
+    @classmethod
+    def _localize_quantitative_table_cell(cls, value, target_lang, glossary=None):
+        code = cls._target_table_language_code(target_lang)
+        if code == "en":
+            return cls._replace_glossary_terms(value, glossary)
+        profile = cls._TARGET_TABLE_LOCALIZATION[code]
+        text = str(value or "")
+        stripped = text.strip()
+        exact = dict(profile.get("cells") or {})
+        if stripped in exact:
+            return text.replace(stripped, str(exact[stripped]), 1)
+        text = cls._replace_glossary_terms(text, glossary)
+        for source, target in sorted(
+            dict(profile.get("phrases") or {}).items(), key=lambda row: len(row[0]), reverse=True
+        ):
+            text = re.sub(re.escape(source), str(target), text, flags=re.I)
+        return text
+
+    @classmethod
+    def _localize_quantitative_markdown_table(cls, markdown, target_lang, glossary=None):
+        lines = []
+        for line in str(markdown or "").splitlines():
+            if not line.lstrip().startswith("|"):
+                lines.append(line)
+                continue
+            raw = line.rstrip()
+            cells = raw.split("|")
+            # Alignment rows contain only punctuation/colons and must remain byte-stable.
+            if all(not re.search(r"[A-Za-z\u0400-\u04FF\u4e00-\u9fff]", cell) for cell in cells):
+                lines.append(raw)
+                continue
+            localized = [cls._localize_quantitative_table_cell(cell, target_lang, glossary) for cell in cells]
+            lines.append("|".join(localized))
+        return "\n".join(lines).strip()
+
+    @classmethod
+    def localize_quantitative_table_manifest(cls, manifest, target_lang, glossary=None):
+        record = dict(manifest or {})
+        rows = [dict(item) for item in (record.get("tables") or []) if isinstance(item, dict)]
+        if {int(row.get("number") or 0) for row in rows} != {1, 2, 3, 4}:
+            return {}
+        code = cls._target_table_language_code(target_lang)
+        profile = cls._TARGET_TABLE_LOCALIZATION.get(code, {})
+        localized_rows = []
+        for row in sorted(rows, key=lambda item: int(item.get("number") or 0)):
+            number = int(row.get("number") or 0)
+            title = str(row.get("title") or "").strip()
+            note = str(row.get("note") or "").strip()
+            if code != "en":
+                title = str(dict(profile.get("titles") or {}).get(number) or title)
+                note = str(dict(profile.get("notes") or {}).get(note) or note)
+            localized_rows.append({
+                **row,
+                "number": number,
+                "title": title,
+                "markdown": cls._localize_quantitative_markdown_table(
+                    row.get("markdown"), target_lang, glossary
+                ),
+                **({"note": note} if note else {}),
+            })
+        return {
+            "version": cls.TARGET_TABLE_BINDING_VERSION,
+            "source_manifest_version": str(record.get("version") or ""),
+            "language": code,
+            "tables": localized_rows,
+        }
+
+    @staticmethod
+    def _strip_target_quantitative_markdown_tables(text):
+        """Remove any model-rendered table blocks before manifest-owned rebinding."""
+        lines = str(text or "").splitlines()
+        kept = []
+        index = 0
+        caption_pattern = re.compile(
+            r"^\s*(?:Table\s+\d+|表\s*\d+|Таблиц(?:а|ы|е|у|ей|ами|ах)?\s*\d+|Кесте\s*\d+|\d+\s*[-–—]?\s*кесте)\s*[:：.\-–—]",
+            flags=re.I,
+        )
+        note_pattern = re.compile(r"^\s*\*?(?:Note|注|Примечание|Ескертпе)\s*[:：]", flags=re.I)
+        while index < len(lines):
+            line = lines[index]
+            if caption_pattern.match(line):
+                index += 1
+                while index < len(lines) and not lines[index].strip():
+                    index += 1
+                if index < len(lines) and lines[index].lstrip().startswith("|"):
+                    while index < len(lines) and lines[index].lstrip().startswith("|"):
+                        index += 1
+                while index < len(lines) and not lines[index].strip():
+                    index += 1
+                if index < len(lines) and note_pattern.match(lines[index]):
+                    index += 1
+                continue
+            if line.lstrip().startswith("|"):
+                start = index
+                while index < len(lines) and lines[index].lstrip().startswith("|"):
+                    index += 1
+                block = lines[start:index]
+                if len(block) >= 2 and re.search(r"-{3,}", block[1]):
+                    continue
+                kept.extend(block)
+                continue
+            kept.append(line)
+            index += 1
+        return re.sub(r"\n{3,}", "\n\n", "\n".join(kept)).strip()
+
+    @classmethod
+    def bind_target_language_quantitative_tables(cls, translated_results, manifest, target_lang, glossary=None):
+        """Bind exactly Table 1-4 to one translated Results unit without model ownership.
+
+        This operation is deterministic and idempotent. Statistical values remain
+        source-manifest owned; only captions, generic statistical labels, notes,
+        and canonical construct surfaces are localized.
+        """
+        localized = cls.localize_quantitative_table_manifest(manifest, target_lang, glossary)
+        rows = [item for item in (localized.get("tables") or []) if isinstance(item, dict)]
+        if {int(row.get("number") or 0) for row in rows} != {1, 2, 3, 4}:
+            raise RuntimeError("target_quantitative_table_manifest_invalid")
+        code = cls._target_table_language_code(target_lang)
+        profile = cls._TARGET_TABLE_LOCALIZATION.get(code, {})
+        base = cls._strip_target_quantitative_markdown_tables(translated_results)
+        blocks = []
+        for row in rows:
+            number = int(row.get("number") or 0)
+            title = str(row.get("title") or "").strip()
+            markdown = str(row.get("markdown") or "").strip()
+            if not number or not title or not markdown:
+                raise RuntimeError(f"target_quantitative_table_manifest_invalid:Table {number}")
+            if code == "zh":
+                caption = f"表 {number}：{title}"
+            elif code == "ru":
+                caption = f"Таблица {number}: {title}"
+            elif code == "kk":
+                caption = f"{number}-кесте: {title}"
+            else:
+                caption = f"Table {number}: {title}"
+            block = caption + "\n" + markdown
+            note = str(row.get("note") or "").strip()
+            if note:
+                prefix = str(profile.get("note_prefix") or "Note:")
+                block += f"\n\n*{prefix} {note}*"
+            blocks.append(block)
+        return (base.rstrip() + "\n\n" + "\n\n".join(blocks)).strip()
+
     @staticmethod
     def generate_psd_corr_matrix(n_constructs, max_corr=0.5):
         if n_constructs == 1: