S0-R1-C5.5-R5 Qualitative Appendix Deterministic Target Binding

core/generation_runner.py

@@ -2090,6 +2090,108 @@ class GenerationRunner:
         )
         return updated_sections, updated_glossary
 
+    def _translate_qualitative_appendix_unit(
+        self, agent, qual_engine, *, unit_key: str, source_text: str, target_lang: str,
+        translation_sections: dict, translation_glossary: dict, data_metadata: dict,
+    ):
+        """Translate Appendix cells, then bind the six-column table deterministically."""
+        source = str(source_text or '').strip()
+        manifest = qual_engine.build_appendix_manifest(data_metadata)
+        if not qual_engine._validate_appendix_manifest(manifest):
+            raise RuntimeError('qualitative_appendix_manifest_invalid')
+        manifest_hash = str(manifest.get('manifest_hash') or '')
+        identity = self._translation_identity_bundle(agent, source)
+        entity_hash_method = getattr(agent, 'translation_protected_entity_ledger_hash', None)
+        protected_entity_ledger_hash = str(
+            entity_hash_method(identity['compiled_source'], translation_glossary)
+            if callable(entity_hash_method) else ''
+        )
+        protected_entity_ledger_version = str(
+            getattr(agent, 'PROTECTED_ENTITY_LEDGER_VERSION', 'protected-entity-ledger-v1')
+            or 'protected-entity-ledger-v1'
+        )
+        sections = dict(translation_sections or {})
+        existing = dict(sections.get(unit_key) or {})
+        if (
+            existing.get('qa_status') in {'passed', 'passed_with_warning'}
+            and existing.get('source_hash') == identity['source_hash']
+            and existing.get('target_lang') == target_lang
+            and existing.get('qualitative_appendix_binding_version') == qual_engine.TARGET_APPENDIX_BINDING_VERSION
+            and existing.get('qualitative_appendix_manifest_hash') == manifest_hash
+            and existing.get('translated_text')
+        ):
+            qual_engine.validate_bound_target_appendix(existing['translated_text'], manifest, target_lang)
+            return sections, translation_glossary
+
+        quote_record = sections.get('__quote_ledger__')
+        quote_map = dict((quote_record or {}).get('translations') or {}) if isinstance(quote_record, dict) else {}
+        required_quotes = {str(row.get('quote_id') or '') for row in manifest.get('rows') or []}
+        if any(not str(quote_map.get(tag) or '').strip() for tag in required_quotes):
+            missing = sorted(tag for tag in required_quotes if not str(quote_map.get(tag) or '').strip())
+            raise RuntimeError(f'qualitative_appendix_quote_ledger_incomplete:{missing[:6]}')
+
+        translate_cells = getattr(agent, 'translate_qualitative_appendix_cells', None)
+        if not callable(translate_cells):
+            raise RuntimeError('Typed qualitative Appendix cell translation entry point is unavailable.')
+        try:
+            result = translate_cells(
+                qual_engine.appendix_translation_cells(manifest), target_lang,
+                glossary=translation_glossary, max_attempts=2,
+                claim_states=(existing.get('appendix_cell_claim_states') if isinstance(existing.get('appendix_cell_claim_states'), dict) else None),
+            )
+            cell_translations = dict((result or {}).get('translations') or {})
+            updated_glossary = dict((result or {}).get('glossary') or translation_glossary or {})
+            translated_text = qual_engine.bind_target_language_appendix(
+                manifest, target_lang, cell_translations, quote_map
+            )
+            qual_engine.validate_bound_target_appendix(translated_text, manifest, target_lang)
+        except PipelineCancelledError:
+            raise
+        except Exception as error:
+            code_method = getattr(agent, 'translation_error_code', None)
+            error_code = str(code_method(error) if callable(code_method) else 'TRANSLATION_PENDING')
+            sections[unit_key] = {
+                'source_hash': identity['source_hash'],
+                'compiled_source_hash': identity['compiled_source_hash'],
+                'target_lang': target_lang,
+                'translation_contract_version': TRANSLATION_CONTRACT_VERSION,
+                'fact_ledger_hash': identity['fact_ledger_hash'],
+                'protected_entity_ledger_version': protected_entity_ledger_version,
+                'protected_entity_ledger_hash': protected_entity_ledger_hash,
+                'translated_text': '',
+                'qa_status': 'repair_pending',
+                'attempts': int(existing.get('attempts') or 0) + 1,
+                'error_code': error_code,
+                'qualitative_appendix_binding_version': qual_engine.TARGET_APPENDIX_BINDING_VERSION,
+                'qualitative_appendix_manifest_hash': manifest_hash,
+                'appendix_cell_claim_states': dict(getattr(agent, '_last_translation_claim_states', {}) or {}),
+                'updated_at': datetime.now(timezone.utc).isoformat(),
+            }
+            logging.warning(
+                'Qualitative Appendix typed translation repair pending | unit=%s code=%s error=%s',
+                unit_key, error_code, type(error).__name__,
+            )
+            return sections, translation_glossary
+        sections[unit_key] = {
+            'source_hash': identity['source_hash'],
+            'compiled_source_hash': identity['compiled_source_hash'],
+            'target_lang': target_lang,
+            'glossary_version': self._glossary_version(updated_glossary),
+            'translation_contract_version': TRANSLATION_CONTRACT_VERSION,
+            'fact_ledger_hash': identity['fact_ledger_hash'],
+            'protected_entity_ledger_version': protected_entity_ledger_version,
+            'protected_entity_ledger_hash': protected_entity_ledger_hash,
+            'translated_text': translated_text,
+            'qa_status': str((result or {}).get('qa_status') or 'passed'),
+            'attempts': int((result or {}).get('attempts') or 1),
+            'qualitative_appendix_binding_version': qual_engine.TARGET_APPENDIX_BINDING_VERSION,
+            'qualitative_appendix_manifest_hash': manifest_hash,
+            'appendix_cell_contract_version': str((result or {}).get('appendix_cell_contract_version') or ''),
+            'appendix_cell_claim_states': dict((result or {}).get('claim_states') or {}),
+            'updated_at': datetime.now(timezone.utc).isoformat(),
+        }
+        return sections, updated_glossary
+
     @staticmethod
     def _bounded_target(base_target: int, accumulated_deviation: float, remaining_including_current: int, safe_chunk: int) -> int:
         base = max(80, int(base_target))
