eduevidence 6.0.0 → 6.3.0

package/visualization/eduevidence-report/scripts/build_report.py

@@ -37,7 +37,7 @@ from typing import Any
 from build_charts import build_all as build_chart_specs, effect_outcomes
 from build_figures import build_figure_data, render_figures, render_lieflat_gallery
 from build_infographics import build_all as build_infographics
-from lieflat_engine import REGISTRY as LIEFLAT_REGISTRY, LEGACY_TYPES, ACADEMIC_FIGURE_KEYS
+from lieflat_engine import REGISTRY as LIEFLAT_REGISTRY, ACADEMIC_FIGURE_KEYS
 from zh_labels import label
 
 THEMES_DIR = Path(__file__).resolve().parent.parent / "themes"
@@ -65,56 +65,21 @@ DATA_ORIGIN_LABELS = {
 # Full report is intentionally NOT a fixed 12-chapter template. The template exposes
 # semantic modules; an upstream AI may group them into any 5–7 chapter outline by writing
 # `report_outline.chapters`. If it does not, a six-chapter fallback keeps the report usable.
-FULL_REPORT_MODULES = (
-    "decision", "scope", "retrieval", "outcomes", "evidence", "quality", "conflicts",
-    "trace", "applicability", "intervention", "evaluation", "sources",
+# Domain copy packs (domains/<id>/copy/) — UI 词典 + 域文案, see report_copy_pack.py.
+from report_copy_pack import (  # noqa: E402
+    FULL_REPORT_MODULES,
+    activate_copy_pack,
+    brief_block_titles,
+    build_ui,
+    default_full_report_plan,
+    default_leads,
+    evidence_detail_label_table,
+    frame_enum_table,
+    methodology_label_table,
+    outcome_group_map,
+    scope_field_labels,
+    scope_subfield_labels,
 )
-DEFAULT_FULL_REPORT_PLAN = (
-    {"key": "decision", "title_zh": "结论、裁决与研究边界", "title_en": "Decision, Adjudication & Research Boundary",
-     "modules": ("decision", "scope")},
-    {"key": "evidence", "title_zh": "关键证据与结果分离", "title_en": "Key Evidence & Outcome Separation",
-     "modules": ("retrieval", "outcomes", "evidence")},
-    {"key": "quality", "title_zh": "证据可信度、反证与方法审计", "title_en": "Evidence Quality, Counterevidence & Method Audit",
-     "modules": ("quality", "conflicts", "trace")},
-    {"key": "action", "title_zh": "适用范围与教学行动", "title_en": "Applicability & Teaching Action",
-     "modules": ("applicability", "intervention")},
-    {"key": "evaluation", "title_zh": "试点设计、评估与停止条件", "title_en": "Pilot, Evaluation & Stop Conditions",
-     "modules": ("evaluation",)},
-    {"key": "sources", "title_zh": "来源、溯源与附录", "title_en": "Sources, Traceability & Appendix",
-     "modules": ("sources",)},
-)
-
-METHODOLOGY_LABELS_ZH = {
-    "control_group": "对照组", "randomization": "随机分配", "pre_test": "前测",
-    "post_test": "后测", "retention_test": "保持测试", "transfer_test": "迁移测试",
-    "sample_bias": "样本偏差", "self_selection": "自我选择偏差",
-    "measurement_validity": "测量效度", "confounders": "混杂因素",
-    "instructor_effect": "教师效应", "novelty_effect": "新奇效应",
-    "tool_version_effect": "工具版本效应", "ai_usage_policy": "AI 使用规则",
-    "dropout": "样本流失",
-}
-
-FRAME_ENUM_ZH = {
-    "teaching_decision": "教学决策",
-    "undergraduate_year_1": "大学一年级",
-    "computer_science": "计算机科学与技术",
-    "C_programming": "C 语言程序设计",
-    "compulsory_core_course": "必修核心课程",
-    "primary": "主要结果",
-    "secondary": "次要结果",
-    "risk": "风险结果",
-}
-
-FRAME_ENUM_EN = {
-    "teaching_decision": "Teaching decision",
-    "undergraduate_year_1": "First-year undergraduate",
-    "computer_science": "Computer science",
-    "C_programming": "C programming",
-    "compulsory_core_course": "Compulsory core course",
-    "primary": "Primary outcomes",
-    "secondary": "Secondary outcomes",
-    "risk": "Risk outcomes",
-}
 
 DIR_LABEL = {"support": "支持", "contradict": "反驳", "neutral": "中性"}
 DIR_CLASS = {"support": "pos", "contradict": "neg", "neutral": "neu"}
@@ -125,359 +90,6 @@ EFFECT_CLASS = {"positive": "pos", "negative": "neg", "null": "neu", "neutral":
 # 双语 UI 文案
 # ---------------------------------------------------------------------------
 
-UI_ZH = {
-    "theme_label": "主题",
-    "lang_label": "语言",
-    "zh": "中文",
-    "en": "EN",
-    "visual_brief": "可视化摘要",
-    "full_report": "完整报告",
-    "contents": "目录",
-    "collapse_contents": "收起目录",
-    "expand_contents": "展开目录",
-    "expand_evidence": "查看完整证据",
-    "expand_methodology": "查看审计依据",
-    "expand_source": "查看来源与溯源",
-    "expand_details": "展开完整说明",
-    "what_this_means": "这意味着什么",
-    "original_title": "原文标题",
-    "original_text": "原文",
-    "full_report_intro": "结论前置：全部可追溯证据与方法学细节都在这里，关键论证位置穿插有意义的可视化，每个数字都能回查到 result.json。",
-    "section_titles": {
-        "01": "01 执行决策", "02": "02 结果证据概览", "03": "03 证据矩阵",
-        "04": "04 证据裁决", "05": "05 方法学审计", "06": "06 冲突分析",
-        "07": "07 主张-证据追溯", "08": "08 适用性", "09": "09 教学干预",
-        "10": "10 评价方案", "11": "11 基准测试", "12": "12 来源与溯源",
-    },
-    "section_leads": {
-        "01": "本节先给结论：最终怎么裁决、置信度多高、靠哪几条证据。",
-        "02": "一图看清：哪些学习结果有支持证据、哪些被反驳。",
-        "03": "每条证据来自哪项研究、测了什么、方向与质量如何；可筛选、可搜索。",
-        "04": "证据允许主张什么、不允许主张什么；缺失的关键证据是什么。",
-        "05": "研究质量可靠吗？哪些方法学问题让结论打折。",
-        "06": "不同研究为何结论不同；分歧出在哪一环。",
-        "07": "从结论到证据到原始来源，每一步都可追查。",
-        "08": "结论适用于谁、什么课程与结果、需要什么条件。",
-        "09": "试点怎么分阶段放开 AI 规则；什么情况必须叫停。",
-        "10": "如何验证效果：指标、对照、成功阈值。",
-        "11": "EduEvidence 自身基准表现：引用精度与成本。",
-        "12": "每篇文献是谁、出自哪里、如何获取。",
-    },
-    "decision_kpi": ["决策", "置信度", "证据最充分的结果", "最不确定的结果", "主要风险", "来源数量"],
-    "summary_title": "一句话结论",
-    "summary_question": "问题",
-    "summary_evidence": "依据",
-    "summary_action": "行动",
-    "outcome_table": ["结果类型", "正向效应", "负向效应", "零效应", "证据"],
-    "figure1_caption": "图 1. 各结果类型的正向 / 负向 / 零效应证据数量（基于 effect_direction，不等同于 Claim 是否被支持）。",
-    "matrix_filter": "筛选 / 搜索",
-    "matrix_search_ph": "搜索证据…",
-    "matrix_all_dir": "全部效应",
-    "matrix_all_outcome": "全部结果",
-    "matrix_heads": ["ID", "结果", "效应", "质量", "主张", "来源"],
-    "matrix_details": "查看完整证据",
-    "matrix_detail_labels": ["研究标题", "研究设计", "人群", "干预", "直接性"],
-    "matrix_source_missing": "无可验证来源",
-    "hero_action": "建议决策",
-    "hero_confidence": "置信度",
-    "hero_supported": "最强支持结论",
-    "hero_uncertain": "关键不确定性 / 反例",
-    "hero_risk": "主要风险",
-    "hero_next": "下一步",
-    "hero_provenance": "证据 / 来源",
-    "outcome_separation_title": "结果分离 · 任务表现 ≠ 学习效果",
-    "effect_positive": "正向效应",
-    "effect_negative": "负向效应",
-    "effect_null": "零效应",
-    "outcome_group_task": "任务 / 近端表现",
-    "outcome_group_learning": "学习 / 保持 / 迁移",
-    "outcome_group_risk": "风险 / 依赖",
-    "outcome_group_other": "其他结果",
-    "outcome_sep_note": "将不同结果类型分开裁决，避免把训练时更快、更高分直接等同于真正学会。",
-    "tribunal_decision": "决策",
-    "tribunal_confidence": "置信度",
-    "tribunal_can": "可以主张",
-    "tribunal_uncertain": "尚不能主张",
-    "tribunal_cannot": "被反驳的主张",
-    "tribunal_missing": "缺失证据",
-    "tribunal_flow": "EvidenceFlow 协议",
-    "tribunal_figure": "裁决信息图",
-    "method_audit_heads": ["检查项", "状态", "说明"],
-    "method_guard": "任务 vs 学习护栏",
-    "conflict_verdict": "裁决说明",
-    "trace_decision": "决策",
-    "trace_claim_prefix": "主张",
-    "trace_no_source": "无来源",
-    "applicability": ["适用于谁", "适用课程", "适用结果", "适用条件", "目标人群", "目标情境"],
-    "intervention_learners": "目标学习者",
-    "intervention_duration": "试点时长",
-    "intervention_policy": "AI 使用规则",
-    "intervention_rule": "AI 规则",
-    "intervention_activities": "活动",
-    "intervention_check": "结果检查",
-    "intervention_stop": "停止条件",
-    "intervention_timeline": "干预时间线信息图",
-    "evaluation_question": "研究问题",
-    "evaluation_measures": ["基线", "后测", "保持测试", "迁移测试"],
-    "evaluation_metrics": ["过程指标", "学习指标", "风险指标"],
-    "evaluation_threshold": "成功阈值",
-    "evaluation_plan": "分析计划",
-    "evaluation_figure": "评价设计信息图",
-    "benchmark_note": "result.json 未携带 benchmark.baselines，本图不绘制；基准表现见独立基准报告。",
-    "sources_title": "来源列表",
-    "sources_heads": ["ID", "标题", "年份", "权威级别", "可验证位置"],
-    "provenance_title": "Fetch 溯源",
-    "provenance_heads": ["来源", "Fetch 方式", "状态", "降级", "时间"],
-    "provenance_search": "搜索提供方",
-    "provenance_time": "检索时间",
-    "provenance_empty": "无逐条 fetch 记录（来源由研究管线直接提供）。",
-    "no_data": "无数据。",
-    "header_evidence": "证据 ",
-    "header_sources": "来源 ",
-    "header_mode": "模式：",
-    "header_generated": "生成时间：",
-    "header_evidence_suffix": " 条",
-    "header_sources_suffix": " 个",
-    "footer_schema": "Schema",
-    "footer_claims": "Claim Binding",
-    "footer_numbers": "Numeric Consistency",
-    "footer_bilingual": "Bilingual Structure",
-    "footer_language": "语言人话化",
-    "footer_no_false_precision": "无伪精度",
-    "footer_lieflat_bound": "Lieflat 数据溯源",
-    "footer_no_axis_distortion": "坐标轴无失真",
-    "footer_colorblind_safe": "色盲安全",
-    "footer": "EduEvidence 证据报告 · {integrity} · 单文件离线可打开 · 数据源：result.json",
-    "matrix_search_label": "筛选 / 搜索证据",
-    "matrix_dir_filter": "按效应方向筛选",
-    "matrix_outcome_filter": "按结果类型筛选",
-    "svg_balance_title": "各结果类型证据效应分布",
-    "svg_balance_desc": "各结果类型的正向 / 负向 / 零效应证据条数（基于 effect_direction，不等同于 Claim 是否被支持）。",
-    "svg_figure1_title": "各结果类型效应方向分布（出版级学术图）",
-    "svg_figure1_desc": "各结果类型的正向 / 负向 / 零效应证据条数；计数轴整数刻度，不随主题变化。来源：EduEvidence result.json。",
-    "svg_benchmark_title": "基准对比：各基线引用支持精度",
-    "svg_benchmark_desc": "各基线的引用支持精度（Citation support precision）对比；无基准数据时不绘制。",
-    "svg_workflow_title": "EvidenceFlow 协议流程",
-    "svg_workflow_desc": "从问题框架、检索、抓取验证、证据抽取、反方质疑、方法审计、裁决到适用性与干预评价的完整流程。",
-    "svg_tribunal_title": "证据裁决信息图",
-    "svg_tribunal_desc": "可以主张与不可主张的证据 ID 与建议决策徽章；完整主张文本见下方裁决卡片。",
-    "svg_intervention_title": "教学干预时间线",
-    "svg_intervention_desc": "各试点阶段的短名称与活动数量；完整 AI 使用规则见阶段说明块。",
-    "svg_evaluation_title": "评价设计流程",
-    "svg_evaluation_desc": "基线、后测、保持测试与迁移测试的评价流程；完整指标与分析计划见评估章节。",
-    "raw_tag_title": "原始标识",
-    "summary_tag_support": "支持",
-    "summary_tag_contradict": "反驳",
-    "summary_confidence_prefix": "（置信度：",
-    "summary_confidence_suffix": "）",
-    "method_target": "审查目标",
-    "applicability_not_suitable": "不适用于",
-    "applicability_conditions": "适用条件",
-    "trace_claim_sep": "：",
-    "colon": "：",
-    "lang_switcher_aria": "语言切换 / Language switch",
-    "theme_switcher_aria": "主题 / Theme",
-    "v2_project_title": "项目与研究历史",
-    "v2_project_id": "项目 ID",
-    "v2_graph_revision": "证据图版本",
-    "v2_decision_snapshot": "决策快照",
-    "v2_timeline": "项目时间线",
-    "v2_gaps_title": "知识缺口",
-    "v2_gap_type": "缺口类型",
-    "v2_gap_priority": "优先级",
-    "v2_gap_reasoning": "依据",
-    "v2_design_title": "研究设计",
-    "v2_design_type": "设计类型",
-    "v2_design_question": "研究问题",
-    "v2_provenance_title": "数据集与分析溯源",
-    "v2_diff_title": "决策变更",
-    "v2_diff_action": "决策动作",
-    "v2_diff_confidence": "置信度",
-    "v2_diff_claims": "变更的主张",
-    "v2_diff_gaps": "已解决/新增缺口",
-    "v2_revision": "版本",
-    "v2_decision": "决策",
-    "v2_no_v2_data": "（无 V2 项目数据）",
-}
-
-UI_EN = {
-    "theme_label": "Theme",
-    "lang_label": "Language",
-    "zh": "中文",
-    "en": "EN",
-    "visual_brief": "Visual Brief",
-    "full_report": "Full Report",
-    "contents": "Contents",
-    "collapse_contents": "Collapse contents",
-    "expand_contents": "Expand contents",
-    "expand_evidence": "View full evidence",
-    "expand_methodology": "View audit rationale",
-    "expand_source": "View source & provenance",
-    "expand_details": "Expand full explanation",
-    "what_this_means": "What this means",
-    "original_title": "Original title",
-    "original_text": "Original text",
-    "full_report_intro": "Conclusions first: every traceable piece of evidence and method note lives here, with visuals only at points where they add meaning. Every number traces back to result.json.",
-    "section_titles": {
-        "01": "01 Executive Decision", "02": "02 Outcome Evidence Overview",
-        "03": "03 Evidence Matrix", "04": "04 Evidence Tribunal",
-        "05": "05 Methodology Audit", "06": "06 Conflict Analysis",
-        "07": "07 Claim-Evidence Trace", "08": "08 Applicability",
-        "09": "09 Teaching Intervention", "10": "10 Evaluation Plan",
-        "11": "11 Benchmark", "12": "12 Sources & Provenance",
-    },
-    "section_leads": {
-        "01": "The verdict first: what we decide, at what confidence, on which evidence.",
-        "02": "At a glance: which learning outcomes have supporting evidence, which are contradicted.",
-        "03": "Where each piece of evidence comes from, what it measures, its direction and quality — filterable and searchable.",
-        "04": "What the evidence lets us claim, what it does not, and what is still missing.",
-        "05": "How reliable are these studies, and which methodological concerns discount the conclusions.",
-        "06": "Why studies disagree — and where exactly they diverge.",
-        "07": "Every step from conclusion to evidence to source stays traceable.",
-        "08": "Who the conclusion applies to, for which course and outcomes, under what conditions.",
-        "09": "How AI usage rules phase in during a pilot, and when we must stop.",
-        "10": "How we verify real effects: metrics, comparison, success threshold.",
-        "11": "How EduEvidence itself performs: citation precision and cost.",
-        "12": "Who wrote each cited study, where it came from, how it was fetched.",
-    },
-    "decision_kpi": ["Decision", "Confidence", "Best-supported outcome", "Most uncertain outcome", "Main risk", "Sources"],
-    "summary_title": "Bottom line",
-    "summary_question": "Question",
-    "summary_evidence": "Evidence",
-    "summary_action": "Action",
-    "outcome_table": ["Outcome", "Positive effect", "Negative effect", "Null effect", "Evidence"],
-    "figure1_caption": "Fig. 1. Positive / negative / null effect counts per outcome (based on effect_direction, not claim support).",
-    "matrix_filter": "Filter / Search",
-    "matrix_search_ph": "Search evidence…",
-    "matrix_all_dir": "All effects",
-    "matrix_all_outcome": "All outcomes",
-    "matrix_heads": ["ID", "Outcome", "Effect", "Quality", "Claim", "Source"],
-    "matrix_details": "View full evidence",
-    "matrix_detail_labels": ["Study title", "Design", "Population", "Intervention", "Directness"],
-    "matrix_source_missing": "No verifiable source",
-    "hero_action": "Recommended decision",
-    "hero_confidence": "Confidence",
-    "hero_supported": "Strongest supported conclusion",
-    "hero_uncertain": "Key uncertainty / contradiction",
-    "hero_risk": "Main risk",
-    "hero_next": "Next action",
-    "hero_provenance": "Evidence / sources",
-    "outcome_separation_title": "Outcome Separation · Task performance ≠ learning",
-    "effect_positive": "Positive effect",
-    "effect_negative": "Negative effect",
-    "effect_null": "Null effect",
-    "outcome_group_task": "Task / proximal performance",
-    "outcome_group_learning": "Learning / retention / transfer",
-    "outcome_group_risk": "Risk / dependency",
-    "outcome_group_other": "Other outcomes",
-    "outcome_sep_note": "Outcomes are adjudicated separately so faster training performance is not silently treated as evidence of learning.",
-    "tribunal_decision": "Decision",
-    "tribunal_confidence": "Confidence",
-    "tribunal_can": "Can claim",
-    "tribunal_uncertain": "Cannot yet claim",
-    "tribunal_cannot": "Contradicted claims",
-    "tribunal_missing": "Missing evidence",
-    "tribunal_flow": "EvidenceFlow Protocol",
-    "tribunal_figure": "Tribunal infographic",
-    "method_audit_heads": ["Item", "Status", "Note"],
-    "method_guard": "Task vs learning guard",
-    "conflict_verdict": "Tribunal note",
-    "trace_decision": "Decision",
-    "trace_claim_prefix": "Claim",
-    "trace_no_source": "No source",
-    "applicability": ["Suitable for", "Course", "Outcomes", "Conditions", "Target population", "Target context"],
-    "intervention_learners": "Target learners",
-    "intervention_duration": "Pilot duration",
-    "intervention_policy": "AI usage policy",
-    "intervention_rule": "AI rule",
-    "intervention_activities": "Activities",
-    "intervention_check": "Outcome check",
-    "intervention_stop": "Stop conditions",
-    "intervention_timeline": "Intervention timeline infographic",
-    "evaluation_question": "Research question",
-    "evaluation_measures": ["Baseline", "Post test", "Retention", "Transfer"],
-    "evaluation_metrics": ["Process metrics", "Learning metrics", "Risk metrics"],
-    "evaluation_threshold": "Success threshold",
-    "evaluation_plan": "Analysis plan",
-    "evaluation_figure": "Evaluation design infographic",
-    "benchmark_note": "result.json carries no benchmark.baselines, so this visual is omitted; see the standalone benchmark report.",
-    "sources_title": "Source list",
-    "sources_heads": ["ID", "Title", "Year", "Authority", "Verifiable location"],
-    "provenance_title": "Fetch provenance",
-    "provenance_heads": ["Source", "Fetch method", "Status", "Fallback", "Time"],
-    "provenance_search": "Search provider",
-    "provenance_time": "Fetched at",
-    "provenance_empty": "No per-source fetch records (sources provided directly by the research pipeline).",
-    "no_data": "No data.",
-    "header_evidence": "Evidence: ",
-    "header_sources": "Sources: ",
-    "header_mode": "Mode: ",
-    "header_generated": "Generated: ",
-    "header_evidence_suffix": "",
-    "header_sources_suffix": "",
-    "footer_schema": "Schema",
-    "footer_claims": "Claim Binding",
-    "footer_numbers": "Numeric Consistency",
-    "footer_bilingual": "Bilingual Structure",
-    "footer_language": "Human Language",
-    "footer_no_false_precision": "False Precision",
-    "footer_lieflat_bound": "Lieflat Data Bound",
-    "footer_no_axis_distortion": "Axis Distortion",
-    "footer_colorblind_safe": "Colorblind Safe",
-    "footer": "EduEvidence Evidence Report · {integrity} · single-file offline · source: result.json",
-    "matrix_search_label": "Filter / search evidence",
-    "matrix_dir_filter": "Filter by effect direction",
-    "matrix_outcome_filter": "Filter by outcome type",
-    "svg_balance_title": "Outcome evidence effect balance",
-    "svg_balance_desc": "Positive / negative / null effect counts per outcome (based on effect_direction, not claim support).",
-    "svg_figure1_title": "Effect direction by outcome type (publication figure)",
-    "svg_figure1_desc": "Counts of positive / negative / null effects per outcome type with an integer count axis, theme-independent. Source: EduEvidence result.json.",
-    "svg_benchmark_title": "Benchmark: citation support precision by baseline",
-    "svg_benchmark_desc": "Citation support precision per baseline; not drawn when no baseline data exists.",
-    "svg_workflow_title": "EvidenceFlow Protocol",
-    "svg_workflow_desc": "Research flow from framing, retrieval, fetch/verify, extraction, challenge, method audit and adjudication to applicability and intervention evaluation.",
-    "svg_tribunal_title": "Evidence Tribunal infographic",
-    "svg_tribunal_desc": "Evidence IDs for claims that can and cannot be claimed, plus the recommended action badge; full claim text is in the tribunal cards below.",
-    "svg_intervention_title": "Teaching intervention timeline",
-    "svg_intervention_desc": "Short phase names and activity counts; full AI usage rules are in the phase blocks.",
-    "svg_evaluation_title": "Evaluation design flow",
-    "svg_evaluation_desc": "Evaluation flow across baseline, post test, retention and transfer; full metrics and analysis plan are in the evaluation section.",
-    "raw_tag_title": "raw id",
-    "summary_tag_support": "Support",
-    "summary_tag_contradict": "Contradict",
-    "summary_confidence_prefix": " (confidence: ",
-    "summary_confidence_suffix": ")",
-    "method_target": "Audit target",
-    "applicability_not_suitable": "Not suitable for",
-    "applicability_conditions": "Conditions",
-    "trace_claim_sep": ": ",
-    "colon": ": ",
-    "lang_switcher_aria": "语言切换 / Language switch",
-    "theme_switcher_aria": "主题 / Theme",
-    "v2_project_title": "Project & Research History",
-    "v2_project_id": "Project ID",
-    "v2_graph_revision": "Graph revision",
-    "v2_decision_snapshot": "Decision snapshot",
-    "v2_timeline": "Project timeline",
-    "v2_gaps_title": "Knowledge gaps",
-    "v2_gap_type": "Gap type",
-    "v2_gap_priority": "Priority",
-    "v2_gap_reasoning": "Reasoning",
-    "v2_design_title": "Study design",
-    "v2_design_type": "Design type",
-    "v2_design_question": "Research question",
-    "v2_provenance_title": "Dataset & analysis provenance",
-    "v2_diff_title": "Decision diff",
-    "v2_diff_action": "Decision action",
-    "v2_diff_confidence": "Confidence",
-    "v2_diff_claims": "Changed claims",
-    "v2_diff_gaps": "Resolved/new gaps",
-    "v2_revision": "Revision",
-    "v2_decision": "Decision",
-    "v2_no_v2_data": "(no V2 project data)",
-}
-
-
 class ReportInvalid(Exception):
     """Scientific Integrity Gate failure (§27/§60): report must not be published."""
 
@@ -489,7 +101,7 @@ def esc(text: Any) -> str:
 def _svg_a11y(svg: str, title: str, desc: str) -> str:
     """6.5: 为嵌入的 SVG 注入双语 <title>/<desc>，并把 aria-label 换成 UI 字典文案。
 
-    title/desc 由调用方按当前语言从 UI_ZH / UI_EN 取；aria-label 已存在时覆盖，
+    title/desc 由调用方按当前语言从 build_ui() 取；aria-label 已存在时覆盖，
     不存在时补上，保证英文模式下不残留中文 aria-label。
     """
     if not svg:
@@ -640,39 +252,135 @@ def visualization_decisions(result: dict, charts: dict) -> dict[str, dict[str, A
 # 0b. Lieflat gallery composition — visual_layout contract (§三)
 # ---------------------------------------------------------------------------
 
-# Deterministic safe combination when visual_layout is missing or all entries
-# are invalid. Rendered through the same extractors as any AI-written layout.
-FALLBACK_LIEFLAT_LAYOUT = (
-    {"chart_id": "lieflat-forest-plot.svg", "type": "forest_plot", "catalog_ref": "FOREST-PLOT (publication figure)",
-     "title_zh": "证据效应量森林图", "title_en": "Effect-size forest plot",
-     "subtitle_zh": "Hedges' g 与 95% 置信区间 · 一行一篇研究 · 数据不足时本图自动抑制",
-     "subtitle_en": "Hedges' g with 95% CI · one row per study · suppressed when data is insufficient",
-     "caption_zh": "仅当证据集携带数值效应量时绘制；无 g/CI 数据时不画假图。",
-     "caption_en": "Drawn only when numeric effect sizes exist in the evidence set.",
-     "source": "meta.forest", "params": {}},
-    {"chart_id": "lieflat-dot-cascade.svg", "type": "dot_cascade", "catalog_ref": "L2 Dot Cascade",
-     "title_zh": "证据效应量梯队级联", "title_en": "Ranked effect-size cascade",
-     "subtitle_zh": "按效应量由高到低排序 · 圆点高度 = Hedges' g · 顶部数字 = g 值",
-     "subtitle_en": "Sorted by effect size · dot height = Hedges' g · top number = g",
-     "caption_zh": "仅当存在逐研究数值效应量时绘制。",
-     "caption_en": "Drawn only when per-study numeric effect sizes exist.",
-     "source": "evidence.ranked_effects", "params": {}},
-    {"chart_id": "lieflat-bubble-almanac.svg", "type": "bubble_almanac", "catalog_ref": "L9 Bubble Almanac",
-     "title_zh": "发表年份 × 结果维度文献年历", "title_en": "Year × dimension evidence almanac",
-     "subtitle_zh": "气泡面积 ∝ 该格研究数（sqrt 换算） · 实心圆 = 有显著结果",
-     "subtitle_en": "Bubble area ∝ study count (sqrt) · solid core = significant results",
-     "caption_zh": "仅当证据集携带发表年份与结果维度时绘制。",
-     "caption_en": "Drawn only when years and outcome dimensions exist.",
-     "source": "evidence.year_x_dimension", "params": {}},
-    {"chart_id": "lieflat-tick-rows.svg", "type": "tick_rows", "catalog_ref": "F5 Tick Rows",
-     "title_zh": "各结果类型效应方向分布", "title_en": "Effect direction by outcome",
-     "subtitle_zh": "每 1 个圆点 = 1 条证据 · 绿 = 正向 · 灰 = 零效应 · 橙 = 负向 · 右端数字 = 净效应",
-     "subtitle_en": "One dot = one evidence item · green = positive · grey = null · orange = negative · right number = net",
-     "caption_zh": "基于 effect_direction 计数，全部数值来自 result.json。",
-     "caption_en": "Based on effect_direction counts; all numbers come from result.json.",
-     "source": "outcomes.direction_counts", "params": {}},
+# Deterministic fallback when visual_layout is missing or all entries are
+# invalid. The composition is DATA-DRIVEN: instead of a fixed quartet that
+# silently suppresses most charts on an evidence set without numeric effect
+# sizes, candidates are probed against the extractors and only the shapes the
+# data actually supports are kept. Numbers still come exclusively from
+# scripts/charts_data.py, so this remains an honest gallery.
+FALLBACK_CANDIDATES = (
+    ("forest_plot", ("证据效应量森林图", "Effect-size forest plot",
+                    "Hedges' g 与 95% 置信区间 · 一行一篇研究",
+                    "Hedges' g with 95% CI · one row per study",
+                    "仅当证据集携带数值效应量时绘制；无 g/CI 数据时不画假图。",
+                    "Drawn only when numeric effect sizes exist in the evidence set.")),
+    ("dot_cascade", ("证据效应量梯队级联", "Ranked effect-size cascade",
+                     "按效应量由高到低排序 · 圆点高度 = Hedges' g",
+                     "Sorted by effect size · dot height = Hedges' g",
+                     "仅当存在逐研究数值效应量时绘制。",
+                     "Drawn only when per-study numeric effect sizes exist.")),
+    ("bubble_almanac", ("发表年份 × 结果维度文献年历", "Year × dimension evidence almanac",
+                        "气泡面积 ∝ 该格研究数 · 实心圆 = 有显著结果",
+                        "Bubble area ∝ study count · solid core = significant results",
+                        "仅当证据集携带发表年份与结果维度时绘制。",
+                        "Drawn only when years and outcome dimensions exist.")),
+    ("matrix_heat", ("年份 × 结果维度证据密度", "Year × outcome evidence density",
+                     "每格数字 = 该年份该结果维度的证据条数",
+                     "Each cell counts evidence items for that year and outcome",
+                     "当证据跨多个年份与结果维度时，展示研究密度的分布。",
+                     "Shows where the evidence sits across years and outcomes.")),
+    ("tick_rows", ("各结果类型效应方向分布", "Effect direction by outcome",
+                   "每 1 个圆点 = 1 条证据 · 绿 = 正向 · 灰 = 零效应 · 橙 = 负向",
+                   "One dot = one evidence item · green = positive · grey = null · orange = negative",
+                   "基于 effect_direction 计数，全部数值来自 result.json。",
+                   "Based on effect_direction counts; all numbers come from result.json.")),
+    ("paired_rungs", ("各结果类型的正负证据对照", "Positive vs negative evidence by outcome",
+                      "左右两列分别汇总正向与负向证据条数",
+                      "Two columns summarise positive and negative evidence counts",
+                      "当同一结果同时存在正向与负向证据时，分列呈现避免相互抵消。",
+                      "Splits positive and negative evidence so they never cancel out.")),
+    ("brand_spectrum", ("各结果类型的净效应倾向", "Net effect direction by outcome",
+                        "位置 =（正向 − 负向）÷ 方向计数 · 中点为中性",
+                        "Position = (positive - negative) / directional count · centre is neutral",
+                        "双极展示各结果构念整体偏向支持还是反对。",
+                        "Bipolar view of whether each outcome leans supportive or against.")),
+    ("hundred_field", ("研究设计构成", "Study-design composition",
+                       "每格 = 1 篇研究 · 显示证据来自哪些研究设计",
+                       "One cell = one study · shows which designs produced the evidence",
+                       "当证据包含多种研究设计时，构成图比表格更快暴露设计偏斜。",
+                       "Reveals design skew faster than a table when several designs are present.")),
+    ("tick_donut", ("方法学评级构成", "Methodology rating composition",
+                    "每 tick ≈ 1% 构成 · 按 WWC 评级汇总",
+                    "One tick ~ 1% share · aggregated by WWC rating",
+                    "仅当证据集记录 WWC 评级时绘制。",
+                    "Drawn only when WWC ratings are recorded.")),
+    ("tick_gauge", ("决策置信度", "Decision confidence",
+                    "0–100% 单值仪表 · 由确定性置信度公式给出",
+                    "Single 0-100% gauge from the deterministic confidence formula",
+                    "置信度值来自 result.json 的决策字段，不由模型自评。",
+                    "The value comes from the result's decision field, never self-rated.")),
+    ("ballot_tally", ("方法学检查项计票", "Methodology checklist tally",
+                      "每 tick = 1 条审计结论 · 按检查项统计通过与否",
+                      "One tick = one audit verdict · grouped by checklist item",
+                      "让读者一眼看出方法学短板集中在哪些检查项。",
+                      "Shows which checklist items concentrate the weaknesses.")),
+    ("launch_fan", ("干预阶段与活动权重", "Intervention phases and activity weight",
+                    "每段 = 一个试点阶段 · 宽度 = 活动条数",
+                    "Each segment is one pilot phase · width = number of activities",
+                    "展示试点在时间上的铺开方式。",
+                    "Shows how the pilot is spread across its phases.")),
+    ("barcode_lollipop", ("试点阶段周次分布", "Pilot phase week spans",
+                          "每根 = 一个阶段 · 高度 = 阶段序号",
+                          "One bar per phase · height = phase index",
+                          "仅当阶段定义包含可解析的周次区间时绘制。",
+                          "Drawn only when phases carry parseable week ranges.")),
+    ("dotty_matrix", ("阶段 × 活动矩阵", "Phase × activity matrix",
+                      "每点 = 1 项活动 · 行 = 阶段",
+                      "One dot = one activity · rows are phases",
+                      "当阶段内含多项活动时，矩阵比列表更易比较。",
+                      "Compares activity load across phases better than a list.")),
+    ("jitter_strip", ("分组效应量分布", "Grouped effect-size distribution",
+                      "每点 = 一篇研究 · 按结果维度分组",
+                      "One point = one study · grouped by outcome dimension",
+                      "仅当多个结果维度各有 3 篇以上带效应量的研究时绘制。",
+                      "Drawn only when several dimensions each carry 3+ numeric effects.")),
+    ("parallel_coordinates", ("跨维度研究画像", "Studies across dimensions",
+                              "同一批研究在效应量 / 样本量 / 质量 / 年份上的走势",
+                              "The same studies traced across effect size / N / quality / year",
+                              "仅当至少 3 篇研究同时具备四项数值时绘制。",
+                              "Drawn only when at least 3 studies carry all four values.")),
 )
 
+
+def _fallback_layout_for(result: dict, lang: str) -> list[dict]:
+    """Probe the registry and keep only the chart shapes this result supports.
+
+    ``visual_layout`` is the AI's job; when it is absent this keeps the gallery
+    useful without inventing anything: every candidate runs through its own
+    extractor, and a candidate whose data is missing is simply not offered.
+    One chart per data source avoids repeating the same shape twice.
+    """
+    from lieflat_engine import REGISTRY
+
+    chosen: list[dict] = []
+    used_sources: set[str] = set()
+    for fig_type, copy in FALLBACK_CANDIDATES:
+        reg = REGISTRY.get(fig_type)
+        if reg is None or reg["source"] in used_sources:
+            continue
+        try:
+            bundle, _reason = reg["extractor"](result, {}, lang)
+        except Exception:
+            bundle = None
+        if bundle is None:
+            continue
+        used_sources.add(reg["source"])
+        title_zh, title_en, sub_zh, sub_en, cap_zh, cap_en = copy
+        chosen.append({
+            "chart_id": "lieflat-" + fig_type.replace("_", "-") + ".svg",
+            "type": fig_type,
+            "catalog_ref": reg["catalog_ref"],
+            "source": reg["source"],
+            "params": {},
+            "title_zh": title_zh, "title_en": title_en,
+            "subtitle_zh": sub_zh, "subtitle_en": sub_en,
+            "caption_zh": cap_zh, "caption_en": cap_en,
+        })
+        if len(chosen) >= 6:
+            break
+    return chosen
+
+
 LIEFLAT_PARAM_TYPES = {"int": int, "list": list}
 
 
@@ -794,9 +502,18 @@ def resolve_visual_layout(result: dict) -> dict[str, Any]:
     if entries:
         return {"entries": entries, "fallback": False, "warnings": warnings, "rejected": rejected}
 
-    warnings.append("visual_layout missing or fully invalid — using deterministic safe "
-                    "combination (forest_plot + dot_cascade + bubble_almanac + tick_rows)")
-    fallback_entries = [dict(e) for e in FALLBACK_LIEFLAT_LAYOUT]
+    # Data-driven fallback: probe every candidate shape and keep the ones this
+    # result can honestly support, instead of a fixed quartet that suppresses
+    # most charts when numeric effect sizes are absent.
+    lang_hint = "zh" if result.get("meta", {}).get("lang") == "zh" else "en"
+    fallback_entries = _fallback_layout_for(result, lang_hint)
+    if fallback_entries:
+        warnings.append(
+            "visual_layout missing or fully invalid — data-driven fallback selected "
+            + ", ".join(e["type"] for e in fallback_entries))
+    else:
+        warnings.append("visual_layout missing or fully invalid — no chart shape had "
+                        "sufficient data; gallery suppressed rather than drawn empty")
     return {"entries": fallback_entries, "fallback": True, "warnings": warnings, "rejected": rejected}
 
 
@@ -948,6 +665,9 @@ TEXT_LEAF_KEYS = {
     "population", "intervention", "comparison", "outcome_measure", "effect", "method",
     "ai_usage_policy", "target_learners", "ai_usage_rule", "outcome_check",
     "research_question", "treatment", "baseline", "post_test", "retention_test",
+    # Evaluation milestone fields name a measurement point in the reader
+    # language; they are prose, not structural identifiers.
+    "immediate_post", "retention", "transfer",
     "transfer_test", "success_threshold", "analysis_plan",
     "suitable_for", "not_suitable_for", "search_provider",
     "learner_match", "subject_match", "tool_match", "scope",
@@ -963,6 +683,10 @@ PROSE_LIST_KEYS = {
     "stop_conditions", "strengths", "limitations", "confounders", "required_conditions",
     "process_metrics", "learning_metrics", "risk_metrics", "suggestions", "risk_control",
     "evidence_alignment",
+    # Evaluation prose: criteria are sentences, and the milestone fields
+    # name a measurement point in the reader language.
+    "success_criteria", "stop_criteria", "immediate_post", "retention",
+    "transfer", "baseline",
 }
 
 
@@ -1091,7 +815,34 @@ _ZH_RESIDUE_RE = [
     (re.compile(r"\bCONCERN\b|\bPASS\b|\bFAIL\b"), "unmapped English audit code in zh narrative"),
 ]
 
+#: Raw storage identifiers inside a sentence. A single-token value may be an
+#: enum rendered through frame_enum_table(), but an underscore inside a multi-word
+#: string or inside a zh sentence is a copy defect the reader would see.
+_RAW_IDENTIFIER_RE = re.compile(r"[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9_]+")
+
+
+def _scan_raw_identifiers(problems: list[str], path: str, text: str) -> None:
+    """Flag snake_case storage identifiers that leaked into visible prose."""
+    if not text or not isinstance(text, str):
+        return
+    cleaned = text.strip()
+    has_cjk = bool(_HAS_CJK.search(cleaned))
+    is_sentence = len(cleaned.split()) > 1
+    if not (has_cjk or is_sentence):
+        return
+    for match in _RAW_IDENTIFIER_RE.finditer(cleaned):
+        token = match.group(0)
+        enum_tokens = set(frame_enum_table("zh")) | set(frame_enum_table("en"))
+        if token in enum_tokens:
+            continue
+        problems.append(path + ": raw identifier " + repr(token) + " leaked into prose")
+        return
+
+
 STRICT_NARRATIVE_PATHS = [
+    # Reader-facing decision prose written by the adjudicator.
+    "decision.strongest_support", "decision.key_uncertainty",
+    "decision.main_risk", "decision.next_action",
     "decision.decision_rationale", "decision.rationale", "decision.strongest_support",
     "decision.key_uncertainty", "decision.main_risk", "decision.next_action",
     "decision.next_steps", "decision.what_can_be_claimed", "decision.what_cannot_be_claimed",
@@ -1108,6 +859,21 @@ _SKIP_HINTS = ("id", "url", "doi", "author", "venue", "year", "status", "score",
                "verdict", "target", "decision")
 
 
+COPY_LIMITS_ZH = {
+    "decision.strongest_support": 60,
+    "decision.key_uncertainty": 70,
+    "decision.main_risk": 60,
+    "decision.next_action": 80,
+    "decision.decision_rationale": 160,
+    "decision.rationale": 160,
+}
+
+
+#: Structural tokens that look like prose to a language check but are parsed
+#: They stay identical across languages by contract.
+NON_NARRATIVE_KEYS = ("weeks", "pilot_duration")
+
+
 def _scan_narrative(problems, path, en_text, zh_text, strict=False, kind=""):
     en_text = en_text or ""
     zh_text = zh_text or ""
@@ -1130,6 +896,10 @@ def _scan_narrative(problems, path, en_text, zh_text, strict=False, kind=""):
             problems.append(path + ": 含" + label)
     if strict and kind in ("rationale", "reason") and len(zh_text) < 40:
         problems.append(path + ": 决策理由过短（<40 字）")
+    ceiling = COPY_LIMITS_ZH.get(path)
+    if ceiling and len(zh_text) > ceiling:
+        problems.append(
+            f"{path}: 叙述超出 {ceiling} 字上限（{len(zh_text)} 字）")
 
 
 def check_language_parallel(result_en: dict, result_zh: dict) -> list[str]:
@@ -1154,6 +924,9 @@ def check_language_parallel(result_en: dict, result_zh: dict) -> list[str]:
         _walk_strings(result_zh.get(root), "", zh_nodes, _SKIP_HINTS)
         by_path_en = {p: t for p, t in en_nodes}
         for p, z in zh_nodes:
+            leaf = p.rsplit(".", 1)[-1]
+            if leaf in NON_NARRATIVE_KEYS:
+                continue
             _scan_narrative(problems, root + p, by_path_en.get(p, ""), z, strict=False)
     for key in ("claims", "evidence"):
         en_items = result_en.get(key) or []
@@ -1163,6 +936,37 @@ def check_language_parallel(result_en: dict, result_zh: dict) -> list[str]:
             z_text = z_item.get("claim") if isinstance(z_item, dict) else None
             if z_text:
                 _scan_narrative(problems, key + "[" + str(i) + "].claim", e_text, z_text, strict=False)
+    # Frame prose: field values may be enums (rendered via frame_enum_table), but a
+    # storage identifier must never reach the reader inside a sentence. Both
+    # language versions are checked because the leak is an authoring defect.
+    # Weeks and pilot duration are structural tokens (W1, W2-W13, one_semester):
+
+    for label, root in (("research_frame", result_en), ("research_frame.zh", result_zh)):
+        nodes: list = []
+        _walk_strings(root.get("research_frame"), "", nodes, ())
+        for node_path, text_value in nodes:
+            _scan_raw_identifiers(problems, label + node_path, text_value)
+    # Structural parallel: ids, source/study/sample keys, sample sizes and the
+    # direction fields must match item by item. Free text may differ between
+    # languages; these may not, or the zh report describes a different study.
+    structural_fields = ("evidence_id", "source_id", "study_id", "sample_id",
+                         "sample_size", "outcome_type", "effect_direction",
+                         "relation_to_claim")
+    en_ev = result_en.get("evidence")
+    zh_ev = result_zh.get("evidence")
+    if isinstance(en_ev, list) and isinstance(zh_ev, list):
+        if len(en_ev) != len(zh_ev):
+            problems.append(
+                "evidence: en and zh rows differ in count "
+                + f"({len(en_ev)} vs {len(zh_ev)})")
+        for i, (a, b) in enumerate(zip(en_ev, zh_ev)):
+            if not (isinstance(a, dict) and isinstance(b, dict)):
+                continue
+            for field_name in structural_fields:
+                if a.get(field_name) != b.get(field_name):
+                    problems.append(
+                        f"evidence[{i}].{field_name}: en={a.get(field_name)!r} "
+                        f"!= zh={b.get(field_name)!r} (structural fields must agree)")
     return problems
 
 
@@ -1352,13 +1156,21 @@ def diverging_bar_svg(option: dict, width: int = 720, height: int = 300,
     """真 diverging 静态图（P0-10）：support 从中心向右、contradict 从中心向左，
     neutral 走独立的细条道（第二网格），三系列互不覆盖。计数轴整数刻度（P0-11）。
     6.5: aria-label / title / desc 从 UI 字典按语言取。"""
-    ui = ui or UI_ZH
+    ui = ui or build_ui("zh")
     cats = option.get("yAxis", [{}])[0].get("data", []) if isinstance(option.get("yAxis"), list) \
         else option.get("yAxis", {}).get("data", [])
     series = option.get("series", [])
     if not cats:
         return ""
-    left, right = 150, 40
+    # Reserve enough gutter for the longest y-axis label. A fixed 150px gutter
+    # pushed a long outcome name off the left edge (x0 = -42), so the reader
+    # saw a clipped label instead of the outcome it names.
+    def _label_w(text: str) -> float:
+        cjk = sum(1 for ch in str(text) if "\u4e00" <= ch <= "\u9fff")
+        return cjk * 11 + (len(str(text)) - cjk) * 6.6
+
+    left = max(150, int(max((_label_w(c) for c in cats), default=0)) + 20)
+    right = 40
     top, bottom = 46, 34
     main_h = int((height - top - bottom) * 0.62)
     neutral_h = height - top - bottom - main_h - 14
@@ -1432,7 +1244,7 @@ def diverging_bar_svg(option: dict, width: int = 720, height: int = 300,
 
 def grouped_bar_svg(option: dict, width: int = 720, height: int = 260,
                     note: str = "", lang: str = "zh", ui: dict | None = None) -> str:
-    ui = ui or UI_ZH
+    ui = ui or build_ui("zh")
     cats = option.get("xAxis", {}).get("data", [])
     series = option.get("series", [])
     parts = [f'<rect x="0" y="0" width="{width}" height="{height}" fill="#FFFFFF"/>']
@@ -1544,26 +1356,21 @@ def _outcome_support_score(evidence: list[dict], outcome: dict) -> float:
 def first_screen(result: dict, lang: str, ui: dict) -> str:
     """Decision-first hero: meaning before raw counts."""
     decision = result.get("decision", {})
-    outcomes = result.get("outcomes", [])
     evidence = result.get("evidence", [])
-    ranked = sorted(outcomes, key=lambda o: _outcome_support_score(evidence, o), reverse=True)
-    best_type = next((o.get("outcome_type") for o in ranked if o.get("positive_count", 0) > 0), None)
-    supported_claims = decision.get("supported_claims") or []
-    can_claim = decision.get("what_can_be_claimed") or []
-    uncertain_claims = decision.get("uncertain_claims") or []
-    contradicted_claims = decision.get("contradicted_claims") or []
     action = decision.get("recommended_action", "insufficient_evidence")
     cls = {"adopt": "adopt", "pilot": "pilot", "reject": "reject"}.get(action, "")
 
-    missing = "当前结果未提供此项信息。" if lang == "zh" else "Not provided in this research result."
-    strongest = (decision.get("strongest_support") or (can_claim[0] if can_claim else None)
-                 or (supported_claims[0] if supported_claims else None) or missing)
-    uncertainty = (decision.get("key_uncertainty")
-                   or (uncertain_claims[0] if uncertain_claims else None)
-                   or (contradicted_claims[0] if contradicted_claims else None)
-                   or decision.get("reason_for_disagreement") or missing)
-    risk = decision.get("main_risk") or decision.get("risk_effect") or missing
-    next_action = decision.get("next_action") or decision.get("next_steps") or missing
+    # These four are written by the adjudicator (schemas/verdict.schema.json).
+    # The renderer must not synthesise them from claim fragments: assembling a
+    # sentence out of list items is what made the first screen read as patched
+    # together rather than written. A missing field is reported as missing,
+    # which is also what the copy gate looks for.
+    missing = ("该字段未产出（应由裁决角色撰写）。" if lang == "zh"
+               else "Not produced by the adjudicator.")
+    strongest = decision.get("strongest_support") or missing
+    uncertainty = decision.get("key_uncertainty") or missing
+    risk = decision.get("main_risk") or missing
+    next_action = decision.get("next_action") or missing
 
     rationale = decision.get("decision_rationale") or decision.get("rationale") or ""
     rationale_html = expandable_text(rationale, ui["expand_details"], 380, "hero-rationale")
@@ -1586,23 +1393,17 @@ def first_screen(result: dict, lang: str, ui: dict) -> str:
 </div>"""
 
 
-OUTCOME_GROUPS = {
-    "task": {"completion_time", "accuracy", "assignment_score", "task_performance", "code_quality"},
-    "learning": {"knowledge_gain", "learning_gain", "concept_understanding", "retention", "transfer",
-                 "independent_problem_solving", "programming_skill", "writing_skill"},
-    "risk": {"ai_dependency", "over_reliance", "reduced_effort", "reduced_transfer",
-             "academic_integrity_risk", "false_confidence", "cognitive_load"},
-}
-
-
 def render_outcome_separation(result: dict, lang: str, ui: dict) -> str:
     outcomes = effect_outcomes(result)
     if len(outcomes) < 2:
         return ""
     buckets: dict[str, list[dict]] = {"task": [], "learning": [], "risk": [], "other": []}
+    group_map = outcome_group_map()
     for outcome in outcomes:
         kind = outcome.get("outcome_type") or ""
-        group = next((name for name, values in OUTCOME_GROUPS.items() if kind in values), "other")
+        group = next((name for name, values in group_map.items() if kind in values), "other")
+        if group not in buckets:
+            group = "other"
         buckets[group].append(outcome)
     group_labels = {
         "task": ui["outcome_group_task"], "learning": ui["outcome_group_learning"],
@@ -1722,33 +1523,33 @@ def effect_label(lang: str, value: Any) -> str:
             "neutral": "Null effect"}.get(effect, effect)
 
 
+def _quality_dims_text(lang: str, dims: Any) -> str:
+    """Render quality dimensions as readable pairs (D1 Study design = 2)."""
+    if not isinstance(dims, dict) or not dims:
+        return ""
+    DIM_LABELS_ZH = {
+        "D1_study_design": "D1 研究设计", "D2_sample_quality": "D2 样本质量",
+        "D3_measurement_validity": "D3 测量效度", "D4_temporal_strength": "D4 时间强度",
+        "D5_directness": "D5 直接性",
+    }
+    DIM_LABELS_EN = {
+        "D1_study_design": "D1 Study design", "D2_sample_quality": "D2 Sample quality",
+        "D3_measurement_validity": "D3 Measurement validity",
+        "D4_temporal_strength": "D4 Temporal strength", "D5_directness": "D5 Directness",
+    }
+    table = DIM_LABELS_ZH if lang == "zh" else DIM_LABELS_EN
+    sep = " · " if lang == "zh" else " · "
+    joiner = "=" if lang == "zh" else " = "
+    parts = []
+    for key, value in dims.items():
+        name = table.get(key) or _humanize_identifier(str(key), lang)
+        parts.append(f"{name}{joiner}{value}")
+    return sep.join(parts)
+
+
 def render_evidence_detail(ev: dict, source: dict, lang: str, ui: dict) -> str:
     """Render complete traceable evidence detail without inventing missing fields."""
-    labels = ({
-        "study_id": "研究 ID", "sample_id": "样本 ID", "title": "研究标题",
-        "year": "年份", "study_type": "研究设计", "education_level": "教育阶段",
-        "population": "研究人群", "sample_size": "样本量", "intervention": "干预",
-        "comparison": "对照 / 比较条件", "outcome_measure": "结果测量", "claim": "完整主张",
-        "effect": "效应 / 结果", "effect_direction": "效应方向", "relation_to_claim": "与主张关系",
-        "duration": "干预时长", "method": "方法", "strengths": "优势",
-        "limitations": "局限", "confounders": "混杂因素", "quality_dimensions": "质量维度",
-        "quality_score": "质量分", "evidence_level": "证据等级", "directness": "直接性",
-        "applicability": "适用性", "confidence": "置信度", "status": "证据状态",
-        "source_location": "来源位置", "source_title": "来源标题", "source_url": "可验证链接",
-        "claim_id": "Claim ID",
-    } if lang == "zh" else {
-        "study_id": "Study ID", "sample_id": "Sample ID", "title": "Study title",
-        "year": "Year", "study_type": "Study design", "education_level": "Education level",
-        "population": "Population", "sample_size": "Sample size", "intervention": "Intervention",
-        "comparison": "Comparison", "outcome_measure": "Outcome measure", "claim": "Full claim",
-        "effect": "Effect / result", "effect_direction": "Effect direction", "relation_to_claim": "Relation to claim",
-        "duration": "Duration", "method": "Method", "strengths": "Strengths",
-        "limitations": "Limitations", "confounders": "Confounders", "quality_dimensions": "Quality dimensions",
-        "quality_score": "Quality score", "evidence_level": "Evidence level", "directness": "Directness",
-        "applicability": "Applicability", "confidence": "Confidence", "status": "Evidence status",
-        "source_location": "Source location", "source_title": "Source title", "source_url": "Verifiable link",
-        "claim_id": "Claim ID",
-    })
+    labels = evidence_detail_label_table(lang)
 
     values: list[tuple[str, Any]] = []
     source_title = source.get("title") or ev.get("title")
@@ -1758,14 +1559,20 @@ def render_evidence_detail(ev: dict, source: dict, lang: str, ui: dict) -> str:
         ("study_id", ev.get("study_id")), ("sample_id", ev.get("sample_id")),
         ("title", ev.get("title")), ("source_title", source_title), ("year", source_year),
         ("study_type", label(lang, "study", ev.get("study_type") or "")),
-        ("education_level", ev.get("education_level")), ("population", ev.get("population")),
-        ("sample_size", ev.get("sample_size")), ("intervention", ev.get("intervention")),
-        ("comparison", ev.get("comparison")), ("outcome_measure", ev.get("outcome_measure")),
+        ("education_level", _frame_value_label(lang, ev.get("education_level"))),
+        ("population", _frame_value_label(lang, ev.get("population"))),
+        ("sample_size", ev.get("sample_size")),
+        ("intervention", _frame_value_label(lang, ev.get("intervention"))),
+        ("comparison", _frame_value_label(lang, ev.get("comparison"))),
+        ("outcome_measure", _frame_value_label(lang, ev.get("outcome_measure"))),
         ("effect", ev.get("effect")), ("effect_direction", effect_label(lang, ev.get("effect_direction"))),
         ("relation_to_claim", label(lang, "dir", ev.get("relation_to_claim") or ev.get("direction") or "neutral")),
-        ("duration", ev.get("duration")), ("method", ev.get("method")),
+        ("duration", _frame_value_label(lang, ev.get("duration"))),
+        ("method", _frame_value_label(lang, ev.get("method"))),
         ("strengths", ev.get("strengths")), ("limitations", ev.get("limitations")),
-        ("confounders", ev.get("confounders")), ("quality_dimensions", ev.get("quality_dimensions")),
+        ("confounders", [_frame_value_label(lang, c) for c in (ev.get("confounders") or [])]
+                        if isinstance(ev.get("confounders"), list) else _frame_value_label(lang, ev.get("confounders"))),
+        ("quality_dimensions", _quality_dims_text(lang, ev.get("quality_dimensions"))),
         ("quality_score", ev.get("quality_score")), ("evidence_level", ev.get("evidence_level")),
         ("directness", ev.get("directness")), ("applicability", ev.get("applicability")),
         ("confidence", ev.get("confidence")), ("status", label(lang, "status", ev.get("status") or "")),
@@ -2000,9 +1807,10 @@ def render_tribunal(result: dict, workflow_svg: str, tribunal_svg: str, lang: st
 
 def methodology_item_label(lang: str, item: Any) -> str:
     key = str(item or "")
-    if lang == "zh":
-        return METHODOLOGY_LABELS_ZH.get(key, key.replace("_", " "))
-    return key.replace("_", " ").strip().title()
+    table = methodology_label_table(lang)
+    if key in table:
+        return table[key]
+    return key.replace("_", " ").strip().title() if lang != "zh" else key.replace("_", " ")
 
 
 def render_methodology(result: dict, lang: str, ui: dict) -> str:
@@ -2086,12 +1894,32 @@ def render_applicability(result: dict, lang: str, ui: dict) -> str:
     return "\n".join(out) or f"<p>{esc(ui['no_data'])}</p>"
 
 
+def _weeks_label(value: str, lang: str) -> str:
+    """Render a week-range token for the reader, keeping data identical.
+
+    The bilingual contract requires the stored value to match across
+    languages, so the Chinese form is produced here rather than stored.
+    """
+    text = str(value or "")
+    if lang != "zh" or not text:
+        return text
+    import re as _re
+    m = _re.fullmatch(r"W(\d+)(?:-W?(\d+))?", text)
+    if not m:
+        return text
+    start, end = m.group(1), m.group(2)
+    if end:
+        return f"第 {start}-{end} 周"
+    return f"第 {start} 周"
+
+
 def render_intervention(result: dict, svg: str, lang: str, ui: dict) -> str:
     intervention = result.get("intervention", {})
     if not intervention:
         return f"<p>{esc(ui['no_data'])}</p>"
     population = intervention.get("target_population") or intervention.get("target_learners")
-    population_label = ("目标人群" if lang == "zh" else "Target population") if intervention.get("target_population") else ui['intervention_learners']
+    population_key = "intervention_population" if intervention.get("target_population") else "intervention_learners"
+    population_label = ui.get(population_key) or ui.get("intervention_learners") or ("目标人群" if lang == "zh" else "Target population")
     lines = [f"<p><strong>{esc(population_label)}{esc(ui['colon'])}</strong>{esc(population)} · "
              f"<strong>{esc(ui['intervention_duration'])}{esc(ui['colon'])}</strong>{esc(intervention.get('pilot_duration'))}</p>"]
     if intervention.get("ai_usage_policy"):
@@ -2258,16 +2086,16 @@ def resolve_full_report_plan(result: dict) -> list[dict[str, Any]]:
     raw = result.get("report_outline") or result.get("report_structure") or {}
     chapters = raw.get("chapters") if isinstance(raw, dict) else raw if isinstance(raw, list) else None
     if not isinstance(chapters, list) or not 5 <= len(chapters) <= 7:
-        return [dict(chapter) for chapter in DEFAULT_FULL_REPORT_PLAN]
+        return default_full_report_plan()
 
     normalized: list[dict[str, Any]] = []
     seen_modules: list[str] = []
     for index, chapter in enumerate(chapters, 1):
         if not isinstance(chapter, dict):
-            return [dict(item) for item in DEFAULT_FULL_REPORT_PLAN]
+            return default_full_report_plan()
         modules = [m for m in (chapter.get("modules") or []) if m in FULL_REPORT_MODULES]
         if not modules or any(m in seen_modules for m in modules):
-            return [dict(item) for item in DEFAULT_FULL_REPORT_PLAN]
+            return [dict(item) for item in default_full_report_plan()]
         seen_modules.extend(modules)
         key = re.sub(r"[^a-z0-9-]+", "-", str(chapter.get("key") or f"chapter-{index}").lower()).strip("-")
         normalized.append({
@@ -2279,9 +2107,9 @@ def resolve_full_report_plan(result: dict) -> list[dict[str, Any]]:
             "modules": tuple(modules),
         })
     if set(seen_modules) != set(FULL_REPORT_MODULES):
-        return [dict(item) for item in DEFAULT_FULL_REPORT_PLAN]
+        return [dict(item) for item in default_full_report_plan()]
     if "decision" not in normalized[0]["modules"] or "sources" not in normalized[-1]["modules"]:
-        return [dict(item) for item in DEFAULT_FULL_REPORT_PLAN]
+        return [dict(item) for item in default_full_report_plan()]
     return normalized
 
 
@@ -2303,8 +2131,31 @@ def render_full_chapter(chapter_id: str, title: str, content: str, lead: str = "
 
 
 def frame_enum_label(lang: str, value: Any) -> str:
+    """Label a frame enum value for display.
+
+    Registered values use the curated label. Anything else must still read as
+    prose: a raw snake_case identifier in the report is a copy defect, so the
+    fallback humanises it instead of leaking the storage form to the reader.
+    """
     text = str(value or "")
-    return (FRAME_ENUM_ZH if lang == "zh" else FRAME_ENUM_EN).get(text, text)
+    if not text:
+        return ""
+    table = frame_enum_table(lang)
+    if text in table:
+        return table[text]
+    return _humanize_identifier(text, lang)
+
+
+def _humanize_identifier(value: str, lang: str = "en") -> str:
+    """Turn a snake_case / kebab-case token into a readable phrase.
+
+    Delegates to zh_labels.humanize_identifier so the report body and the
+    charts share one display rule (curated label first, acronym-aware prose
+    second) instead of leaking storage identifiers to the reader.
+    """
+    from zh_labels import humanize_identifier
+
+    return humanize_identifier(value, lang)
 
 
 def labeled_pairs(lang: str, data: dict, labels_zh: dict[str, str], labels_en: dict[str, str]) -> str:
@@ -2313,33 +2164,39 @@ def labeled_pairs(lang: str, data: dict, labels_zh: dict[str, str], labels_en: d
     for key, value in data.items():
         if value in (None, "", [], {}):
             continue
-        rendered = frame_enum_label(lang, value) if isinstance(value, str) else str(value)
+        rendered = _frame_value_label(lang, value) if isinstance(value, str) else str(value)
         parts.append(f"{labels.get(key, key)}：{rendered}" if lang == "zh" else f"{labels.get(key, key)}: {rendered}")
     return "；".join(parts) if lang == "zh" else "; ".join(parts)
 
 
+def _frame_value_label(lang: str, value: Any) -> str:
+    """Render a frame value for display.
+
+    Free prose passes through; a bare storage identifier is humanised so the
+    comparison/success cards never show snake_case. Multi-word prose that
+    merely contains an underscore is returned unchanged.
+    """
+    if value in (None, "", [], {}):
+        return ""
+    text_value = str(value)
+    table = frame_enum_table(lang)
+    if text_value in table:
+        return table[text_value]
+    if " " in text_value.strip() or _HAS_CJK.search(text_value):
+        return text_value
+    return _humanize_identifier(text_value, lang)
+
+
 def render_research_scope(result: dict, lang: str, ui: dict) -> str:
     frame = result.get("research_frame", {}) or {}
     learner = frame.get("learner", {}) or {}
     course = frame.get("course", {}) or {}
     intervention = frame.get("intervention", {}) or {}
     scope = frame.get("scope", {}) or {}
-    labels = ({
-        "question": "研究问题", "learner": "目标学习者", "course": "课程情境", "intervention": "AI 干预",
-        "comparison": "比较条件", "outcomes": "结果构念", "scope": "研究范围", "success": "决策成功条件",
-    } if lang == "zh" else {
-        "question": "Research question", "learner": "Target learners", "course": "Course context", "intervention": "AI intervention",
-        "comparison": "Comparison", "outcomes": "Outcome constructs", "scope": "Research scope", "success": "Decision success condition",
-    })
-    learner_text = labeled_pairs(lang, learner,
-        {"education_level":"教育阶段", "major":"专业", "prior_knowledge":"先验知识", "special_characteristics":"学习者特征"},
-        {"education_level":"Education level", "major":"Major", "prior_knowledge":"Prior knowledge", "special_characteristics":"Learner characteristics"})
-    course_text = labeled_pairs(lang, course,
-        {"subject":"课程", "course_type":"课程类型", "duration":"课程周期"},
-        {"subject":"Subject", "course_type":"Course type", "duration":"Duration"})
-    intervention_text = labeled_pairs(lang, intervention,
-        {"ai_tool":"AI 工具", "allowed_usage":"允许使用", "frequency":"使用频率", "duration":"干预周期"},
-        {"ai_tool":"AI tool", "allowed_usage":"Allowed usage", "frequency":"Frequency", "duration":"Duration"})
+    labels = scope_field_labels(lang)
+    learner_text = labeled_pairs(lang, learner, scope_subfield_labels(lang, "learner"), scope_subfield_labels(lang, "learner"))
+    course_text = labeled_pairs(lang, course, scope_subfield_labels(lang, "course"), scope_subfield_labels(lang, "course"))
+    intervention_text = labeled_pairs(lang, intervention, scope_subfield_labels(lang, "intervention"), scope_subfield_labels(lang, "intervention"))
     outcome_map = frame.get("outcomes", {}) or {}
     outcome_parts = []
     for group, values in outcome_map.items():
@@ -2347,24 +2204,34 @@ def render_research_scope(result: dict, lang: str, ui: dict) -> str:
             rendered = "、".join(label(lang, "outcome", v) for v in values) if lang == "zh" else ", ".join(label(lang, "outcome", v) for v in values)
             outcome_parts.append(f"{frame_enum_label(lang, group)}：{rendered}" if lang == "zh" else f"{frame_enum_label(lang, group)}: {rendered}")
     scope_parts = []
-    scope_labels_zh = {"time_range":"时间范围", "geography":"地域", "study_types":"研究设计"}
-    scope_labels_en = {"time_range":"Time range", "geography":"Geography", "study_types":"Study designs"}
+    scope_labels_zh = scope_subfield_labels("zh", "scope")
+    scope_labels_en = scope_subfield_labels("en", "scope")
     for key, value in scope.items():
         if value in (None, "", [], {}):
             continue
-        if key == "study_types" and isinstance(value, list):
-            rendered = "、".join(label(lang, "study", str(v)) for v in value) if lang == "zh" else ", ".join(label(lang, "study", str(v)) for v in value)
+        if isinstance(value, list):
+            # Any list-valued scope field renders as a joined list. Only
+            # study_types used to be unpacked, so a list-valued evidence_types
+            # fell through to str() and printed its Python repr
+            # ("['quasi Experimental', 'rct']") straight into the card.
+            kind = "study" if key == "study_types" else ""
+            parts = [label(lang, kind, str(v)) if kind else _frame_value_label(lang, v)
+                     for v in value]
+            rendered = ("、".join(parts) if lang == "zh" else ", ".join(parts))
         else:
             rendered = frame_enum_label(lang, value)
-        field_label = (scope_labels_zh if lang == "zh" else scope_labels_en).get(key, key)
+        field_label = (scope_labels_zh if lang == "zh" else scope_labels_en).get(
+            key, _humanize_identifier(key, lang))
         scope_parts.append(f"{field_label}：{rendered}" if lang == "zh" else f"{field_label}: {rendered}")
     scope_text = "；".join(scope_parts) if lang == "zh" else "; ".join(scope_parts)
     cards = [
         (labels["question"], frame.get("question") or result.get("meta", {}).get("question")),
         (labels["learner"], learner_text), (labels["course"], course_text),
-        (labels["intervention"], intervention_text), (labels["comparison"], frame.get("comparison")),
+        (labels["intervention"], intervention_text),
+        (labels["comparison"], _frame_value_label(lang, frame.get("comparison"))),
         (labels["outcomes"], "；".join(outcome_parts) if lang == "zh" else "; ".join(outcome_parts)),
-        (labels["scope"], scope_text), (labels["success"], frame.get("success_condition")),
+        (labels["scope"], scope_text),
+        (labels["success"], _frame_value_label(lang, frame.get("success_condition"))),
     ]
     return '<div class="scope-grid">' + "".join(
         f'<article class="scope-card"><h3>{esc(title)}</h3>{expandable_text(text, ui["expand_details"], 260, "scope-text")}</article>'
@@ -2373,8 +2240,8 @@ def render_research_scope(result: dict, lang: str, ui: dict) -> str:
 
 def render_retrieval_context(result: dict, lang: str, ui: dict) -> str:
     frame = result.get("research_frame", {}) or {}
-    inclusion = frame.get("inclusion_criteria") or []
-    exclusion = frame.get("exclusion_criteria") or []
+    inclusion = [_frame_value_label(lang, v) for v in (frame.get("inclusion_criteria") or [])]
+    exclusion = [_frame_value_label(lang, v) for v in (frame.get("exclusion_criteria") or [])]
     provenance = result.get("provenance", {}) or {}
     sources = result.get("sources", []) or []
     source_ids = " ".join(f'<code>{esc(s.get("source_id"))}</code>' for s in sources)
@@ -2448,20 +2315,13 @@ def render_full_report(result: dict, lang: str, ui: dict, charts: dict, infograp
                     + render_v2_history(result, lang, ui)),
     }
 
-    default_leads = {
-        "decision": ("先明确最终裁决与研究边界，再解释为什么。" if lang == "zh" else "State the final adjudication and research boundary before explaining why."),
-        "evidence": ("把任务表现、真实学习、保持与风险放在同一证据地图中，但不混为一谈。" if lang == "zh" else "Place task performance, actual learning, retention and risk on one evidence map without conflating them."),
-        "quality": ("检查证据为什么可信、哪里冲突，以及哪些结论必须降级。" if lang == "zh" else "Examine why evidence is credible, where it conflicts, and which conclusions require downgrading."),
-        "action": ("把可外推范围、护栏和教学动作连接到具体证据。" if lang == "zh" else "Connect applicability, guardrails and teaching actions to specific evidence."),
-        "evaluation": ("用独立学习结果验证试点，并预先写清停止条件。" if lang == "zh" else "Validate the pilot with independent learning outcomes and pre-specified stop conditions."),
-        "sources": ("保留原始来源、URL、证据 ID 和获取信息，确保可回查。" if lang == "zh" else "Preserve original sources, URLs, evidence IDs and retrieval metadata for auditability."),
-    }
+    leads_by_key = default_leads(lang)
 
     plan = resolve_full_report_plan(result)
     rendered = []
     for index, chapter in enumerate(plan, 1):
         content = "".join(module_content.get(module, "") for module in chapter.get("modules", ()))
-        lead = chapter.get("lead_zh" if lang == "zh" else "lead_en") or default_leads.get(chapter.get("key"), "")
+        lead = chapter.get("lead_zh" if lang == "zh" else "lead_en") or leads_by_key.get(chapter.get("key"), "")
         rendered.append(render_full_chapter(
             chapter_dom_id(lang, str(chapter.get("key") or f"chapter-{index}"), index),
             full_chapter_title(chapter, lang, index), content, str(lead or "")))
@@ -2640,12 +2500,6 @@ def _enhancer_js(charts_zh: dict, charts_en: dict, result_en: dict) -> str:
     trace_en = next((c for c in charts_en.get("charts", [])
                      if c.get("chart_id") == "claim-evidence-trace"), None)
     benchmark_en = charts_en.get("benchmark") or {}
-    matrix_rows = [
-        {"id": e.get("evidence_id"), "title": e.get("title", ""),
-         "direction": e.get("direction", "neutral"),
-         "outcome": e.get("outcome_type", ""), "quality": e.get("quality_score", 0)}
-        for e in result_en.get("evidence", [])
-    ]
     return f"""
 (function () {{
   'use strict';
@@ -2845,7 +2699,12 @@ def render_lieflat_gallery_brief(result: dict, figures: dict, layout: dict,
         title = entry.get("title_zh" if zh else "title_en") or ""
         subtitle = entry.get("subtitle_zh" if zh else "subtitle_en") or ""
         caption = entry.get("caption_zh" if zh else "caption_en") or ""
-        source_line = f"{entry.get('catalog_ref', '')} · {entry.get('source', '')}".strip(" ·")
+        # The caption names the catalogue figure and, in prose, what it was
+        # drawn from. The raw bundle path ("evidence.year_x_outcome_counts") is
+        # an internal pointer and must not reach the reader, so it goes through
+        # the same humaniser as every other enum in the report.
+        source_ref = _humanize_identifier(str(entry.get('source', '')), lang)
+        source_line = f"{entry.get('catalog_ref', '')} · {source_ref}".strip(" ·")
         fig_type = entry.get("type", "")
         cards.append(
             f'<figure class="lieflat-card" data-lieflat data-visual="lieflat-{esc(fig_type)}" '
@@ -2879,24 +2738,7 @@ def render_body(result: dict, lang: str, ui: dict, charts: dict, infographics: d
     outcome_chart = next((c for c in charts.get("charts", [])
                           if c.get("chart_id") == "outcome-evidence-overview"), None)
 
-    if lang == "zh":
-        brief_titles = {
-            "decision": ("先看结论", "该不该做、置信度多高、最关键的证据边界在哪。"),
-            "lieflat": ("Lieflat 实证手作画廊", "AI 按数据形状从 Lieflat 目录选型编排；每张图的数字都可溯源到 result.json。"),
-            "outcomes": ("任务表现 ≠ 学习效果", "只展示真正有解释力的结果分离；正向、负向与零效应按 effect_direction 编码。"),
-            "tribunal": ("证据裁决", "支持、不确定、被反驳与缺失证据分开放置，不把长段落平铺在同一层。"),
-            "action": ("从证据到行动", "适用性、护栏、停止条件与评价连成一条可执行路径。"),
-            "sources": ("关键来源", "摘要页只列最关键的来源；完整溯源在完整报告中展开。"),
-        }
-    else:
-        brief_titles = {
-            "decision": ("Decision first", "What to do, how confident we are, and the most important evidence boundary."),
-            "lieflat": ("Lieflat Editorial Gallery", "Charts selected and composed by AI from the Lieflat catalog; every number traces back to result.json."),
-            "outcomes": ("Task performance ≠ learning", "Only informative outcome separation; positive, negative and null effects use effect_direction."),
-            "tribunal": ("Evidence tribunal", "Supported, uncertain, contradicted and missing evidence stay separated instead of flattened into long prose."),
-            "action": ("Evidence to action", "Applicability, guardrails, stop conditions and evaluation form one executable path."),
-            "sources": ("Key sources", "Only the key sources in the brief; full traceability expands in the full report."),
-        }
+    brief_titles = brief_block_titles(lang)
 
     lieflat_layout = viz.get("lieflat_layout") or {"entries": []}
     lieflat_meta = (viz.get("lieflat_meta") or {}).get(lang, {})
@@ -2922,7 +2764,7 @@ def render_body(result: dict, lang: str, ui: dict, charts: dict, infographics: d
     nav_items = [("decision", brief_titles["decision"][0]), ("outcomes", brief_titles["outcomes"][0]),
                  ("tribunal", brief_titles["tribunal"][0]), ("action", brief_titles["action"][0]),
                  ("sources", brief_titles["sources"][0])]
-    brief_nav = '<nav class="brief-navigation" aria-label="' + ("摘要导航" if lang == "zh" else "Brief navigation") + '">' + ''.join(
+    brief_nav = '<nav class="brief-navigation" aria-label="' + esc(ui["brief_nav_aria"]) + '">' + ''.join(
         f'<a href="#brief-{key}-{lang}"><span>{i:02d}</span>{esc(title)}</a>'
         for i, (key, title) in enumerate(nav_items, 1)) + '</nav>'
     full_report = render_full_report(result, lang, ui, charts, infographics, figures, viz)
@@ -2967,9 +2809,11 @@ def render_html(result_en: dict, result_zh: dict, charts_zh: dict, charts_en: di
                 figures_en: dict, theme: str, viz: dict,
                 result_sha256: str = "", integrity: dict | None = None) -> str:
     # Theme is fixed at generation time; language remains switchable in the HTML.
-    body_zh = render_body(result_zh, "zh", UI_ZH, charts_zh, infographics_zh, figures_zh, viz, theme,
+    ui_zh = build_ui("zh")
+    ui_en = build_ui("en")
+    body_zh = render_body(result_zh, "zh", ui_zh, charts_zh, infographics_zh, figures_zh, viz, theme,
                           integrity=integrity)
-    body_en = render_body(result_en, "en", UI_EN, charts_en, infographics_en, figures_en, viz, theme,
+    body_en = render_body(result_en, "en", ui_en, charts_en, infographics_en, figures_en, viz, theme,
                           integrity=integrity)
     hash_meta = (f'<meta name="eduevidence-result-sha256" content="{esc(result_sha256)}">\n'
                  if result_sha256 else "")
@@ -2993,10 +2837,10 @@ def render_html(result_en: dict, result_zh: dict, charts_zh: dict, charts_en: di
 <div class="controls reader-toolbar">
 <a class="reader-home" href="#" aria-label="Back to report start">EduEvidence<span class="generated-theme">{esc(THEME_DISPLAY[theme])}</span></a>
 <div class="reader-view-controls" role="group" aria-label="Report view">
-<button type="button" class="report-view-btn active" data-report-view="brief" data-copy="brief" aria-pressed="true">摘要</button>
-<button type="button" class="report-view-btn" data-report-view="full" data-copy="full" aria-pressed="false">完整报告</button>
+<button type="button" class="report-view-btn active" data-report-view="brief" data-copy="brief" aria-pressed="true">{esc(ui_zh['toolbar_brief'])}</button>
+<button type="button" class="report-view-btn" data-report-view="full" data-copy="full" aria-pressed="false">{esc(ui_zh['toolbar_full'])}</button>
 </div>
-<div class="reader-tools">{_lang_switcher(UI_ZH, UI_EN)}<button class="reader-print" type="button" data-copy="print">打印</button></div>
+<div class="reader-tools">{_lang_switcher(ui_zh, ui_en)}<button class="reader-print" type="button" data-copy="print">{esc(ui_zh['toolbar_print'])}</button></div>
 </div>
 {body_zh}
 {body_en}
@@ -3093,6 +2937,13 @@ def main() -> int:
         return 2
     result_zh = json.loads(zh_path.read_text(encoding="utf-8"))
 
+    # 0. Domain copy pack（result.meta.domain / frame.extensions.domain）
+    try:
+        activate_copy_pack(result_en)
+    except AssertionError as exc:
+        print(f"REPORT_INVALID — domain copy pack rejected:\n{exc}")
+        return 2
+
     # 1. Contract validation（两份数据分别校验）
     for label, data in (("result.json", result_en), ("result.zh.json", result_zh)):
         problems = validate_contract(data)
@@ -3122,8 +2973,8 @@ def main() -> int:
     # 3. Adapters（两份数据分别生成 spec / 信息图 / 学术图；数字同构）
     charts_zh = build_chart_specs(result_zh, lang="zh")
     charts_en = build_chart_specs(result_en, lang="en")
-    infographics_zh = build_infographics(result_zh, lang="zh")
-    infographics_en = build_infographics(result_en, lang="en")
+    infographics_zh = build_infographics(result_zh, lang="zh", ui=build_ui("zh"))
+    infographics_en = build_infographics(result_en, lang="en", ui=build_ui("en"))
     figure_data = build_figure_data(result_en)
     figures_zh = render_figures(figure_data, theme=args.theme, lang="zh")
     figures_en = render_figures(figure_data, theme=args.theme, lang="en")
@@ -3200,5 +3051,14 @@ def main() -> int:
     return 0
 
 
+def __getattr__(name: str):
+    """Back-compat UI dicts for tests: br.UI_ZH / br.UI_EN."""
+    if name == "UI_ZH":
+        return build_ui("zh")
+    if name == "UI_EN":
+        return build_ui("en")
+    raise AttributeError(name)
+
+
 if __name__ == "__main__":
     sys.exit(main())