@@ -3038,6 +3140,12 @@ class GenerationRunner:
             citation_unit_section_map = self._citation_unit_section_map(adaptive_structure)
         translation_sections = dict(state.get('translation_sections') or {})
         translation_glossary = dict(state.get('translation_glossary') or {})
+        if mode == "asq":
+            appendix_record = dict(translation_sections.get("appendix") or {})
+            if appendix_record and appendix_record.get("qualitative_appendix_binding_version") != qual_engine.TARGET_APPENDIX_BINDING_VERSION:
+                logging.info("Invalidating pre-R5 qualitative Appendix translation record; deterministic binding required.")
+                translation_sections.pop("appendix", None)
+                state["translation_sections"] = dict(translation_sections)
         canonical_concept_ledger = state.get('canonical_concept_ledger')
         if not isinstance(canonical_concept_ledger, dict) or not canonical_concept_ledger.get('items'):
             canonical_concept_ledger = self._build_canonical_concept_ledger(
@@ -4137,12 +4245,17 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     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=translation_source,
-                    translation_sections=translation_sections,
-                    english_commit_text=full_draft_en,
-                )
+                if mode == "asq" and str(section_key).strip().casefold() == "appendix":
+                    # R5: the qualitative Appendix is not model-owned Markdown.
+                    # It is translated/bound at the strict final gate from typed cells.
+                    pass
+                else:
+                    self._enqueue_translation_unit(
+                        translation_agent,
+                        unit_key=section_key, unit_name=sec_title, source_text=translation_source,
+                        translation_sections=translation_sections,
+                        english_commit_text=full_draft_en,
+                    )
             # Collect only already-finished target jobs.  This call never waits,
             # so English Section N+1 can start while target Section N runs.
             translation_sections, translation_glossary = self._collect_translation_results(
@@ -4506,13 +4619,20 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     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=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,
-                )
+                if mode == "asq" and str(unit_key).strip().casefold() == "appendix":
+                    translation_sections, translation_glossary = self._translate_qualitative_appendix_unit(
+                        translation_agent, qual_engine, unit_key=unit_key, source_text=source_text,
+                        target_lang=target_lang, translation_sections=translation_sections,
+                        translation_glossary=translation_glossary, data_metadata=data_metadata,
+                    )
+                else:
+                    translation_sections, translation_glossary = self._translate_frozen_unit(
+                        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.
@@ -4584,6 +4704,11 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             full_draft_translated = _normalize_target_manuscript_typography(
                 full_draft_translated, target_lang
             )
+            if mode == "asq":
+                appendix_manifest = qual_engine.build_appendix_manifest(data_metadata)
+                qual_engine.validate_bound_target_appendix(
+                    full_draft_translated, appendix_manifest, target_lang
+                )
             agent.validate_translation_alignment(full_draft_en, full_draft_translated)
             agent.validate_reference_preservation(full_draft_en, full_draft_translated, target_lang)
             self._publish_target_preview(

core/pipeline_agent.py

@@ -8255,6 +8255,59 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                 )
         return {}
 
+    def translate_qualitative_appendix_cells(
+        self, cell_objects, target_lang, glossary=None, max_attempts=2,
+        stage_callback=None, claim_states=None,
+    ):
+        """Translate typed Appendix cells without giving the model table ownership.
+
+        Cell IDs never enter model-visible text.  Unique source surfaces are
+        translated as independent SP-P blocks through the existing frozen-section
+        compiler/QA stack, then rebound to the original server-side cell IDs.
+        """
+        if not isinstance(cell_objects, dict) or not cell_objects:
+            raise DeepSeekRequestError('Qualitative Appendix cells must be a non-empty mapping.')
+        ordered = []
+        source_to_ids = {}
+        for cell_id, raw_source in cell_objects.items():
+            cell_id = str(cell_id or '').strip()
+            source = re.sub(r'\s+', ' ', str(raw_source or '')).strip()
+            if not cell_id or not source:
+                raise DeepSeekRequestError('Qualitative Appendix cell identity/source is empty.')
+            if source not in source_to_ids:
+                source_to_ids[source] = []
+                ordered.append(source)
+            source_to_ids[source].append(cell_id)
+        payload = '\n\n'.join(ordered)
+        result = self.translate_frozen_section(
+            payload, target_lang, glossary=glossary,
+            section_name='Qualitative Appendix semantic cells', max_attempts=max_attempts,
+            stage_callback=stage_callback, claim_states=claim_states,
+        )
+        body_units = [
+            unit['text'] for unit in self._translation_body_units(result.get('text') or '')
+            if unit.get('kind') == 'body'
+        ]
+        if len(body_units) != len(ordered):
+            raise DeepSeekRequestError(
+                'Qualitative Appendix cell identity mismatch after translation: '
+                f'expected={len(ordered)} got={len(body_units)}.'
+            )
+        by_source = dict(zip(ordered, body_units))
+        translations = {}
+        for source, cell_ids in source_to_ids.items():
+            target = re.sub(r'\s+', ' ', str(by_source.get(source) or '')).strip()
+            if not target:
+                raise DeepSeekRequestError('Qualitative Appendix translated cell is empty.')
+            for cell_id in cell_ids:
+                translations[cell_id] = target
+        return {
+            **dict(result or {}),
+            'translations': translations,
+            'cell_ids': list(cell_objects.keys()),
+            'appendix_cell_contract_version': 'typed-qualitative-appendix-cells-v1',
+        }
+
     def translate_frozen_section(self, section_text, target_lang, glossary=None, section_name='', max_attempts=2, stage_callback=None, claim_states=None):
         """Translate one frozen English unit and publish only after all QA passes."""
         value = str(section_text or '').strip()

core/qualitative_engine.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import logging
 import re
 
@@ -11,6 +12,32 @@ from config import APP_CONFIG
 
 
 class QualitativeEngine:
+    QUALITATIVE_APPENDIX_MANIFEST_VERSION = "qualitative-appendix-manifest-v1"
+    TARGET_APPENDIX_BINDING_VERSION = "target-qualitative-appendix-binding-v1"
+    APPENDIX_FIELDS = ("theme", "concept", "stage", "case_label", "evidence_role")
+    APPENDIX_HEADERS = (
+        "Higher-order Theme", "Empirical Concept", "Process Stage",
+        "Case/Actor", "Evidence Role", "Representative Quote",
+    )
+    _TARGET_APPENDIX_LOCALIZATION = {
+        "en": {
+            "heading": "Appendix: Data Structure and Evidence",
+            "headers": APPENDIX_HEADERS,
+        },
+        "zh": {
+            "heading": "附录：数据结构与证据",
+            "headers": ("高阶主题", "经验概念", "过程阶段", "案例/参与者", "证据角色", "代表性引文"),
+        },
+        "ru": {
+            "heading": "Приложение: Структура данных и доказательства",
+            "headers": ("Тема высшего порядка", "Эмпирическое понятие", "Этап процесса", "Случай/участник", "Роль доказательства", "Репрезентативная цитата"),
+        },
+        "kk": {
+            "heading": "Қосымша: Деректер құрылымы және дәлелдер",
+            "headers": ("Жоғары деңгейлі тақырып", "Эмпирикалық ұғым", "Процесс кезеңі", "Кейс/қатысушы", "Дәлел рөлі", "Репрезентативті дәйексөз"),
+        },
+    }
+
     ALLOWED_ANALYTIC_DESIGNS = {
         "Process analysis",
         "Comparative case analysis",
@@ -227,38 +254,197 @@ class QualitativeEngine:
 
         return "\n".join(lines).strip()
 
+    @staticmethod
+    def _appendix_target_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"
+
     @classmethod
-    def build_appendix_evidence_md(cls, metadata):
-        """Render the reader-facing qualitative evidence appendix deterministically.
+    def build_appendix_manifest(cls, metadata):
+        """Freeze Appendix row/cell identity before any target-language operation."""
+        rows = []
+        seen = set()
+        for index, item in enumerate((metadata or {}).get("evidence") or [], start=1):
+            if not isinstance(item, dict):
+                continue
+            quote = cls._clean_cell(item.get("quote"), "")
+            if not quote:
+                continue
+            quote_id = str(item.get("tag") or "").strip().upper()
+            if not re.fullmatch(r"QUOTE-\d+", quote_id) or quote_id in seen:
+                return {}
+            seen.add(quote_id)
+            row = {
+                "row_id": quote_id,
+                "quote_id": quote_id,
+                "quote_hash": hashlib.sha256(re.sub(r"\s+", " ", quote).strip().encode("utf-8")).hexdigest(),
+                "theme": cls._clean_cell(item.get("theme"), "Emergent pattern"),
+                "concept": cls._clean_cell(item.get("concept"), "Empirical observation"),
+                "stage": cls._clean_cell(item.get("stage")),
+                "case_label": cls._clean_cell(item.get("case_label")),
+                "evidence_role": cls._clean_cell(
+                    str(item.get("evidence_role") or "typical").strip().lower(), "typical"
+                ),
+                "quote": quote,
+            }
+            rows.append(row)
+        if not rows:
+            return {}
+        manifest = {
+            "version": cls.QUALITATIVE_APPENDIX_MANIFEST_VERSION,
+            "columns": list(cls.APPENDIX_HEADERS),
+            "rows": rows,
+        }
+        manifest["manifest_hash"] = cls.appendix_manifest_hash(manifest)
+        return manifest
 
-        Internal QUOTE identifiers are deliberately omitted. The same frozen
-        quotation literals are reused by the translation ledger, so Findings
-        and Appendix share one target-language rendering per quote.
-        """
-        metadata = metadata or {}
+    @classmethod
+    def appendix_manifest_hash(cls, manifest):
+        record = dict(manifest or {})
+        record.pop("manifest_hash", None)
+        payload = json.dumps(record, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
 
-        def cell(value, default="Not specified"):
-            return cls._clean_cell(value, default).replace("|", r"\|")
+    @classmethod
+    def appendix_translation_cells(cls, manifest):
+        """Return typed non-quote Appendix cells; IDs stay server-side."""
+        cells = {}
+        for row in (manifest or {}).get("rows") or []:
+            if not isinstance(row, dict):
+                continue
+            row_id = str(row.get("row_id") or "").strip()
+            if not row_id:
+                continue
+            for field in cls.APPENDIX_FIELDS:
+                value = cls._clean_cell(row.get(field), "Not specified")
+                cells[f"{row_id}:{field}"] = value
+        return cells
+
+    @staticmethod
+    def _escape_appendix_markdown_cell(value):
+        return re.sub(r"\s+", " ", str(value or "").strip()).replace("|", r"\|")
+
+    @classmethod
+    def _validate_appendix_manifest(cls, manifest):
+        record = dict(manifest or {})
+        if record.get("version") != cls.QUALITATIVE_APPENDIX_MANIFEST_VERSION:
+            return False
+        if list(record.get("columns") or []) != list(cls.APPENDIX_HEADERS):
+            return False
+        rows = [row for row in (record.get("rows") or []) if isinstance(row, dict)]
+        ids = [str(row.get("row_id") or "") for row in rows]
+        quote_ids = [str(row.get("quote_id") or "") for row in rows]
+        if not rows or len(ids) != len(set(ids)) or ids != quote_ids:
+            return False
+        if any(not re.fullmatch(r"QUOTE-\d+", item) for item in ids):
+            return False
+        expected_hash = str(record.get("manifest_hash") or "")
+        return bool(expected_hash) and expected_hash == cls.appendix_manifest_hash(record)
 
+    @classmethod
+    def bind_target_language_appendix(cls, manifest, target_lang, cell_translations, quote_translations):
+        """Render one six-column target Appendix from frozen semantic objects.
+
+        Markdown structure, row identity, column identity, and quote identity are
+        program-owned.  The translation model may supply only ordinary cell
+        surfaces through ``cell_translations``.
+        """
+        if not cls._validate_appendix_manifest(manifest):
+            raise RuntimeError("target_qualitative_appendix_manifest_invalid")
+        expected_cells = cls.appendix_translation_cells(manifest)
+        translations = dict(cell_translations or {})
+        if set(translations) != set(expected_cells):
+            missing = sorted(set(expected_cells) - set(translations))
+            extra = sorted(set(translations) - set(expected_cells))
+            raise RuntimeError(
+                f"target_qualitative_appendix_cell_identity_mismatch:missing={missing[:4]} extra={extra[:4]}"
+            )
+        quote_map = dict(quote_translations or {})
+        required_quotes = {str(row.get("quote_id") or "") for row in manifest.get("rows") or []}
+        missing_quotes = sorted(tag for tag in required_quotes if not str(quote_map.get(tag) or "").strip())
+        if missing_quotes:
+            raise RuntimeError(f"target_qualitative_appendix_quote_identity_missing:{missing_quotes[:6]}")
+
+        code = cls._appendix_target_language_code(target_lang)
+        profile = dict(cls._TARGET_APPENDIX_LOCALIZATION.get(code) or cls._TARGET_APPENDIX_LOCALIZATION["en"])
+        headers = list(profile.get("headers") or cls.APPENDIX_HEADERS)
+        heading = str(profile.get("heading") or cls._TARGET_APPENDIX_LOCALIZATION["en"]["heading"])
         lines = [
-            "| Higher-order Theme | Empirical Concept | Process Stage | Case/Actor | Evidence Role | Representative Quote |",
+            "| " + " | ".join(cls._escape_appendix_markdown_cell(item) for item in headers) + " |",
             "| :--- | :--- | :--- | :--- | :--- | :--- |",
         ]
-        for item in metadata.get("evidence") or []:
-            if not isinstance(item, dict):
-                continue
-            quote = cls._clean_cell(item.get("quote"), "").replace('"', "'")
-            if not quote:
+        for row in manifest.get("rows") or []:
+            row_id = str(row.get("row_id") or "")
+            values = [translations[f"{row_id}:{field}"] for field in cls.APPENDIX_FIELDS]
+            values.append(quote_map[str(row.get("quote_id") or "")])
+            lines.append(
+                "| " + " | ".join(cls._escape_appendix_markdown_cell(value) for value in values) + " |"
+            )
+        rendered = f"# {heading}\n\n" + "\n".join(lines)
+        cls.validate_bound_target_appendix(rendered, manifest, target_lang)
+        return rendered.strip()
+
+    @classmethod
+    def validate_bound_target_appendix(cls, text, manifest, target_lang):
+        """Fail before DOCX packaging if semantic Appendix identity drifted."""
+        if not cls._validate_appendix_manifest(manifest):
+            raise RuntimeError("target_qualitative_appendix_manifest_invalid")
+        code = cls._appendix_target_language_code(target_lang)
+        profile = dict(cls._TARGET_APPENDIX_LOCALIZATION.get(code) or cls._TARGET_APPENDIX_LOCALIZATION["en"])
+        heading = str(profile.get("heading") or "")
+        headers = list(profile.get("headers") or cls.APPENDIX_HEADERS)
+        value = str(text or "")
+        heading_pattern = re.compile(rf"(?m)^#\s+{re.escape(heading)}\s*$")
+        matches = list(heading_pattern.finditer(value))
+        if len(matches) != 1:
+            raise RuntimeError("target_qualitative_appendix_heading_identity_missing_or_ambiguous")
+        tail = value[matches[0].end():]
+        table_blocks = re.findall(r"(?m)(?:^[ \t]*\|[^\n]+\|[ \t]*$\n?)+", tail)
+        valid_blocks = []
+        for block in table_blocks:
+            lines = [line.strip() for line in block.splitlines() if line.strip().startswith("|")]
+            if not lines:
                 continue
+            if all(len(re.findall(r"(?<!\\)\|", line)) == 7 for line in lines):
+                valid_blocks.append(lines)
+        if len(valid_blocks) != 1:
+            raise RuntimeError("target_qualitative_appendix_semantic_table_identity_missing_or_ambiguous")
+        lines = valid_blocks[0]
+        expected_rows = len(manifest.get("rows") or []) + 2
+        if len(lines) != expected_rows:
+            raise RuntimeError(
+                f"target_qualitative_appendix_row_identity_mismatch:expected={expected_rows} got={len(lines)}"
+            )
+        expected_header = "| " + " | ".join(cls._escape_appendix_markdown_cell(item) for item in headers) + " |"
+        if lines[0] != expected_header or not re.fullmatch(
+            r"\|\s*:---\s*\|\s*:---\s*\|\s*:---\s*\|\s*:---\s*\|\s*:---\s*\|\s*:---\s*\|",
+            lines[1],
+        ):
+            raise RuntimeError("target_qualitative_appendix_column_identity_mismatch")
+        if re.search(r"\bQUOTE-\d+\b", "\n".join(lines), flags=re.I):
+            raise RuntimeError("target_qualitative_appendix_internal_quote_id_leak")
+        return True
+
+    @classmethod
+    def build_appendix_evidence_md(cls, metadata):
+        """Render the reader-facing English Appendix from the same frozen manifest."""
+        manifest = cls.build_appendix_manifest(metadata)
+        if not cls._validate_appendix_manifest(manifest):
+            raise RuntimeError("qualitative_appendix_manifest_invalid")
+        lines = [
+            "| " + " | ".join(cls.APPENDIX_HEADERS) + " |",
+            "| :--- | :--- | :--- | :--- | :--- | :--- |",
+        ]
+        for row in manifest.get("rows") or []:
+            values = [row.get(field) for field in cls.APPENDIX_FIELDS] + [f'"{row.get("quote")}"']
             lines.append(
-                "| {theme} | {concept} | {stage} | {case_label} | {role} | \"{quote}\" |".format(
-                    theme=cell(item.get("theme"), "Emergent pattern"),
-                    concept=cell(item.get("concept"), "Empirical observation"),
-                    stage=cell(item.get("stage")),
-                    case_label=cell(item.get("case_label")),
-                    role=cell(str(item.get("evidence_role") or "typical").strip().lower(), "typical"),
-                    quote=quote.replace("|", r"\|"),
-                )
+                "| " + " | ".join(cls._escape_appendix_markdown_cell(value) for value in values) + " |"
             )
         return "\n".join(lines).strip()