Initial deployment

README.md

@@ -1,10 +1,10 @@
 ---
 title: MahjongGameDesigner
 emoji: 🀄️
-colorFrom: blue
+colorFrom: green
 colorTo: yellow
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
 ---
@@ -16,7 +16,7 @@ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-
 MahjongGameDesigner 是一个“麻将玩法生成与迭代”工具，输出三类交付物：
 - **自然语言规则说明**（可直接给策划/制作/评审）
 - **mGDL v1.3**（结构化规则描述，用于规范化与落地）
-- **思维日志（设计日志）**（创新机制的候选方案、取舍理由、推演摘要、落地映射）
+- **思维日志（设计日志）**（融合清单、冲突桥接、推演摘要、落地映射，便于人工复核）
 
 工具提供两种关键能力：
 - **Analyse 模式（单问题迭代）**：通过多轮问答把需求场景收敛到可生成状态（不生成 mGDL）
@@ -55,6 +55,13 @@ MahjongGameDesigner 是一个“麻将玩法生成与迭代”工具，输出三
 - 思维日志会从 `### 设计日志（创新推演摘要）` 段落提取并保存到 `exports/design_log_output.txt`
 - 在 Analyse 模式下不会导出上述文件（因为 Analyse 模式不生成完整交付物）
 
+## 当前阶段的规则准确性重点（必读）
+
+现阶段主要聚焦“既有机制组合”，但必须保证麻将底层物理逻辑准确（手牌守恒、吃碰杠轮次、牌墙转移等）。因此生成模式下请重点检查输出是否包含并一致：
+- 《动作—手牌变化—轮次影响表》
+- 3段《最小回合推演》（普通/碰/杠，每行标注手牌张数变化）
+- mGDL 的 `(invariants ...)` 中包含牌数守恒与“回合结束手牌恒为13”的约束
+
 ## 生成质量增强（默认开启）
 
 为提升“玩法理解”与“创新落地”，系统默认会自动注入：

app.py

@@ -41,6 +41,8 @@ try:
 except Exception:
     design_mahjong_game_stream = None
 
+from output_validator import validate_mahjong_response, format_issues_for_llm
+
 from design_state import (
     extract_design_state,
     extract_ready_to_generate,
@@ -48,6 +50,33 @@ from design_state import (
     diff_keys,
     diff_mechanics,
     is_change_within_scope,
+    generate_diff_summary,
+    generate_diff_summary_compact,
+    # 版本历史相关
+    create_empty_history,
+    add_to_history,
+    rollback_history,
+    get_history_choices,
+    parse_version_from_choice,
+    # 多阶段交互相关
+    InteractionPhase,
+    extract_proposals,
+    extract_clarify_questions,
+    detect_interaction_phase,
+    format_proposals_for_display,
+    generate_phase_prompt_hint,
+    create_phase_state,
+    update_phase_state,
+    get_phase_display_name,
+    # 细粒度范围控制相关
+    CONTROLLABLE_FIELDS,
+    ScopeConstraint,
+    create_scope_config,
+    get_scope_preset_options,
+    validate_scope_compliance,
+    format_scope_violations,
+    get_mechanics_from_state,
+    generate_scope_prompt_hint,
 )
 
 
@@ -160,6 +189,24 @@ def clear_files():
     return None
 
 
+def render_validation_md(text: str) -> str:
+    issues = validate_mahjong_response(text or "")
+    if not issues:
+        return "✅ 输出校验：未发现静态问题（可导出）"
+
+    errors = [i for i in issues if i.get("level") == "error"]
+    warnings = [i for i in issues if i.get("level") == "warning"]
+
+    parts = ["⚠️ 输出校验：发现潜在问题（建议先让模型按最小修改修复后再导出）"]
+    if errors:
+        parts.append("\n**错误（必须修复）**\n")
+        parts.append(format_issues_for_llm(errors))
+    if warnings:
+        parts.append("\n**警告（建议修复）**\n")
+        parts.append(format_issues_for_llm(warnings))
+    return "\n".join(parts).strip()
+
+
 def update_file_status(files):
     """更新文件状态显示"""
     if not files:
@@ -297,7 +344,7 @@ def save_gdl_and_narrative(gdl_content, narrative_content):
 
 def extract_design_log(content):
     """
-    提取“设计日志（创新推演摘要）”段落，用于单独导出。
+    提取"设计日志（创新推演摘要）"段落，用于单独导出。
     规则：从标题行开始，截到下一个同级标题（###）或文件结尾。
     """
     import re
@@ -305,12 +352,16 @@ def extract_design_log(content):
     if not content:
         return ""
 
-    m = re.search(r"^###\\s*设计日志（创新推演摘要）\\s*$", content, re.MULTILINE)
+    # 修复：原始字符串中 \s 即可匹配空白，不需要 \\s
+    m = re.search(r"^###\s*设计日志（创新推演摘要）\s*$", content, re.MULTILINE)
+    if not m:
+        # 兼容变体格式：设计日志/思维日志/Design Log
+        m = re.search(r"^###\s*(设计日志|思维日志|Design\s*Log).*$", content, re.MULTILINE | re.IGNORECASE)
     if not m:
         return ""
     start = m.start()
 
-    m2 = re.search(r"^###\\s+.+$", content[m.end():], re.MULTILINE)
+    m2 = re.search(r"^###\s+.+$", content[m.end():], re.MULTILINE)
     end = (m.end() + m2.start()) if m2 else len(content)
     return content[start:end].strip()
 
@@ -412,6 +463,8 @@ with gr.Blocks(
                 design_state_obj = gr.State({})       # 解析后的 dict（用于显示与对比）
                 design_state_version = gr.State(0)    # 版本号（每次成功提取 +1）
                 ready_to_generate = gr.State(False)
+                design_state_history = gr.State(create_empty_history())  # 版本历史
+                interaction_phase_state = gr.State(create_phase_state())  # 多阶段交互状态
 
                 with gr.Group(elem_classes="side-card"):
                     gr.Markdown("### 可控迭代（推荐）")
@@ -425,19 +478,89 @@ with gr.Blocks(
                     )
                     ready_status = gr.Markdown("READY_TO_GENERATE：未知", elem_classes="hint")
                     iteration_scope = gr.Dropdown(
-                        label="本轮允许修改范围",
-                        choices=[
-                            "自由迭代(仍保最小修改)",
-                            "仅优化创新机制",
-                            "仅优化计分与番型",
-                            "仅优化流程与阶段",
-                            "仅修复校验问题",
-                        ],
+                        label="本轮允许修改范围（预设）",
+                        choices=get_scope_preset_options(),
                         value="仅优化创新机制",
                     )
+
+                    # 细粒度范围控制（新增）
+                    with gr.Accordion("🔒 细粒度范围控制", open=False) as scope_accordion:
+                        scope_mode = gr.Radio(
+                            choices=["预设模式", "自定义模式"],
+                            value="预设模式",
+                            label="控制模式",
+                        )
+                        constraint_level = gr.Radio(
+                            choices=["软约束（提示）", "硬约束（阻断）"],
+                            value="软约束（提示）",
+                            label="约束级别",
+                        )
+                        with gr.Group(visible=False) as custom_scope_group:
+                            gr.Markdown("**锁定字段**（选中的字段不允许修改）", elem_classes="hint")
+                            locked_fields = gr.CheckboxGroup(
+                                choices=[
+                                    ("玩法名称", "new_variant_name"),
+                                    ("底座玩法", "base_variants"),
+                                    ("融合玩法", "fusion_variants"),
+                                    ("游戏模式", "game_variant"),
+                                    ("玩家人数", "players"),
+                                    ("计分模式", "scoring_mode"),
+                                    ("牌组配置", "tileset"),
+                                ],
+                                value=[],
+                                label="",
+                            )
+                            gr.Markdown("**锁定机制**（选中的机制不允许修改）", elem_classes="hint")
+                            locked_mechanics = gr.CheckboxGroup(
+                                choices=[],
+                                value=[],
+                                label="",
+                            )
+                            refresh_mechanics_btn = gr.Button("刷新机制列表", size="sm")
+                        scope_status = gr.Markdown("_范围约束: 预设模式_", elem_classes="hint")
+
+                    # 保存范围配置的 State
+                    scope_config_state = gr.State(create_scope_config())
+
                     generate_from_state_btn = gr.Button("基于当前 DesignState 生成完整玩法", variant="primary")
                     design_state_status = gr.Markdown("DesignState：未建立（先生成一版玩法）", elem_classes="hint")
 
+                    # 差异可视化区域（新增）
+                    with gr.Accordion("📊 DesignState 变更详情", open=False) as diff_accordion:
+                        diff_summary_display = gr.Markdown("_尚无变更记录_", elem_classes="diff-summary")
+
+                    # 版本历史与回滚（新增）
+                    with gr.Accordion("🕐 版本历史与回滚", open=False) as history_accordion:
+                        version_dropdown = gr.Dropdown(
+                            label="选择版本",
+                            choices=[],
+                            value=None,
+                            interactive=True,
+                        )
+                        with gr.Row():
+                            rollback_btn = gr.Button("回滚到所选版本", variant="secondary", size="sm")
+                            refresh_history_btn = gr.Button("刷新列表", variant="secondary", size="sm")
+                        history_status = gr.Markdown("_无版本历史_", elem_classes="hint")
+
+                    # 多阶段交互与方案选择（新增）
+                    with gr.Accordion("🎯 方案选择与交互引导", open=True) as phase_accordion:
+                        phase_status = gr.Markdown("**当前阶段**: 🚀 初始", elem_classes="hint")
+                        proposals_display = gr.Markdown("_等待生成方案..._", visible=False)
+                        with gr.Row(visible=False) as proposal_select_row:
+                            proposal_dropdown = gr.Dropdown(
+                                label="选择方案",
+                                choices=[],
+                                value=None,
+                                interactive=True,
+                                scale=3,
+                            )
+                            select_proposal_btn = gr.Button("确认选择", variant="primary", size="sm", scale=1)
+                        with gr.Row(visible=False) as diverge_action_row:
+                            request_more_btn = gr.Button("🔄 重新发散", variant="secondary", size="sm")
+                            request_elaborate_btn = gr.Button("📝 直接深入展开", variant="secondary", size="sm")
+
+                    validation_status = gr.Markdown("输出校验：未运行", elem_classes="hint")
+
                 user_input = gr.Textbox(
                     placeholder="例如：为4人竞速推倒胡设计番型与流程；或“做一个双人合作麻将 roguelike” …",
                     show_label=False,
@@ -465,21 +588,25 @@ with gr.Blocks(
                     ds_obj_prev,
                     ds_ver_prev,
                     ready_prev,
+                    history_data,
+                    phase_state,
                 ):
                     user_text = (user_text or "").strip()
+                    diff_md_prev = "_尚无变更记录_"  # 保留��次的差异摘要
+                    cur_choices = get_history_choices(history_data)
                     if not user_text:
                         # 不提交空消息：输出不变
-                        yield history_msgs, "", history_msgs, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：未变更", ready_prev, "READY_TO_GENERATE：未知"
+                        yield history_msgs, "", history_msgs, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：未变更", ready_prev, "READY_TO_GENERATE：未知", "输出校验：未运行", diff_md_prev, history_data, gr.update(choices=cur_choices), "_无版本历史_" if not cur_choices else f"共 {len(cur_choices)} 个版本"
                         return
 
-                    # 立即显示“用户消息”
+                    # 立即显示"用户消息"
                     history = list(history_msgs or [])
                     history.append({"role": "user", "content": user_text})
-                    yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：处理中…", ready_prev, "READY_TO_GENERATE：未知"
+                    yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：处理中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_处理中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
 
                     # 添加空的助手气泡，用于逐步填充
                     history.append({"role": "assistant", "content": ""})
-                    yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：处理中…", ready_prev, "READY_TO_GENERATE：未知"
+                    yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：处理中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_处理中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
 
                     # 流式生成内容
                     tuples_hist = _messages_to_tuples(history)
@@ -526,10 +653,10 @@ with gr.Blocks(
                                 if not piece:
                                     continue
                                 history[-1]["content"] += str(piece)
-                                yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, status_hint, ready_to_gen, ready_md
+                                yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, status_hint, ready_to_gen, ready_md, "输出校验：运行中…", "_处理中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
                         except Exception as e:
                             history[-1]["content"] += f"\n（流式出错）{type(e).__name__}: {e}"
-                            yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：流式出错（未变更）", ready_to_gen, "READY_TO_GENERATE：未知"
+                            yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：流式出错（未变更）", ready_to_gen, "READY_TO_GENERATE：未知", "输出校验：未运行", "_处理出错_", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
                     else:
                         try:
                             full = design_mahjong_game(effective_user_text, tuples_to_send, files, custom_prompt, mode)
@@ -537,13 +664,16 @@ with gr.Blocks(
                             full = f"（出错）{type(e).__name__}: {e}"
                         for piece in _chunk_fake_stream(str(full), step=40):
                             history[-1]["content"] += piece
-                            yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, status_hint, ready_to_gen, ready_md
+                            yield history, "", history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, status_hint, ready_to_gen, ready_md, "输出校验：运行中…", "_处理中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
 
                     # 提取 GDL 和自然语言描述并保存
                     new_ds_obj, new_ds_raw = extract_design_state(history[-1]["content"])
                     ready_flag = extract_ready_to_generate(history[-1]["content"])
                     ds_ver = int(ds_ver_prev or 0)
                     ds_status = "DesignState：未变更"
+                    diff_summary_md = "_无变更_"
+                    updated_history_data = history_data
+
                     if new_ds_obj and new_ds_raw:
                         ds_ver = ds_ver + 1
                         ds_status = "DesignState：v{0} 已更新 | {1}".format(ds_ver, summarize_design_state(new_ds_obj))
@@ -551,7 +681,19 @@ with gr.Blocks(
                             ready_to_gen = ready_flag
                             ready_md = "READY_TO_GENERATE：{0}".format("true" if ready_flag else "false")
 
-                        # 可控迭代：做一个“范围越界”软检查（不阻断，只提示）
+                        # 生成差异摘要
+                        diff_summary_md = generate_diff_summary(
+                            ds_obj_prev if isinstance(ds_obj_prev, dict) else None,
+                            new_ds_obj,
+                            int(ds_ver_prev or 0),
+                            ds_ver
+                        )
+
+                        # 添加到版本历史
+                        compact_summary = generate_diff_summary_compact(ds_obj_prev if isinstance(ds_obj_prev, dict) else None, new_ds_obj)
+                        updated_history_data = add_to_history(history_data, ds_ver, new_ds_obj, new_ds_raw, compact_summary)
+
+                        # 可控迭代：做一个"范围越界"软检查（不阻断，只提示）
                         if iterative_enabled and ds_obj_prev and isinstance(ds_obj_prev, dict) and scope:
                             changed = diff_keys(ds_obj_prev, new_ds_obj)
                             mech_changes = diff_mechanics(ds_obj_prev, new_ds_obj)
@@ -561,7 +703,7 @@ with gr.Blocks(
                                     "允许范围：{scope}\n"
                                     "顶层变更字段：{keys}\n"
                                     "机制变更：{mech}\n"
-                                    "建议：请重新执行一次迭代，明确只改允许范围内字段，或切换为“自由迭代”。\n"
+                                    "建议：请重新执行一次迭代，明确只改允许范围内字段，或切换为「自由迭代」。\n"
                                 ).format(
                                     scope=scope,
                                     keys=",".join(changed) if changed else "（无）",
@@ -569,23 +711,27 @@ with gr.Blocks(
                                 )
 
                     try:
+                        # 更新版本下拉选项
+                        new_choices = get_history_choices(updated_history_data)
+                        history_status_md = f"共 {len(new_choices)} 个版本" if new_choices else "_无版本历史_"
+
                         # Analyse 模式不产出完整规则，不导出GDL/自然语言文件
                         if analyse_enabled:
-                            yield history, "", history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md
+                            yield history, "", history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md, "输出校验：Analyse 模式跳过", diff_summary_md, updated_history_data, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), history_status_md
                             return
 
                         gdl_content, narrative_content = extract_gdl_and_narrative(history[-1]["content"])
                         design_log_content = extract_design_log(history[-1]["content"])
-                        
+
                         # 保存 GDL 和自然语言文件
                         gdl_path, narrative_path = save_gdl_and_narrative(gdl_content, narrative_content)
                         design_log_path = save_design_log(design_log_content)
-                        
+
                         # 返回文件路径，以便下载
-                        yield history, "", history, gdl_path, narrative_path, design_log_path, (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md
+                        yield history, "", history, gdl_path, narrative_path, design_log_path, (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md, render_validation_md(history[-1]["content"]), diff_summary_md, updated_history_data, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), history_status_md
                     except Exception as e:
                         print(f"保存GDL和自然语言文件时出错: {e}")
-                        yield history, "", history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md
+                        yield history, "", history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_to_gen, ready_md, render_validation_md(history[-1]["content"]), diff_summary_md, updated_history_data, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), history_status_md
 
                 def on_generate_from_state(
                     history_msgs,
@@ -596,18 +742,20 @@ with gr.Blocks(
                     ds_obj_prev,
                     ds_ver_prev,
                     ready_prev,
+                    history_data,
                 ):
+                    cur_choices = get_history_choices(history_data)
                     if not (ds_raw_prev or "").strip():
-                        yield history_msgs, history_msgs, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：未建立（先生成一版玩法）", ready_prev, "READY_TO_GENERATE：未知"
+                        yield history_msgs, history_msgs, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：未建立（先生成一版玩法）", ready_prev, "READY_TO_GENERATE：未知", "输出校验：未运行", "_尚无变更记录_", history_data, gr.update(choices=cur_choices), "_无版本历史_" if not cur_choices else f"共 {len(cur_choices)} 个版本"
                         return
 
                     history = list(history_msgs or [])
                     user_text = "基于当前 DesignState 生成完整玩法（自然语言规则 + mGDL + 自检报告）。"
                     history.append({"role": "user", "content": user_text})
-                    yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知"
+                    yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_生成中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
 
                     history.append({"role": "assistant", "content": ""})
-                    yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知"
+                    yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_生成中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
 
                     effective_user_text = (
                         "请基于下方 DesignState(JSON) 生成完整的麻将新玩法交付物：\n"
@@ -628,33 +776,50 @@ with gr.Blocks(
                                 s = str(piece)
                                 buf.append(s)
                                 history[-1]["content"] += s
-                                yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知"
+                                yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_生成中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
                         else:
                             full = design_mahjong_game(effective_user_text, tuples_to_send, files, custom_prompt, mode)
                             buf.append(str(full))
                             for piece in _chunk_fake_stream(str(full), step=40):
                                 history[-1]["content"] += piece
-                                yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知"
+                                yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成中…", ready_prev, "READY_TO_GENERATE：未知", "输出校验：运行中…", "_生成中..._", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
                     except Exception as e:
                         history[-1]["content"] += f"\n（生成出错）{type(e).__name__}: {e}"
-                        yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成出错", ready_prev, "READY_TO_GENERATE：未知"
+                        yield history, history, "", "", "", ds_raw_prev, ds_obj_prev, ds_ver_prev, "DesignState：生成出错", ready_prev, "READY_TO_GENERATE：未知", "输出校验：未运行", "_生成出错_", history_data, gr.update(choices=cur_choices), f"共 {len(cur_choices)} 个版本" if cur_choices else "_无版本历史_"
                         return
 
                     new_ds_obj, new_ds_raw = extract_design_state(history[-1]["content"])
                     ds_ver = int(ds_ver_prev or 0)
                     ds_status = "DesignState：未变更"
+                    diff_summary_md = "_无变更_"
+                    updated_history_data = history_data
+
                     if new_ds_obj and new_ds_raw:
                         ds_ver += 1
                         ds_status = "DesignState：v{0} 已更新 | {1}".format(ds_ver, summarize_design_state(new_ds_obj))
+                        # 生成差异摘要
+                        diff_summary_md = generate_diff_summary(
+                            ds_obj_prev if isinstance(ds_obj_prev, dict) else None,
+                            new_ds_obj,
+                            int(ds_ver_prev or 0),
+                            ds_ver
+                        )
+                        # 添加到版本历史
+                        compact_summary = generate_diff_summary_compact(ds_obj_prev if isinstance(ds_obj_prev, dict) else None, new_ds_obj)
+                        updated_history_data = add_to_history(history_data, ds_ver, new_ds_obj, new_ds_raw, compact_summary)
+
+                    # 更新版本下拉选项
+                    new_choices = get_history_choices(updated_history_data)
+                    history_status_md = f"共 {len(new_choices)} 个版本" if new_choices else "_无版本历史_"
 
                     try:
                         gdl_content, narrative_content = extract_gdl_and_narrative(history[-1]["content"])
                         design_log_content = extract_design_log(history[-1]["content"])
                         gdl_path, narrative_path = save_gdl_and_narrative(gdl_content, narrative_content)
                         design_log_path = save_design_log(design_log_content)
-                        yield history, history, gdl_path, narrative_path, design_log_path, (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_prev, "READY_TO_GENERATE：未知"
+                        yield history, history, gdl_path, narrative_path, design_log_path, (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_prev, "READY_TO_GENERATE：未知", render_validation_md(history[-1]["content"]), diff_summary_md, updated_history_data, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), history_status_md
                     except Exception:
-                        yield history, history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_prev, "READY_TO_GENERATE：未知"
+                        yield history, history, "", "", "", (new_ds_raw or ds_raw_prev), (new_ds_obj or ds_obj_prev), ds_ver, ds_status, ready_prev, "READY_TO_GENERATE：未知", render_validation_md(history[-1]["content"]), diff_summary_md, updated_history_data, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), history_status_md
 
                 # 绑定：回车提交（Enter=提交；Shift+Enter=换行由浏览器处理）
                 user_input.submit(
@@ -672,6 +837,7 @@ with gr.Blocks(
                         design_state_obj,
                         design_state_version,
                         ready_to_generate,
+                        design_state_history,
                     ],
                     outputs=[
                         chatbot,
@@ -686,6 +852,11 @@ with gr.Blocks(
                         design_state_status,
                         ready_to_generate,
                         ready_status,
+                        validation_status,
+                        diff_summary_display,
+                        design_state_history,
+                        version_dropdown,
+                        history_status,
                     ],
                     preprocess=True,
                 )
@@ -706,6 +877,7 @@ with gr.Blocks(
                         design_state_obj,
                         design_state_version,
                         ready_to_generate,
+                        design_state_history,
                     ],
                     outputs=[
                         chatbot,
@@ -720,6 +892,11 @@ with gr.Blocks(
                         design_state_status,
                         ready_to_generate,
                         ready_status,
+                        validation_status,
+                        diff_summary_display,
+                        design_state_history,
+                        version_dropdown,
+                        history_status,
                     ],
                     preprocess=True,
                 )
@@ -735,6 +912,7 @@ with gr.Blocks(
                         design_state_obj,
                         design_state_version,
                         ready_to_generate,
+                        design_state_history,
                     ],
                     outputs=[
                         chatbot,
@@ -748,10 +926,273 @@ with gr.Blocks(
                         design_state_status,
                         ready_to_generate,
                         ready_status,
+                        validation_status,
+                        diff_summary_display,
+                        design_state_history,
+                        version_dropdown,
+                        history_status,
                     ],
                     preprocess=True,
                 )
 
+                # 版本回滚功能
+                def on_rollback(selected_version, history_data, ds_obj_prev, ds_ver_prev):
+                    """回滚到选定版本"""
+                    if not selected_version:
+                        return (
+                            ds_obj_prev, "", ds_ver_prev,
+                            "DesignState：未选择版本", "_请选择要回滚的版本_",
+                            history_data, gr.update(), f"共 {len(get_history_choices(history_data))} 个版本" if get_history_choices(history_data) else "_无版本历史_"
+                        )
+
+                    version = parse_version_from_choice(selected_version)
+                    if version <= 0:
+                        return (
+                            ds_obj_prev, "", ds_ver_prev,
+                            "DesignState：版本解析失败", "_版本号无效_",
+                            history_data, gr.update(), f"共 {len(get_history_choices(history_data))} 个版本" if get_history_choices(history_data) else "_无版本历史_"
+                        )
+
+                    updated_history, state_obj, state_raw = rollback_history(history_data, version)
+                    if state_obj is None:
+                        return (
+                            ds_obj_prev, "", ds_ver_prev,
+                            f"DesignState：回滚失败（v{version} 不存在）", "_回滚失败_",
+                            history_data, gr.update(), f"共 {len(get_history_choices(history_data))} 个版本" if get_history_choices(history_data) else "_无版本历史_"
+                        )
+
+                    new_choices = get_history_choices(updated_history)
+                    ds_status = "DesignState：v{0} | {1}".format(version, summarize_design_state(state_obj))
+                    diff_md = f"**已回滚到 v{version}**\n\n{summarize_design_state(state_obj)}"
+
+                    return (
+                        state_obj, state_raw, version,
+                        ds_status, diff_md,
+                        updated_history, gr.update(choices=new_choices, value=new_choices[-1] if new_choices else None), f"✅ 已回滚到 v{version}，共 {len(new_choices)} 个版本"
+                    )
+
+                rollback_btn.click(
+                    fn=on_rollback,
+                    inputs=[version_dropdown, design_state_history, design_state_obj, design_state_version],
+                    outputs=[
+                        design_state_obj,
+                        design_state_raw,
+                        design_state_version,
+                        design_state_status,
+                        diff_summary_display,
+                        design_state_history,
+                        version_dropdown,
+                        history_status,
+                    ],
+                )
+
+                # 刷新历史列表
+                def on_refresh_history(history_data):
+                    choices = get_history_choices(history_data)
+                    return gr.update(choices=choices, value=choices[-1] if choices else None), f"共 {len(choices)} 个版本" if choices else "_无版本历史_"
+
+                refresh_history_btn.click(
+                    fn=on_refresh_history,
+                    inputs=[design_state_history],
+                    outputs=[version_dropdown, history_status],
+                )
+
+                # ====== 多阶段交互：阶段检测与方案选择 ======
+                def update_phase_from_chat(history_msgs, ds_obj, phase_state):
+                    """根据最新聊天内容更新阶段状态和方案显示"""
+                    if not history_msgs:
+                        return (
+                            "**当前阶段**: 🚀 初始",
+                            gr.update(visible=False),
+                            gr.update(choices=[], value=None),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            phase_state,
+                        )
+
+                    # 获取最后一条助手消息
+                    last_bot_msg = ""
+                    for msg in reversed(history_msgs):
+                        if isinstance(msg, dict) and msg.get("role") == "assistant":
+                            last_bot_msg = msg.get("content", "")
+                            break
+
+                    if not last_bot_msg:
+                        return (
+                            "**当前阶段**: 🚀 初始",
+                            gr.update(visible=False),
+                            gr.update(choices=[], value=None),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            phase_state,
+                        )
+
+                    # 检测阶段
+                    detected_phase = detect_interaction_phase(last_bot_msg, ds_obj)
+                    phase_display = get_phase_display_name(detected_phase)
+
+                    # 提取方案
+                    proposals = extract_proposals(last_bot_msg)
+                    questions = extract_clarify_questions(last_bot_msg)
+
+                    # 更新阶段状态
+                    new_phase_state = update_phase_state(phase_state, detected_phase, proposals=proposals)
+
+                    # 根据阶段决定 UI 显示
+                    if detected_phase == InteractionPhase.DIVERGE and len(proposals) >= 2:
+                        # 有多个方案，显示方案选择 UI
+                        proposal_choices = [f"方案 {p['id']}: {p['title']}" for p in proposals]
+                        proposals_md = format_proposals_for_display(proposals)
+                        return (
+                            f"**当前阶段**: {phase_display}\n\n发现 **{len(proposals)}** 个候选方案，请选择一个深入展开。",
+                            gr.update(value=proposals_md, visible=True),
+                            gr.update(choices=proposal_choices, value=None, visible=True),
+                            gr.update(visible=True),
+                            gr.update(visible=True),
+                            new_phase_state,
+                        )
+                    elif detected_phase == InteractionPhase.UNDERSTAND and questions:
+                        # 有确认问题
+                        questions_md = "\n".join([f"❓ {q}" for q in questions])
+                        return (
+                            f"**当前阶段**: {phase_display}\n\n请回答以下确认问题：",
+                            gr.update(value=questions_md, visible=True),
+                            gr.update(choices=[], value=None),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            new_phase_state,
+                        )
+                    else:
+                        # 其他阶段
+                        return (
+                            f"**当前阶段**: {phase_display}",
+                            gr.update(visible=False),
+                            gr.update(choices=[], value=None),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            new_phase_state,
+                        )
+
+                # 当聊天内容变化时更新阶段
+                chatbot.change(
+                    fn=update_phase_from_chat,
+                    inputs=[chatbot, design_state_obj, interaction_phase_state],
+                    outputs=[
+                        phase_status,
+                        proposals_display,
+                        proposal_dropdown,
+                        proposal_select_row,
+                        diverge_action_row,
+                        interaction_phase_state,
+                    ],
+                )
+
+                # 确认选择方案
+                def on_select_proposal(selected, phase_state, history_msgs):
+                    """用户选择方案后，生成相应的用户消息"""
+                    if not selected:
+                        return "", history_msgs, phase_state
+
+                    # 提取方案 ID
+                    proposal_id = selected.split(":")[0].replace("方案", "").strip()
+
+                    # 生成用户确认消息
+                    confirm_msg = f"我选择 **方案 {proposal_id}**，请对这个方案进行深入展开设计。"
+
+                    # 更新阶段状态
+                    new_phase_state = update_phase_state(phase_state, InteractionPhase.SELECT, selected=proposal_id)
+
+                    return confirm_msg, history_msgs, new_phase_state
+
+                select_proposal_btn.click(
+                    fn=on_select_proposal,
+                    inputs=[proposal_dropdown, interaction_phase_state, chat_state],
+                    outputs=[user_input, chat_state, interaction_phase_state],
+                )
+
+                # 重新发散按钮
+                def on_request_more():
+                    return "请给出更多不同方向的机制组合方案，我想看看其他可能性。"
+
+                request_more_btn.click(
+                    fn=on_request_more,
+                    outputs=[user_input],
+                )
+
+                # 直接深入展开按钮
+                def on_request_elaborate(phase_state):
+                    proposals = phase_state.get("proposals", [])
+                    if proposals:
+                        first = proposals[0]
+                        return f"请直接对方案 {first['id']}（{first['title']}）进行深入展开设计。"
+                    return "请直接对当前方案进行深入展开设计，生成完整的玩法规则和 mGDL。"
+
+                request_elaborate_btn.click(
+                    fn=on_request_elaborate,
+                    inputs=[interaction_phase_state],
+                    outputs=[user_input],
+                )
+
+                # ====== 细粒度范围控制：事件绑定 ======
+                def on_scope_mode_change(mode):
+                    """切换控制模式时显示/隐藏自定义选项"""
+                    is_custom = mode == "自定义模式"
+                    status_text = "_范围约束: 自定义模式_" if is_custom else "_范围约束: 预设模式_"
+                    return gr.update(visible=is_custom), status_text
+
+                scope_mode.change(
+                    fn=on_scope_mode_change,
+                    inputs=[scope_mode],
+                    outputs=[custom_scope_group, scope_status],
+                )
+
+                def on_refresh_mechanics(ds_obj):
+                    """刷新当前 DesignState 中的机制列表"""
+                    if not ds_obj or not isinstance(ds_obj, dict):
+                        return gr.update(choices=[], value=[])
+                    mechanics = get_mechanics_from_state(ds_obj)
+                    choices = [(m, m) for m in mechanics]
+                    return gr.update(choices=choices, value=[])
+
+                refresh_mechanics_btn.click(
+                    fn=on_refresh_mechanics,
+                    inputs=[design_state_obj],
+                    outputs=[locked_mechanics],
+                )
+
+                def on_scope_config_update(mode, constraint, locked_flds, locked_mechs, preset_scope):
+                    """更新范围配置状态"""
+                    is_preset = mode == "预设模式"
+                    constraint_level_val = ScopeConstraint.SOFT if "软" in constraint else ScopeConstraint.HARD
+
+                    config = {
+                        "mode": "preset" if is_preset else "custom",
+                        "preset": preset_scope if is_preset else "",
+                        "constraint_level": constraint_level_val,
+                        "locked_fields": locked_flds or [],
+                        "allowed_fields": [],
+                        "locked_mechanics": locked_mechs or [],
+                        "allowed_mechanics": [],
+                    }
+
+                    # 生成状态提示
+                    if is_preset:
+                        status = f"_范围约束: 预设模式 ({preset_scope})_"
+                    else:
+                        locked_count = len(locked_flds or []) + len(locked_mechs or [])
+                        constraint_text = "软约束" if constraint_level_val == ScopeConstraint.SOFT else "硬约束"
+                        status = f"_范围约束: 自定义模式 | {constraint_text} | 锁定 {locked_count} 项_"
+
+                    return config, status
+
+                # 当任意范围控制项变化时更新配置
+                for scope_input in [scope_mode, constraint_level, locked_fields, locked_mechanics, iteration_scope]:
+                    scope_input.change(
+                        fn=on_scope_config_update,
+                        inputs=[scope_mode, constraint_level, locked_fields, locked_mechanics, iteration_scope],
+                        outputs=[scope_config_state, scope_status],
+                    )
+
                 # 导出对话
                 with gr.Row():
                     export_btn = gr.Button("导出对话（Markdown）", variant="secondary")
@@ -762,7 +1203,16 @@ with gr.Blocks(
                     clear_dialog_btn = gr.Button("清空对话", variant="secondary")
 
                 def _clear_chat():
-                    return [], "", [], "", "", "", "", {}, 0, "DesignState：未建立（先生成一版玩法）", False, "READY_TO_GENERATE：未知"
+                    return (
+                        [], "", [], "", "", "", "", {}, 0,
+                        "DesignState：未建立（先生成一版玩法）", False, "READY_TO_GENERATE：未知",
+                        "输出校验：未运行", "_尚无变更记录_",
+                        create_empty_history(), gr.update(choices=[], value=None), "_无版本历史_",
+                        create_phase_state(), "**当前阶段**: 🚀 初始",
+                        gr.update(visible=False), gr.update(choices=[], value=None),
+                        gr.update(visible=False), gr.update(visible=False),
+                        create_scope_config(), "_范围约束: 预设模式_",
+                    )
 
                 clear_dialog_btn.click(
                     fn=_clear_chat,
@@ -780,6 +1230,19 @@ with gr.Blocks(
                         design_state_status,
                         ready_to_generate,
                         ready_status,
+                        validation_status,
+                        diff_summary_display,
+                        design_state_history,
+                        version_dropdown,
+                        history_status,
+                        interaction_phase_state,
+                        phase_status,
+                        proposals_display,
+                        proposal_dropdown,
+                        proposal_select_row,
+                        diverge_action_row,
+                        scope_config_state,
+                        scope_status,
                     ],
                 )
 

design_state.py

@@ -1,5 +1,5 @@
 """
-DesignState 解析与差分（用于“多轮可控迭代”）。
+DesignState 解析与差分（用于"多轮可控迭代"）。
 
 约定：
 - 模型需在回答中输出一个 ```json ...``` 代码块作为 DesignState
@@ -8,9 +8,191 @@ DesignState 解析与差分（用于“多轮可控迭代”）。
 
 import json
 import re
+from datetime import datetime
 from typing import Any, Dict, List, Optional, Tuple
 
 
+# ==================== 版本历史管理 ====================
+
+class DesignStateHistory:
+    """
+    管理 DesignState 的版本历史，支持回滚
+
+    每个版本包含：
+    - version: 版本号
+    - state_obj: DesignState 字典
+    - state_raw: 原始 JSON 字符串
+    - timestamp: 时间戳
+    - summary: 紧凑版摘要
+    """
+
+    def __init__(self, max_versions: int = 20):
+        self.max_versions = max_versions
+        self.versions: List[Dict[str, Any]] = []
+        self.current_index: int = -1  # 当前版本在 versions 中的索引
+
+    def add_version(
+        self,
+        version: int,
+        state_obj: Dict[str, Any],
+        state_raw: str,
+        summary: str = ""
+    ) -> None:
+        """添加新版本"""
+        if not state_obj:
+            return
+
+        record = {
+            "version": version,
+            "state_obj": state_obj.copy() if state_obj else {},
+            "state_raw": state_raw,
+            "timestamp": datetime.now().strftime("%H:%M:%S"),
+            "summary": summary or self._generate_summary(state_obj),
+        }
+
+        # 如果当前不在最新位置，截断后面的版本（类似 git 的分支）
+        if self.current_index >= 0 and self.current_index < len(self.versions) - 1:
+            self.versions = self.versions[:self.current_index + 1]
+
+        self.versions.append(record)
+        self.current_index = len(self.versions) - 1
+
+        # 超出最大版本数时，删除最早的
+        if len(self.versions) > self.max_versions:
+            self.versions.pop(0)
+            self.current_index = len(self.versions) - 1
+
+    def _generate_summary(self, state_obj: Dict[str, Any]) -> str:
+        """生成简短摘要"""
+        name = state_obj.get("new_variant_name", "(未命名)")
+        mechanics = state_obj.get("mechanics", [])
+        mech_count = len(mechanics) if isinstance(mechanics, list) else 0
+        return f"{name} ({mech_count}个机制)"
+
+    def get_version(self, version: int) -> Optional[Dict[str, Any]]:
+        """获取指定版本"""
+        for record in self.versions:
+            if record["version"] == version:
+                return record
+        return None
+
+    def get_version_by_index(self, index: int) -> Optional[Dict[str, Any]]:
+        """通过索引获取版本"""
+        if 0 <= index < len(self.versions):
+            return self.versions[index]
+        return None
+
+    def rollback_to(self, version: int) -> Optional[Tuple[Dict[str, Any], str]]:
+        """
+        回滚到指定版本
+        返回：(state_obj, state_raw) 或 None
+        """
+        for i, record in enumerate(self.versions):
+            if record["version"] == version:
+                self.current_index = i
+                return record["state_obj"].copy(), record["state_raw"]
+        return None
+
+    def get_version_list(self) -> List[Dict[str, Any]]:
+        """获取所有版本列表（用于 UI 显示）"""
+        return [
+            {
+                "version": r["version"],
+                "timestamp": r["timestamp"],
+                "summary": r["summary"],
+                "is_current": i == self.current_index,
+            }
+            for i, r in enumerate(self.versions)
+        ]
+
+    def get_version_choices(self) -> List[str]:
+        """生成下拉选项列表"""
+        choices = []
+        for i, r in enumerate(self.versions):
+            marker = " ← 当前" if i == self.current_index else ""
+            choices.append(f"v{r['version']} [{r['timestamp']}] {r['summary']}{marker}")
+        return choices
+
+    def get_current_version(self) -> int:
+        """获取当前版本号"""
+        if self.current_index >= 0 and self.current_index < len(self.versions):
+            return self.versions[self.current_index]["version"]
+        return 0
+
+    def clear(self) -> None:
+        """清空历史"""
+        self.versions = []
+        self.current_index = -1
+
+    def to_serializable(self) -> Dict[str, Any]:
+        """转为可序列化格式（用于 Gradio State）"""
+        return {
+            "versions": self.versions,
+            "current_index": self.current_index,
+            "max_versions": self.max_versions,
+        }
+
+    @classmethod
+    def from_serializable(cls, data: Dict[str, Any]) -> "DesignStateHistory":
+        """从序列化格式恢复"""
+        if not data or not isinstance(data, dict):
+            return cls()
+        history = cls(max_versions=data.get("max_versions", 20))
+        history.versions = data.get("versions", [])
+        history.current_index = data.get("current_index", -1)
+        return history
+
+
+def create_empty_history() -> Dict[str, Any]:
+    """创建空的历史记录（用于初始化 State）"""
+    return DesignStateHistory().to_serializable()
+
+
+def add_to_history(
+    history_data: Dict[str, Any],
+    version: int,
+    state_obj: Dict[str, Any],
+    state_raw: str,
+    summary: str = ""
+) -> Dict[str, Any]:
+    """添加版本到历史"""
+    history = DesignStateHistory.from_serializable(history_data)
+    history.add_version(version, state_obj, state_raw, summary)
+    return history.to_serializable()
+
+
+def rollback_history(
+    history_data: Dict[str, Any],
+    version: int
+) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]], Optional[str]]:
+    """
+    回滚到指定版本
+    返回：(更新后的 history_data, state_obj, state_raw)
+    """
+    history = DesignStateHistory.from_serializable(history_data)
+    result = history.rollback_to(version)
+    if result:
+        return history.to_serializable(), result[0], result[1]
+    return history_data, None, None
+
+
+def get_history_choices(history_data: Dict[str, Any]) -> List[str]:
+    """获取版本下拉选项"""
+    history = DesignStateHistory.from_serializable(history_data)
+    return history.get_version_choices()
+
+
+def parse_version_from_choice(choice: str) -> int:
+    """从选项字符串中解析版本号"""
+    if not choice:
+        return 0
+    # 格式: "v3 [14:23:45] 玩法名 (2个机制)"
+    match = re.match(r"v(\d+)", choice)
+    if match:
+        return int(match.group(1))
+    return 0
+
+
 _JSON_FENCE_RE = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL | re.IGNORECASE)
 _READY_RE = re.compile(r"READY_TO_GENERATE\s*:\s*(true|false)", re.IGNORECASE)
 
@@ -163,7 +345,7 @@ def is_change_within_scope(changed_top_keys: List[str], scope: str) -> bool:
     else:
         return True
 
-    # 名称/来源类字段默认不允许在“仅优化”里被改（除非自由迭代）
+    # 名称/来源类字段默认不允许在"仅优化"里被改（除非自由迭代）
     forbidden = {"new_variant_name", "base_variants", "fusion_variants"}
     for k in changed_top_keys:
         if k in forbidden:
@@ -171,3 +353,703 @@ def is_change_within_scope(changed_top_keys: List[str], scope: str) -> bool:
         if k not in allowed:
             return False
     return True
+
+
+# ==================== 差异可视化（新增） ====================
+
+# 字段中文名映射
+_FIELD_NAMES = {
+    "new_variant_name": "玩法名称",
+    "base_variants": "底座玩法",
+    "fusion_variants": "融合玩法",
+    "game_variant": "游戏模式",
+    "players": "玩家人数",
+    "scoring_mode": "计分模式",
+    "tileset": "牌组配置",
+    "core_constraints": "核心约束",
+    "mechanics": "机制列表",
+    "open_questions": "待定问题",
+}
+
+
+def _format_value(val: Any, max_len: int = 40) -> str:
+    """格式化值为简短字符串"""
+    if val is None:
+        return "(空)"
+    if isinstance(val, bool):
+        return "是" if val else "否"
+    if isinstance(val, (int, float)):
+        return str(val)
+    if isinstance(val, str):
+        s = val.strip()
+        return s if len(s) <= max_len else s[:max_len] + "..."
+    if isinstance(val, list):
+        if not val:
+            return "(空列表)"
+        if len(val) <= 3:
+            return ", ".join(str(v) for v in val)
+        return ", ".join(str(v) for v in val[:3]) + f"... 共{len(val)}项"
+    if isinstance(val, dict):
+        keys = list(val.keys())
+        if len(keys) <= 3:
+            return "{" + ", ".join(keys) + "}"
+        return "{" + ", ".join(keys[:3]) + f"... 共{len(keys)}项" + "}"
+    return str(val)[:max_len]
+
+
+def diff_open_questions(prev: Dict[str, Any], cur: Dict[str, Any]) -> Tuple[List[str], List[str]]:
+    """
+    对比 open_questions 的变化
+    返回：(已解决的问题列表, 新增的问题列表)
+    """
+    prev_qs = prev.get("open_questions") if isinstance(prev, dict) else None
+    cur_qs = cur.get("open_questions") if isinstance(cur, dict) else None
+
+    if not isinstance(prev_qs, list):
+        prev_qs = []
+    if not isinstance(cur_qs, list):
+        cur_qs = []
+
+    prev_set = set(str(q) for q in prev_qs)
+    cur_set = set(str(q) for q in cur_qs)
+
+    resolved = sorted(prev_set - cur_set)
+    added = sorted(cur_set - prev_set)
+
+    return resolved, added
+
+
+def generate_diff_summary(
+    prev: Optional[Dict[str, Any]],
+    cur: Optional[Dict[str, Any]],
+    prev_version: int = 0,
+    cur_version: int = 0
+) -> str:
+    """
+    生成人可读的 DesignState 变更摘要（Markdown 格式）
+    """
+    if not cur:
+        return ""
+
+    if not prev:
+        # 首次建立
+        name = cur.get("new_variant_name", "(未命名)")
+        mechanics = cur.get("mechanics", [])
+        mech_count = len(mechanics) if isinstance(mechanics, list) else 0
+        return f"**DesignState v{cur_version} 已建立**\n\n玩法：{name}\n机制数：{mech_count}"
+
+    lines = []
+    version_str = f"v{prev_version} → v{cur_version}" if prev_version and cur_version else ""
+    lines.append(f"**DesignState 变更摘要** {version_str}")
+    lines.append("")
+
+    # 1. 顶层字段变更（排除 mechanics 和 open_questions，单独处理）
+    skip_keys = {"mechanics", "open_questions"}
+    changed_fields = []
+
+    all_keys = set(prev.keys()) | set(cur.keys())
+    for key in sorted(all_keys):
+        if key in skip_keys:
+            continue
+        prev_val = prev.get(key)
+        cur_val = cur.get(key)
+        if prev_val != cur_val:
+            field_name = _FIELD_NAMES.get(key, key)
+            if key not in prev:
+                changed_fields.append(f"  • **[新增]** {field_name}: {_format_value(cur_val)}")
+            elif key not in cur:
+                changed_fields.append(f"  • **[删除]** {field_name}")
+            else:
+                changed_fields.append(f"  • {field_name}: `{_format_value(prev_val)}` → `{_format_value(cur_val)}`")
+
+    if changed_fields:
+        lines.append("📝 **顶层字段变更:**")
+        lines.extend(changed_fields)
+        lines.append("")
+
+    # 2. 机制变更
+    mech_changes = diff_mechanics(prev, cur)
+    if mech_changes:
+        lines.append("🔧 **机制变更:**")
+        for change in mech_changes:
+            if change.startswith("新增机制"):
+                lines.append(f"  • **[新增]** {change.replace('新增机制: ', '')}")
+            elif change.startswith("删除机制"):
+                lines.append(f"  • **[删除]** {change.replace('删除机制: ', '')}")
+            else:
+                # 机制变更: XXX 字段=a,b,c
+                parts = change.replace("机制变更: ", "").split(" 字段=")
+                if len(parts) == 2:
+                    lines.append(f"  • **[修改]** {parts[0]}: {parts[1]}")
+                else:
+                    lines.append(f"  • {change}")
+        lines.append("")
+
+    # 3. 待定问题变化
+    resolved, added = diff_open_questions(prev, cur)
+    if resolved or added:
+        lines.append("❓ **待定问题变化:**")
+        for q in resolved:
+            lines.append(f"  • ~~[已解决]~~ {q[:50]}{'...' if len(q) > 50 else ''}")
+        for q in added:
+            lines.append(f"  • **[新增]** {q[:50]}{'...' if len(q) > 50 else ''}")
+        lines.append("")
+
+    # 如果没有任何变更
+    if len(lines) <= 2:
+        lines.append("_(无变更)_")
+
+    return "\n".join(lines).strip()
+
+
+def generate_diff_summary_compact(
+    prev: Optional[Dict[str, Any]],
+    cur: Optional[Dict[str, Any]]
+) -> str:
+    """
+    生成紧凑版变更摘要（单行，用于状态栏）
+    """
+    if not cur:
+        return "无变更"
+
+    if not prev:
+        name = cur.get("new_variant_name", "(未命名)")
+        return f"新建: {name}"
+
+    changes = []
+
+    # 顶层字段变更数
+    field_changes = diff_keys(prev, cur)
+    skip_keys = {"mechanics", "open_questions"}
+    field_changes = [k for k in field_changes if k not in skip_keys]
+    if field_changes:
+        changes.append(f"{len(field_changes)}个字段")
+
+    # 机制变更数
+    mech_changes = diff_mechanics(prev, cur)
+    if mech_changes:
+        changes.append(f"{len(mech_changes)}个机制")
+
+    # 问题变化
+    resolved, added = diff_open_questions(prev, cur)
+    if resolved:
+        changes.append(f"解决{len(resolved)}个问题")
+    if added:
+        changes.append(f"新增{len(added)}个问题")
+
+    if not changes:
+        return "无变更"
+
+    return "变更: " + ", ".join(changes)
+
+
+# ==================== 多阶段引导式交互 ====================
+
+class InteractionPhase:
+    """交互阶段枚举"""
+    INITIAL = "initial"           # 初始阶段：用户提出需求
+    UNDERSTAND = "understand"     # 理解确认：确认对已有玩法的理解
+    DIVERGE = "diverge"           # 方案发散：生成多种机制组合方案
+    SELECT = "select"             # 方案选择：用户选择具体方案
+    ELABORATE = "elaborate"       # 深入展开：对选定方案进行详细设计
+    ITERATE = "iterate"           # 迭代优化：基于反馈优化方案
+
+
+# 方案提取正则
+_PROPOSAL_BLOCK_RE = re.compile(
+    r"(?:###?\s*)?(?:方案|选项|Option)\s*([A-Z\d一二三四五六七八九十]+)[：:\s]*(.+?)(?=(?:###?\s*)?(?:方案|选项|Option)\s*[A-Z\d一二三四五六七八九十]+[：:\s]|$)",
+    re.DOTALL | re.IGNORECASE
+)
+
+# 理解确认问题提取
+_CLARIFY_QUESTION_RE = re.compile(
+    r"(?:❓|🤔|【确认】|【问题】|\[确认\]|\[问题\]|请确认|请问|是否是指)\s*(.+?\?)",
+    re.DOTALL
+)
+
+
+def extract_proposals(text: str) -> List[Dict[str, Any]]:
+    """
+    从模型输出中提取多个候选方案
+    返回: [{"id": "A", "title": "...", "description": "...", "highlights": [...]}]
+    """
+    if not text:
+        return []
+
+    proposals = []
+    matches = _PROPOSAL_BLOCK_RE.findall(text)
+
+    for idx, (proposal_id, content) in enumerate(matches):
+        content = content.strip()
+        # 提取标题（第一行或冒号前的部分）
+        lines = content.split("\n")
+        title = lines[0].strip() if lines else f"方案 {proposal_id}"
+        # 清理标题中的 markdown 标记
+        title = re.sub(r"^[#\-\*]+\s*", "", title)
+        title = re.sub(r"\*+", "", title)
+
+        # 提取描述
+        description = "\n".join(lines[1:]).strip() if len(lines) > 1 else ""
+
+        # 提取亮点/创新点
+        highlights = []
+        highlight_patterns = [
+            r"[★✦⭐🌟]\s*(.+)",
+            r"(?:创新点|亮点|特色)[：:]\s*(.+)",
+            r"[-•]\s*(?:创新|特色|核心)[：:]\s*(.+)",
+        ]
+        for pattern in highlight_patterns:
+            hl_matches = re.findall(pattern, content)
+            highlights.extend([h.strip() for h in hl_matches])
+
+        proposals.append({
+            "id": proposal_id.strip(),
+            "title": title[:50],  # 限制标题长度
+            "description": description[:200] + ("..." if len(description) > 200 else ""),
+            "highlights": highlights[:3],  # 最多3个亮点
+            "full_content": content,
+        })
+
+    return proposals
+
+
+def extract_clarify_questions(text: str) -> List[str]:
+    """
+    从模型输出中提取需要用户确认的问题
+    """
+    if not text:
+        return []
+
+    questions = []
+    matches = _CLARIFY_QUESTION_RE.findall(text)
+    for q in matches:
+        q = q.strip()
+        if q and len(q) > 5:  # 过滤太短的
+            questions.append(q)
+
+    # 也尝试提取 open_questions 中的内容
+    try:
+        ds_obj, _ = extract_design_state(text)
+        if ds_obj and "open_questions" in ds_obj:
+            for q in ds_obj.get("open_questions", []):
+                if isinstance(q, str) and q not in questions:
+                    questions.append(q)
+    except Exception:
+        pass
+
+    return questions[:5]  # 最多5个问题
+
+
+def detect_interaction_phase(text: str, ds_obj: Optional[Dict[str, Any]] = None) -> str:
+    """
+    根据模型输出内容检测当前交互阶段
+    """
+    if not text:
+        return InteractionPhase.INITIAL
+
+    text_lower = text.lower()
+
+    # 检测是否有多个方案供选择
+    proposals = extract_proposals(text)
+    if len(proposals) >= 2:
+        return InteractionPhase.DIVERGE
+
+    # 检测是否有需要确认的问题
+    questions = extract_clarify_questions(text)
+    if questions:
+        return InteractionPhase.UNDERSTAND
+
+    # 检测是否有完整的 DesignState 且 READY_TO_GENERATE
+    ready = extract_ready_to_generate(text)
+    if ready is True:
+        return InteractionPhase.ELABORATE
+
+    # 检测是否在迭代中
+    if ds_obj and ds_obj.get("mechanics"):
+        return InteractionPhase.ITERATE
+
+    return InteractionPhase.INITIAL
+
+
+def format_proposals_for_display(proposals: List[Dict[str, Any]]) -> str:
+    """
+    将方案列表格式化为 Markdown 显示
+    """
+    if not proposals:
+        return ""
+
+    lines = ["## 🎯 请选择一个方案深入展开\n"]
+
+    for p in proposals:
+        lines.append(f"### 方案 {p['id']}: {p['title']}")
+        if p.get("highlights"):
+            for hl in p["highlights"]:
+                lines.append(f"  ✦ {hl}")
+        if p.get("description"):
+            lines.append(f"\n{p['description'][:150]}...")
+        lines.append("")
+
+    lines.append("\n💡 请在下方选择方案编号，或输入「其他」描述你的想法。")
+
+    return "\n".join(lines)
+
+
+def generate_phase_prompt_hint(phase: str, ds_obj: Optional[Dict[str, Any]] = None) -> str:
+    """
+    根据当前阶段生成提示词补充
+    """
+    hints = {
+        InteractionPhase.INITIAL: "",
+        InteractionPhase.UNDERSTAND: (
+            "\n\n【阶段提示】当前处于「理解确认」阶段。"
+            "请确保你完全理解用户描述的已有玩法，如有不明确之处请提出确认问题。"
+        ),
+        InteractionPhase.DIVERGE: (
+            "\n\n【阶段提示】当前处于「方案发散」阶段。"
+            "请发散思维，给出 2-4 种不同方向的机制组合方案，每个方案需包含：\n"
+            "1. 方案编号（A/B/C/D）\n"
+            "2. 方案名称\n"
+            "3. 核心创新点（1-2句话）\n"
+            "4. 机制组合简述\n"
+            "不要深入展开，等用户选择后再详细设计。"
+        ),
+        InteractionPhase.SELECT: (
+            "\n\n【阶段提示】用户已选择方案，请对该方案进行深入展开设计。"
+        ),
+        InteractionPhase.ELABORATE: (
+            "\n\n【阶段提示】当前处于「深入展开」阶段。"
+            "请输出完整的玩法设计（含 DesignState、mGDL、自检报告）。"
+        ),
+        InteractionPhase.ITERATE: (
+            "\n\n【阶段提示】当前处于「迭代优化」阶段。"
+            "请基于用户反馈对现有方案进行最小修改。"
+        ),
+    }
+    return hints.get(phase, "")
+
+
+def create_phase_state() -> Dict[str, Any]:
+    """创建阶段状态（用于 Gradio State）"""
+    return {
+        "current_phase": InteractionPhase.INITIAL,
+        "confirmed_understanding": [],  # 已确认的理解点
+        "proposals": [],                 # 当前可选方案
+        "selected_proposal": None,       # 用户选择的方案
+        "phase_history": [],             # 阶段历史
+    }
+
+
+def update_phase_state(
+    phase_state: Dict[str, Any],
+    new_phase: str,
+    proposals: Optional[List[Dict[str, Any]]] = None,
+    selected: Optional[str] = None,
+    confirmed: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """更新阶段状态"""
+    state = phase_state.copy() if phase_state else create_phase_state()
+
+    # 记录阶段变化历史
+    if state["current_phase"] != new_phase:
+        state["phase_history"].append({
+            "from": state["current_phase"],
+            "to": new_phase,
+            "timestamp": datetime.now().strftime("%H:%M:%S"),
+        })
+
+    state["current_phase"] = new_phase
+
+    if proposals is not None:
+        state["proposals"] = proposals
+
+    if selected is not None:
+        state["selected_proposal"] = selected
+
+    if confirmed is not None:
+        state["confirmed_understanding"].extend(confirmed)
+
+    return state
+
+
+def get_phase_display_name(phase: str) -> str:
+    """获取阶段的显示名称"""
+    names = {
+        InteractionPhase.INITIAL: "🚀 初始",
+        InteractionPhase.UNDERSTAND: "🔍 理解确认",
+        InteractionPhase.DIVERGE: "💡 方案发散",
+        InteractionPhase.SELECT: "✅ 方案选择",
+        InteractionPhase.ELABORATE: "📝 深入展开",
+        InteractionPhase.ITERATE: "🔄 迭代优化",
+    }
+    return names.get(phase, phase)
+
+
+# ==================== 细粒度范围控制 ====================
+
+# DesignState 可控字段定义
+CONTROLLABLE_FIELDS = {
+    "new_variant_name": {"label": "玩法名称", "category": "基础信息", "lockable": True},
+    "base_variants": {"label": "底座玩法", "category": "基础信息", "lockable": True},
+    "fusion_variants": {"label": "融合玩法", "category": "基础信息", "lockable": True},
+    "game_variant": {"label": "游戏模式", "category": "游戏规则", "lockable": True},
+    "players": {"label": "玩家人数", "category": "游戏规则", "lockable": True},
+    "scoring_mode": {"label": "计分模式", "category": "计分系统", "lockable": True},
+    "tileset": {"label": "牌组配置", "category": "游戏规则", "lockable": True},
+    "core_constraints": {"label": "核心约束", "category": "游戏规则", "lockable": False},
+    "mechanics": {"label": "机制列表", "category": "创新机制", "lockable": False},
+    "open_questions": {"label": "待定问题", "category": "其他", "lockable": False},
+}
+
+# 字段分类
+FIELD_CATEGORIES = {
+    "基础信息": ["new_variant_name", "base_variants", "fusion_variants"],
+    "游戏规则": ["game_variant", "players", "tileset", "core_constraints"],
+    "计分系统": ["scoring_mode"],
+    "创新机制": ["mechanics"],
+    "其他": ["open_questions"],
+}
+
+
+class ScopeConstraint:
+    """范围约束类型"""
+    SOFT = "soft"    # 软约束：检测到越界时提示，但不阻断
+    HARD = "hard"    # 硬约束：检测到越界时阻断并要求重做
+
+
+def create_scope_config() -> Dict[str, Any]:
+    """创建默认的范围配置"""
+    return {
+        "mode": "preset",  # preset（预设模式）或 custom（自定义模式）
+        "preset": "自由迭代(仍保最小修改)",  # 预设选项
+        "constraint_level": ScopeConstraint.SOFT,  # 约束级别
+        "locked_fields": [],  # 锁定的顶层字段
+        "allowed_fields": [],  # 允许修改的顶层字段（custom 模式下使用）
+        "locked_mechanics": [],  # 锁定的机制名称（不允许修改这些机制）
+        "allowed_mechanics": [],  # 只允许修改这些机制（为空表示不限制）
+    }
+
+
+def get_scope_preset_options() -> List[str]:
+    """获取预设范围选项"""
+    return [
+        "自由迭代(仍保最小修改)",
+        "仅优化创新机制",
+        "仅优化计分与番型",
+        "仅优化流程与阶段",
+        "仅修复校验问题",
+        "锁定核心（仅微调细节）",
+    ]
+
+
+def get_allowed_fields_for_preset(preset: str) -> List[str]:
+    """根据预设获取允许修改的字段"""
+    presets = {
+        "自由迭代(仍保最小修改)": list(CONTROLLABLE_FIELDS.keys()),
+        "仅优化创新机制": ["mechanics", "open_questions", "core_constraints"],
+        "仅优化计分与番型": ["scoring_mode", "open_questions"],
+        "仅优化流程与阶段": ["game_variant", "open_questions"],
+        "仅修复校验问题": ["mechanics", "tileset", "core_constraints", "players", "game_variant", "scoring_mode", "open_questions"],
+        "锁定核心（仅微调细节）": ["open_questions", "core_constraints"],
+    }
+    return presets.get(preset, list(CONTROLLABLE_FIELDS.keys()))
+
+
+def get_forbidden_fields_for_preset(preset: str) -> List[str]:
+    """根据预设获取禁止修改的字段"""
+    if preset == "自由迭代(仍保最小修改)":
+        return []
+
+    allowed = set(get_allowed_fields_for_preset(preset))
+    all_fields = set(CONTROLLABLE_FIELDS.keys())
+    return list(all_fields - allowed)
+
+
+def validate_scope_compliance(
+    prev: Dict[str, Any],
+    cur: Dict[str, Any],
+    scope_config: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    验证变更是否符合范围约束
+
+    返回:
+    {
+        "compliant": bool,  # 是否符合约束
+        "violations": [  # 违规列表
+            {"field": "xxx", "type": "field_locked|field_forbidden|mechanic_locked", "detail": "..."}
+        ],
+        "warnings": [],  # 警告（软约束时）
+        "summary": "..."  # 摘要文本
+    }
+    """
+    if not prev or not cur:
+        return {"compliant": True, "violations": [], "warnings": [], "summary": "无变更"}
+
+    result = {
+        "compliant": True,
+        "violations": [],
+        "warnings": [],
+        "summary": "",
+    }
+
+    mode = scope_config.get("mode", "preset")
+    constraint_level = scope_config.get("constraint_level", ScopeConstraint.SOFT)
+
+    # 确定允许和禁止的字段
+    if mode == "preset":
+        preset = scope_config.get("preset", "自由迭代(仍保最小修改)")
+        allowed_fields = set(get_allowed_fields_for_preset(preset))
+        forbidden_fields = set(get_forbidden_fields_for_preset(preset))
+    else:
+        allowed_fields = set(scope_config.get("allowed_fields", []))
+        forbidden_fields = set(scope_config.get("locked_fields", []))
+
+    locked_mechanics = set(scope_config.get("locked_mechanics", []))
+    allowed_mechanics = set(scope_config.get("allowed_mechanics", []))
+
+    # 检查顶层字段变更
+    changed_fields = diff_keys(prev, cur)
+
+    for field in changed_fields:
+        # 检查是否在禁止列表中
+        if field in forbidden_fields:
+            violation = {
+                "field": field,
+                "type": "field_forbidden",
+                "detail": f"字段「{CONTROLLABLE_FIELDS.get(field, {}).get('label', field)}」不在允许修改范围内",
+            }
+            result["violations"].append(violation)
+            continue
+
+        # 检查是否被显式锁定
+        if field in scope_config.get("locked_fields", []):
+            violation = {
+                "field": field,
+                "type": "field_locked",
+                "detail": f"字段「{CONTROLLABLE_FIELDS.get(field, {}).get('label', field)}」已被锁定",
+            }
+            result["violations"].append(violation)
+            continue
+
+    # 检查机制级别变更
+    if "mechanics" in changed_fields:
+        mech_changes = diff_mechanics(prev, cur)
+
+        for change in mech_changes:
+            # 提取机制名称
+            mech_name = ""
+            if "新增机制:" in change:
+                mech_name = change.replace("新增机制: ", "").strip()
+            elif "删除机制:" in change:
+                mech_name = change.replace("删除机制: ", "").strip()
+            elif "机制变更:" in change:
+                mech_name = change.split(" 字段=")[0].replace("机制变更: ", "").strip()
+
+            # 检查机制是否被锁定
+            if mech_name and mech_name in locked_mechanics:
+                violation = {
+                    "field": "mechanics",
+                    "type": "mechanic_locked",
+                    "detail": f"机制「{mech_name}」已被锁定，不允许修改",
+                }
+                result["violations"].append(violation)
+
+            # 检查是否只允许修改特定机制
+            if allowed_mechanics and mech_name and mech_name not in allowed_mechanics:
+                # 只对修改和删除进行限制，新增通常是允许的
+                if "删除机制:" in change or "机制变更:" in change:
+                    violation = {
+                        "field": "mechanics",
+                        "type": "mechanic_not_allowed",
+                        "detail": f"机制「{mech_name}」不在允许修改的机制列表中",
+                    }
+                    result["violations"].append(violation)
+
+    # 根据约束级别处理违规
+    if result["violations"]:
+        if constraint_level == ScopeConstraint.HARD:
+            result["compliant"] = False
+            result["summary"] = f"❌ 发现 {len(result['violations'])} 处范围越界（硬约束），请重新生成"
+        else:
+            result["warnings"] = result["violations"]
+            result["violations"] = []
+            result["summary"] = f"⚠️ 发现 {len(result['warnings'])} 处范围越界（软约束），建议检查"
+    else:
+        result["summary"] = "✅ 变更符合范围约束"
+
+    return result
+
+
+def format_scope_violations(validation_result: Dict[str, Any]) -> str:
+    """格式化范围违规为 Markdown"""
+    if validation_result.get("compliant", True) and not validation_result.get("warnings"):
+        return validation_result.get("summary", "")
+
+    lines = [validation_result.get("summary", "")]
+
+    items = validation_result.get("violations", []) or validation_result.get("warnings", [])
+    if items:
+        lines.append("")
+        for item in items:
+            field_label = CONTROLLABLE_FIELDS.get(item["field"], {}).get("label", item["field"])
+            lines.append(f"  • **{field_label}**: {item['detail']}")
+
+    return "\n".join(lines)
+
+
+def get_mechanics_from_state(ds_obj: Dict[str, Any]) -> List[str]:
+    """从 DesignState 中提取机制名称列表"""
+    if not ds_obj:
+        return []
+
+    mechanics = ds_obj.get("mechanics", [])
+    if not isinstance(mechanics, list):
+        return []
+
+    names = []
+    for m in mechanics:
+        if isinstance(m, dict) and "name" in m:
+            names.append(m["name"])
+
+    return names
+
+
+def generate_scope_prompt_hint(scope_config: Dict[str, Any], ds_obj: Optional[Dict[str, Any]] = None) -> str:
+    """生成范围约束的提示词补充"""
+    mode = scope_config.get("mode", "preset")
+
+    if mode == "preset":
+        preset = scope_config.get("preset", "自由迭代(仍保最小修改)")
+        if preset == "自由迭代(仍保最小修改)":
+            return ""
+
+        allowed = get_allowed_fields_for_preset(preset)
+        forbidden = get_forbidden_fields_for_preset(preset)
+
+        allowed_labels = [CONTROLLABLE_FIELDS.get(f, {}).get("label", f) for f in allowed]
+        forbidden_labels = [CONTROLLABLE_FIELDS.get(f, {}).get("label", f) for f in forbidden]
+
+        hint = f"\n\n【范围约束】当前模式：{preset}\n"
+        hint += f"允许修改：{', '.join(allowed_labels)}\n"
+        if forbidden_labels:
+            hint += f"禁止修改：{', '.join(forbidden_labels)}\n"
+
+        return hint
+
+    # 自定义模式
+    locked_fields = scope_config.get("locked_fields", [])
+    locked_mechanics = scope_config.get("locked_mechanics", [])
+
+    if not locked_fields and not locked_mechanics:
+        return ""
+
+    hint = "\n\n【范围约束】自定义模式\n"
+
+    if locked_fields:
+        locked_labels = [CONTROLLABLE_FIELDS.get(f, {}).get("label", f) for f in locked_fields]
+        hint += f"锁定字段（禁止修改）：{', '.join(locked_labels)}\n"
+
+    if locked_mechanics:
+        hint += f"锁定机制（禁止修改）：{', '.join(locked_mechanics)}\n"
+
+    return hint

m_prompt.txt

@@ -1,1331 +1,350 @@
-# 优化版麻将mGDL生成Prompt（完整工程级规范）
-
-<details>
-<summary>核心升级说明：从基础规范到工程级框架</summary>
-本优化将扑克类GDL的**完整工程化框架**迁移到麻将领域，同时保留所有核心优势：
-1. **物理守恒原则**：将"压牌即转移"适配为"摸打即转移"，确保所有麻将牌变动都有明确来源和去向
-2. **区域先行原则**：显式定义牌墙、手牌区、吃碰区、杠区、弃牌区等核心区域
-3. **机制完整性双向检查**：新增麻将特有机制（幺鸡/红中/翻马/承包）的注册与验证
-4. **牌数守恒动态校验**：精确跟踪牌墙剩余张数、各家手牌、吃碰杠明牌等
-5. **阶段完整性约束**：强制要求每个阶段（定缺/换三张/行牌/结算）必须明确定义触发条件与结束规则
-6. **番型可达性验证**：检查大牌型是否存在理论不可达情况（如四暗刻+单吊在血战麻将中不可行）
-7. **最小修改优先级**：提供麻将场景专用的自动修复策略树
-</details>
-
-## 角色设定及麻将游戏设计任务总览
-
-你是一位专业的麻将游戏设计专家，精通血战麻将、血流麻将、广东鸡平胡、武汉麻将等各类麻将变体的规则设计。你的任务是严格按照四步流程，输出一个完整、合规、创新的麻将新玩法方案，包含：
-
-1. **思考与自检过程**（含自检报告与修复轨迹）
-2. **设计日志（创新推演摘要）**：输出“候选方案对比 + 取舍理由 + 推演摘要 + 落地映射”，用于审核“创新不是文本拼接”
-3. **游戏名称与理念**
-4. **符合 mGDL 规范的完整 mGDL 描述（带中文注释）**
-5. **对应的自然语言规则说明**（含机制声明、流程、得分、番型等）
-6. **平衡性分析**
-7. **术语词典**
-
-## 核心参照资源
-
-本 prompt 配套以下 16 个经过严格验证的 mGDL v1.3 标准示例，涵盖了主流麻将机制。**在设计新玩法时，必须遵循mGDL v1.3规范，并优先参考同类机制的现有文件**：
-
-1.  **通用语法规范**：`麻将游戏mGDL通用语法_v1.3.txt`
-2.  **创新机制词典 (Mechanism Library)**：`示例玩法md/麻将机制说明.md`
-    *   **用途**：包含大量经过验证的麻将原子机制（如暴击、换牌、海捞、生肖收集等）。
-    *   **原则**：在进行“机制创新”或“玩法结合”时，**必须**首先查阅此文档，从中选取适配的机制进行组合。
-3.  **双源参考库 (Dual Source Reference)**：
-    
-    **核心原则：设计依从 .md (主)，语法参考 .txt (辅)**
-    *当 .md 与 .txt 规则不一致时，绝对以 .md 为准。*
-
-    *   **血战/血流体系 (Multiplier Mode)**
-        *   [组合] `疯狂血战.md` (主) + `疯狂血战_mGDL_v1.3.txt` (辅)
-        *   [组合] `两门血战麻将.md` (主) + `两门血战麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `幺鸡血战.md` (主) + `幺鸡血战_mGDL_v1.3.txt` (辅)
-        *   [组合] `疯狂血流.md` (主) + `疯狂血流_mGDL_v1.3.txt` (辅)
-        *   [组合] `海底捞月.md` (主) + `海底捞月_mGDL_v1.3.txt` (辅)
-
-    *   **混合/复杂计分体系 (Hybrid Mode)**
-        *   [组合] `贵州捉鸡麻将.md` (主) + `贵州捉鸡麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `广东鸡平胡.md` (主) + `广东鸡平胡_mGDL_v1.3.txt` (辅)
-        *   [组合] `广东100张.md` (主) + `广东100张_mGDL_v1.3.txt` (辅)
-        *   [组合] `合肥麻将.md` (主) + `合肥麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `山西扣点麻将.md` (主) + `山西扣点麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `经典推倒胡.md` (主) + `经典推倒胡_mGDL_v1.3.txt` (辅)
-        *   [组合] `长沙麻将.md` (主) + `长沙麻将_mGDL_v1.3.txt` (辅)
-
-    *   **特殊/番数体系 (Special/Fan System)**
-        *   [组合] `卡五星麻将.md` (主) + `卡五星麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `红中麻将.md` (主) + `红中麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `武汉麻将.md` (主) + `武汉麻将_mGDL_v1.3.txt` (辅)
-        *   [组合] `妙手七星.md` (主) + `妙手七星_mGDL_v1.3.txt` (辅)
-
-3.  **使用要求**：你的输出必须在语法上完全符合规范1（v1.3），在详细度上不低于上述示例（辅文档）。
-4.  **黄金原则（Golden Rule）**：若用户请求的玩法名称与上述参考文件匹配（如“妙手七星”），**必须读取并遵循对应的 .md 主文档**。
-5.  **主次分明原则（Primary-Auxiliary Principle）**：
-    - **当同时存在自然语言文档（.md）和 mGDL 文件（.txt）时**：
-        - **主文档（Primary）= 自然语言文档 (.md)**：它是**内容真理**。玩法的风味、设计初衷、非数值体验、特殊规则描述以 .md 为准。
-        - **辅文档（Auxiliary）= mGDL 文件 (.txt)**：它是**语法/结构参考**，不是规则真理。仅用于参考如何用合法的 v1.3 语法将 .md 中的规则“翻译”成代码：
-          - ✅ 允许参考：模块结构、字段写法、合法枚举、注释风格、invariants 写法模板
-          - ❌ 严禁参考：把示例中的具体数值/倍数/牌数/限制条件当作新玩法规则依据（除非 .md 也明确这样写）
-          - ❌ 严禁推断：不得仅凭 mGDL 示例“猜测”规则细节（尤其是牌组构成、发牌/摸牌节奏、结算公式）
-    - **冲突解决**：若 .md 说“摸2打1”，而 .txt 示例说“摸1打1”，**以 .md 为准**，必须编写出支持“摸2打1”的新 mGDL 代码，而不是照抄旧代码。
-    - **RAG 上下文使用规则（重要）**：
-        - 若系统注入了参考玩法 `.md`，你必须将其视为“规则真理片段”，并在融合分析中明确引用其机制点（无需逐行引用）。
-        - 若系统注入了参考玩法 mGDL（可能默认不注入），你只能把它当作“语法写法范例”，不得把它当作规则来源。
-
-## 统一约定（强制）
-
-- **mGDL 代码**：使用括号嵌套节点结构（S-expression），例如：
-  - `(extensions (special_mechanics (mechanic_cards ...)))`
-- **mGDL_path**：仅在表格/自检/说明中使用“点号路径字符串”，例如：
-  - `extensions.special_mechanics.mechanic_cards.<Mechanic_ID>`
-- **严禁混用**：
-  - ❌ 禁止在 mGDL 代码里写 `(extensions.special_mechanics.mechanic_cards. ...)`
-  - ❌ 禁止使用双点 `..`、禁止路径末尾 `.`（统一不带末尾点）
-
-## 玩法融合任务指南 (Variant Fusion Guidelines)
-
-当任务要求**"融合玩法 A 与 玩法 B"**或**"基于 A 玩法增加 B 的机制"**时，请严格遵循以下步骤：
-
-### 1. 机制解构与冲突检测
-首先分析源玩法的核心特征，并检查是否存在冲突：
-- **计分模式冲突**：若 A 是倍数制(血战)，B 是番数制(国标)，**强制统一为倍数制(multiplier)**。将番数制番型转化为倍数（如 1番=2倍）。
-- **胡牌流程冲突**：若 A 是血流(胡牌继续)，B 是普通(胡牌结束)，需明确新玩法采用哪种模式（通常保留血战/血流模式以增加趣味性）。
-- **牌组冲突**：若 A 无万字，B 有花牌，需明确新牌组构成。
-
-### 2. 融合策略
-- **核心+插件模式**：以一个玩法为"底座"（通常选择流程更成熟的血战/血流），将另一个玩法的"特色机制"作为插件植入。
-  - *示例*：血流麻将(底座) + 红中赖子(插件) = 红中血流
-- **化学反应（Chemical Reaction）**：融合不应是简单的“A+B”，而应产生新的策略体验。
-  - *提问*：引入的新机制（如+2牌）如何改变原有的出牌策略？如果只是单纯增加运气，请重新设计为策略型机制（如“指定下家打出特定花色”）。
-- **特殊机制注册**：所有从 B 玩法引入的机制（如买马、抓鸟、特殊赖子），必须在机制卡注册表中注册：
-  - 代码落点：`(extensions (special_mechanics (mechanic_cards ...)))`
-  - 路径引用：`extensions.special_mechanics.mechanic_cards.<Mechanic_ID>`
-
-
-### 3. 生成要求
-- 在 **游戏理念** 中明确说明融合了哪些玩法的哪些要素。
-- 在 **mGDL** 中，确保引入的机制完全符合 v1.3 语法（如 `horse_rules` 用于买马，`wildcard` 用于赖子）。
-- **禁止**简单堆砌：不要同时保留两套互相矛盾的规则（如同时存在"只能自摸"和"允许点炮"），必须在 `win_rules` 中统一。
-
-> ⚠️ **注意**：以下"mGDL 生成硬规范"仅约束第3部分（mGDL描述）的语法与语义，不影响其他部分的自由生成。其他部分仍需遵守通用清晰性、确定性、无模糊词等基本要求。
-
-## 创新扩展任务指南 (Innovation Extension Guidelines)
-
-当任务要求**“在某玩法A基础上，新增若干机制 / 做一个A的创新变体（不指定玩法B）”**时，进入【创新扩展模式】。
-目标不是堆叠条款，而是让新机制成为“改变策略”的主干，并且能被 mGDL v1.3 **实体化**。
-
-### A. 一脊一骨架原则（Anti-Stacking）
-1. 只允许 **1 个“主创新机制”（Core Mechanic）**。
-2. 最多允许再配 **1 个“辅机制”（Aux Mechanic）**，且辅机制必须服务于主机制（例如：主机制=收集轨；辅机制=一次性加速/保底触发）。
-3. 每一条新增规则必须同时满足：
-   - 绑定到某个【状态变量】（计数器/集合/标记/可见性/全局池/个人池）
-   - 影响至少一个【决策点】（摸/打/吃碰杠/宣告/换牌/点炮/结算）
-   - 在结算中体现为【奖励/惩罚/上限突破】之一
-   否则判定为“装饰性堆叠”→ 必须删掉或重写。
-4. 复杂度预算（防止无限扩张）：
-   - 主机制新增【状态变量】≤2 个
-   - 新增【行动（action）】≤2 个（可用既有 action 的参数化替代）
-   - 新增【结算条目/番型】≤3 个（若更多，必须合并成阶梯式阈值）
-
-### B. 机制卡（Mechanic Card）模板（必须在脑中生成，输出可简版）
-对每个候选机制，用下列字段快速定型（字段越具体越好）：
-- 名称：
-- 设计目的（对应你要强化的体验：加速/做大牌/互动/信息博弈等）：
-- 状态变量（存放位置：哪个 zone/状态树；初值；可见性）：
-- 触发器列表（trigger_condition：事件+时机+条件）：
-- 效果列表（transfer_path / visibility_change / scoring_delta / phase_rule）：
-- 反制与风险（对手能做什么？失败代价是什么？）：
-- 平衡旋钮（上限、频率、成本、门槛、封顶/破封）：
-- mGDL 落点（extensions.special_mechanics.mechanic_cards. / actions / phases.rules / scoring / fan_table）：
-
-### C. 创新模式的“化学反应”检查（必须过）
-写出一条因果链：
-新机制 → 改变玩家选择 → 形成对抗/博弈 → 在分数/胜负上体现。
-若链路中断（只增加随机性/只是加倍/只是换皮）→ 必须重构为策略机制（带条件/成本/反制）。
-
-### D. 常用创新母题（来自已知创新玩法的抽象内核；禁止照抄具体数值）
-从下列母题中选 **1 个作为主机制骨架**，再围绕它做“一处关键扭转”（一个明确的新选择/新代价/新反制）：
-1. 信息显隐与交换（暗/明牌、公开承诺、揭示换收益）
-2. 进度/收集轨（点亮/收集集合→阶梯式奖励，阈值触发）
-3. 可扩张目标池（听口/任务池随事件增长；重复触发带来突破）
-4. 回收与二次抽取（弃牌/交换牌回收进池；形成“牌库循环”）
-5. 门槛触发相位切换（全员听牌/全员胡牌后进入“决斗相位”等）
-
-6. 宣告-押注（宣告目标换更高收益，失败受惩罚；鼓励对抗和读牌）
-7. **机制库提取（Reference Library）**：基于 `麻将机制说明.md` 中的分类：
-   - **速度类**：一炮多响、抢杠胡、封顶加速
-   - **策略类**：换牌、海底漫游、海捞、暴击（Win Compare）
-   - **社交类**：2v2组队（Shared Info）、团队任务
-   - **趣味类**：功能牌（Draw 3 Choose 1）、收集（Zodiac/Items）
-
-### E. 选型流程（内部，不要求完整输出）
-1. 先提出 **3 个候选 Mechanic Card**
-2. 用 5 项打分：新颖性 / 契合度 / 可实现性（可落 mGDL） / 复杂度预算 / 反制性
-3. 只实现最高分的 **1 个主机制（+可选 1 个辅机制）**，其余全部丢弃
-
-
-## 核心设计原则与强制约束
-
-### mGDL 输出硬规范补充
-
-1. **区域定义完整性**：
-   - 所有牌在游戏中的位置必须属于预定义区域：`wall`（牌墙）、`hand:<PID>`（手牌）、`meld:<PID>`（吃碰区）、`kong:<PID>`（杠区）、`discard_pile`（弃牌区）、`flip_zone`（翻牌区）
-   - 任何涉及牌变动的行为必须被理解为区域间的物理转移，不存在"凭空出现"或"凭空消失"
-   - 示例：摸牌 = `(transfer_path from: wall to: hand:<PID>)`；吃牌 = `(transfer_path from: discard_pile to: meld:<PID>)`
-
-2. **牌数守恒公式**：
-   - 必须在 `(setup)` 模块中明确定义初始牌数分布
-   - 必须在 `(invariants)` 中包含守恒公式：`(= (+ (zone wall) (zone hand:A1) ... (zone meld:A1) ... (zone discard_pile)) TotalTiles)`
-   - 任何操作后必须保持等式成立
-
-3. **阶段命名规范**：
-   - 阶段名只用短枚举，顶层 (phases [...]) 列表禁止使用 *_phase；state_machine / mechanic_cards 内部状态名允许使用 *_phase（但建议仍尽量短名）；合法阶段：`setup,choose_que,exchange_three,play,sea_draw,settle`，说明：deal 语义并入 setup（发牌/起手手牌配置属于 setup 细则），如无“海底”机制可让 sea_draw 为空实现或不触发。
-   - `turn_order` 必须精确到 PID 序列，或通过 `player_seating` 完成角色→PID 绑定
-
-4. **计分模式一致性与番数/倍数区分**（v1.3 核心要求）：
-   - 必须显式指定 `scoring.mode` 为 `"multiplier"`/`"fan_system"`/`"hybrid"`
-   - **番型定义必须与计分模式严格兼容**：
-     * **倍数制 (multiplier)**：仅使用 `mult` 字段，适用于血战/血流麻将
-       - 计算：得分 = 底分 × 倍数
-       - 叠加：通常使用 `stacking="multiply"` 倍数叠乘
-       - 示例：清一色(4倍) × 碰碰胡(2倍) = 8倍
-     * **番数制 (fan_system)**：仅使用 `fan` 字段，适用于国标麻将
-       - 计算：得分 = 底分 × 2^番数
-       - 叠加：通常使用 `stacking="add_fan"` 番数相加后指数计算
-       - 示例：清一色(6番) + 碰碰胡(6番) = 12番 → 2^12 = 4096倍
-     * **混合制 (hybrid)**：使用 `mult` + `category` 区分不同计分维度
-       - 适用：捉鸡麻将等复杂计分玩法
-       - 分类：pattern(番型分)/event(事件分)/chicken(鸡分)/bean(豆分)
-   - **禁止混用不同计分体系的字段**（如同时使用 `mult` 和 `fan`）
-   - **必须明确 `fan_table.stacking` 方式**：`multiply`/`add`/`add_fan`/`none`
-
-5. **可见性统一模型**：
-   - 所有牌的可见性必须明确定义：`(default_visibility (state visible/hidden) (to owner/teammates/enemies/all/none))`
-   - 弃用旧版简写如 `face_up/face_down`
-   - 示例：`(default_visibility (state hidden) (to none))` 表示牌墙不可见
-
-6. **特殊机制统一注册**：
-   - 所有创新机制（幺鸡/红中/皮子/翻马/承包等）必须在机制卡注册表中注册：
-     - 代码落点：`(extensions (special_mechanics (mechanic_cards ...)))`
-     - 路径引用：`extensions.special_mechanics.mechanic_cards.<Mechanic_ID>`
-   - 每个机制卡（mechanic）必须包含以下最小字段（零容忍）：
-     - `name`、`category`、`enabled`、`description`、`stage_scope`
-     - `transfer_path`（允许为 `none`，但必须显式给出）
-   - 若处于【创新扩展模式】（Innovation Extension）：
-     - 机制卡必须额外包含闭环四段：`trigger / effect / settle / reset`
-   - `category` 必须为：`wildcard`/`scoring`/`phase_rule`/`settlement`/`other` 之一
-
-
-7. **胡牌事件完整性**：
-   - 必须明确定义 `win_rules.allow_*` 系列（`allow_discard_win`/`allow_self_draw_win`/`allow_rob_kong`/`allow_gang_shoot`/`allow_multi_win`）
-   - 必须在 `post_win_continuation` 中完整定义胡牌后逻辑
-   - 禁止仅写"类似血战"而不展开具体参数
-
-8. **番型可达性验证**：
-   - 大牌型（如四暗刻+单吊、大车轮）必须验证在给定牌组下是否理论可达
-   - 必须设置合理的 `resource_bounds` 限制（如同一点数牌的最大张数）
-   - 禁止定义不可能达成的番型组合
-
-9. **麻将物理守恒原则**：
-   - 摸打即转移：摸牌 = 从牌墙到手牌；打牌 = 从手牌到弃牌区；吃碰杠 = 从弃牌区到吃碰区/杠区
-   - 牌墙不可再生：除非有明确的机制（如"海底回收"），否则牌墙只能减少不能增加
-   - 弃牌区必须单调递增：除非有明确回收机制，否则打出的牌不能回到牌墙
-
-10. **麻将区域先行原则**：
-    - 所有麻将牌（包括特殊牌如幺鸡、红中）必须在 `(setup zones)` 中预先定义来源
-    - 任何涉及牌变动的行为必须指定 `(transfer_path from: X to: Y)`
-    - `pass` 动作必须显式声明为 `(transfer_path none)`
-
-11. **手牌恒定不变量（Hand Size Invariant，红线要求）**：
-   - 除起手阶段和胡牌结算瞬间外，**每位玩家在打出牌后必须严格保持手牌数为基准值**（13张）。
-   - **动态平衡原则**：任何导致手牌增加的机制，必须配套等量的减少机制。
-     - ❌ 错误示例：定义“摸2张功能牌”作为奖励，导致手牌变为14/15张。
-     - ✅ 正确修正：“摸2张”必须配套“打2张”或“弃1张+不摸下一轮”，**net change 必须为 0**。
-   - 每个 `action`（吃/碰/杠/自摸/打牌）必须显式说明其对手牌数量的净影响，并确保后续通过 `discard` 或 `kong_draw` 等操作恢复至基准值。
-   - 在 `(invariants)` 中必须包含如下断言：
-     ```lisp
-     (invariants
-       ; 行牌阶段：打出后手牌恒为13张
-       (hand_size_stable (forall p (-> (in_phase play) (= (zone hand:p) 13))))
-       ; 动态平衡：任何Action前后净变化必须为0 (Action_Draw + Action_Discard = 0)
-     )
-     ```
-   - **严禁**出现“吃后手牌=15”、“摸二不打”等违反手牌守恒的描述。
-
-### 番数与倍数核心区分（v1.3 重点强调）
-
-> ⚠️ **血战/血流麻将设计者必读**：番数(fan)和倍数(mult)是两种完全不同的计分体系，混淆使用将导致严重的计分错误！
-
-#### 核心差异对比表
-
-| 维度 | 番数 (fan) | 倍数 (mult) |
-|-----|-----------|------------|
-| **计算方式** | 得分 = 底分 × 2^番数（指数增长） | 得分 = 底分 × 倍数（线性增长） |
-| **适用玩法** | 国标麻将、竞技麻将 | 血战麻将、血流麻将、四川麻将 |
-| **叠加方式** | 番数相加后指数计算 | 倍数叠乘 |
-| **mGDL字段** | `(fan N)` | `(mult N)` |
-| **stacking** | `"add_fan"` | `"multiply"` |
-| **增长速度** | 极快（1番=2倍，10番=1024倍） | 可控（1倍=1倍，10倍=10倍） |
-
-#### 详细说明与示例
-
-**【番数制 (fan_system)】- 国标麻将**
-
-```lisp
-(scoring (mode "fan_system"))
-(fan_table
-  (stacking "add_fan")  ; 番数相加后指数计算
-  
-  (yaku qingyise (fan 6) (desc "清一色"))
-  (yaku pengpenghu (fan 6) (desc "碰碰胡"))
-  (yaku menqing (fan 2) (desc "门清"))
-)
-```
+# Mahjong 玩法融合 Prompt（Phase-1：既有机制精准融合）
 
-**计算过程**：
-1. 番数相加：6番 + 6番 + 2番 = 14番
-2. 指数计算：2^14 = 16384倍
-3. 最终得分：底分 × 16384
-
-**【倍数制 (multiplier)】- 血战/血流麻将**
-
-```lisp
-(scoring (mode "multiplier"))
-(fan_table
-  (stacking "multiply")  ; 倍数叠乘
-  
-  ;; 普通血战 (2进制)
-  (yaku qingyise (mult 4) (category "special") (desc "清一色(2番=4倍)"))
-  
-  ;; 疯狂血战 (10进制) - 直接填写换算后的倍数
-  (yaku pengpenghu (mult 10) (category "special") (desc "碰碰胡(1番=10倍)"))
-  (yaku qingyise_crazy (mult 100) (category "special") (desc "清一色(2番=100倍)"))
-)
-```
+你是一位**麻将规则策划**与**规则一致性审计员**。本阶段只做“既有机制组合/融合”，目标是：把“底座玩法A”的流程与计分框架作为主干，将“参考玩法B”的既有机制以插件方式融合进来，并确保麻将底层逻辑完全自洽可落地（手牌守恒、吃碰杠、出牌权与轮次、牌墙转移等）。
 
-**计算过程**：
-1. 普通：4倍 × 2倍 = 8倍
-2. 疯狂：100倍(清一色) × 10倍(碰碰胡) = 1000倍
-
-> 💡 **提示**：对于"疯狂"类玩法（1番=10倍，2番=100倍），请直接使用 `multiplier` 模式，并将表格中的最终倍数填入 `mult` 字段，不要使用 `fan` 字段去尝试定义底数。
-
-**【混合制 (hybrid)】- 捉鸡麻将**
-
-```lisp
-(scoring (mode "hybrid"))
-(fan_table
-  (stacking "none")  ; 番型不叠加，仅取最大
-  
-  ;; 番型分（不叠加）
-  (yaku qingyise (mult 15) (category "pattern") (desc "清一色"))
-  (yaku daduizi (mult 10) (category "pattern") (desc "大对子"))
-  
-  ;; 事件分（叠加）
-  (yaku gangkai (mult 6) (category "event") (desc "杠开"))
-  (yaku baoting (mult 15) (category "event") (desc "报听"))
-)
-```
+本阶段优先级：**底层正确性 > 融合准确性 > 输出完整性 > 创新强度**  
+说明：允许做少量“桥接规则”解决冲突，但禁止凭空发明新机制体系。
 
-**计算过程**：
-1. 番型分 = max(15, 10) = 15倍
-2. 事件分 = 6 + 15 = 21倍
-3. 未胡牌玩家输分 = 底分 × (15 + 21) = 底分 × 36
-4. 另外独立计算鸡分、豆分
+---
 
-#### 常见错误示例（必须避免）
+## 资源使用规则（务必遵守）
 
-❌ **错误1：混用 mult 和 fan**
-```lisp
-(yaku qingyise (mult 4) (fan 6))  ; 严重错误！
-```
+1. **规则真理**：所有规则语义以 `.md` 为准（系统注入的 `<REFERENCE_VARIANTS_MD>` 或本项目内玩法 `.md`）。
+2. **mGDL 的定位**：mGDL 仅用于“结构化落地与形式约束”，不得反推/猜测规则细节。
+3. **机制来源限制（Phase-1）**：你只能组合/改写以下来源中已存在的机制：
+   - 底座玩法A的 `.md`
+   - 参考玩法B的 `.md`
+   - `<MECHANISM_LIBRARY>`（麻将机制说明）
+4. **禁止**引入“全新母题机制/自创资源系统/自创牌类”。如果必须做桥接，只能做最小可量化规则（例如：把B的一个结算倍数映射到A的倍数制）。
 
-❌ **错误2：计分模式与字段不匹配**
-```lisp
-(scoring (mode "multiplier"))
-(yaku qingyise (fan 6))  ; 错误！倍数制应使用 mult
-```
+---
 
-❌ **错误3：stacking 方式错误**
-```lisp
-(scoring (mode "fan_system"))
-(fan_table (stacking "multiply"))  ; 错误！番数制应使用 add_fan
-```
+## Phase-1 融合策略（必做）
 
-✅ **正确示例：血战麻将**
-```lisp
-(scoring (mode "multiplier") (base_point 1))
-(fan_table
-  (stacking "multiply")
-  (yaku qingyise (mult 4) (category "special") (desc "清一色"))
-  (yaku zimu (mult 2) (category "event") (desc "自摸"))
-)
-```
+1. **确定底座**：选择A作为底座（流程、胡后模式、计分模式默认继承A）。
+2. **抽取清单**：
+   - 从A抽取：牌组、流程阶段、吃碰杠权限、胡牌结束逻辑、计分模式与番型框架
+   - 从B抽取：要引入的“具体机制条款”（只能抽取明确条款，禁止抽象概念）
+3. **冲突检测与桥接**（必须写清）：
+   - 冲突类型：计分模式/胡后流程/牌组构成/动作权限/轮次控制
+   - 桥接规则：一条冲突最多允许一条桥接规则；必须可量化、可落地、可验证
+4. **落地映射**：每个融合机制必须对应一个 mGDL 落点（`mGDL_path`），并在自然语言中说明它如何影响“牌转移/分数/阶段/出牌权”。
+
+---
+
+## 麻将底层物理守恒（零容忍硬约束）
 
-#### 设计建议
-
-1. **血战/血流麻将**：必须使用倍数制，封顶通常为16-32倍
-2. **国标麻将**：必须使用番数制，封顶通常为8-13番
-3. **捉鸡麻将**：使用混合制，通过 category 区分不同计分维度
-4. **简化麻将**：可使用倍数制 + `stacking="add"` 倍数相加
-
-
-### 牌数与库存显式声明强制要求（防幻觉核心机制）
-
-为杜绝模型在生成过程中因"隐式假设"导致的牌数不一致或库存逻辑缺失，所有输出必须在 **mGDL描述** 和 **自然语言规则说明** 中**显式列出以下数据**，并确保二者严格一致：
-
-- **牌组构成**：
-  - 基础花色：万/筒/条各 N 张
-  - 字牌类型与数量：中/发/白/风牌等
-  - 特殊牌：幺鸡/红中/月亮牌等数量
-  - 总牌数验证：TotalTiles = 基础花色 + 字牌 + 特殊牌
-
-- **初始分布**：
-  - 起手牌数：庄家 N₁ 张，闲��� N₂ 张
-  - 牌墙剩余：Wall_initial = TotalTiles - (N₁ + 3×N₂)
-  - 翻牌区（如有）：Flip_zone_initial = N 张
-  - 总验证：N₁ + 3×N₂ + Wall_initial + Flip_zone_initial = TotalTiles
-
-- **行牌阶段手牌动态守恒**：
-  - 每次操作后手牌数变化必须可追踪，且**最终必须通过打牌恢复至13张**。
-  - 必须在自然语言规则的“游戏流程描述”中，为每种操作明确标注手牌净变化，例如：
-    - **摸牌**：+1 → 需打1张 → 净变化 0（保持13张）
-    - **吃牌**：从弃牌区取1张 + 手中2张组成顺 → 手牌-2 → 需打1张 → 净变化 -1（但打出后恢复13）
-    - **碰牌**：从弃牌区取1张 + 手中2张组成刻 → 手牌-2 → 需打1张 → 净变化 -1
-    - **明杠**：碰后加1张成杠 → 手牌-3 → 补1张（从牌墙）→ 手牌-2 → 需打1张 → 净变化 -1
-    - **暗杠**：4张同牌 → 移出 → 手牌-4 → 补1张 → 手牌-3 → 需打1张 → 净变化 -2（需特别说明）
-  - **强制要求**：在 mGDL 的 `(actions ...)` 模块中，为每个 action 添加中文注释说明 `手牌净变化` 及 `是否需强制打牌`。
-
-
-
-> ✅ **强制要求**：若 `Wall_initial > 0`，则必须在自然语言规则中明确说明 **牌墙中的牌将在何种条件下、通过何种机制被转移**（例如："玩家每回合从牌墙摸1张牌"或"杠后需从牌墙补1张牌"）。禁止出现"牌墙有剩余但无任何使用机制"的设计。
-
-> ❌ **幻觉红线**：若模型输出中出现 `Wall_initial > 0` 但未定义任何从 `wall` 转移牌的 `action` 或 `mechanic`，视为严重违规，必须回退修正。
-
-## 任务说明：分步生成流程
-
-你的任务是严格按照以下四步流程来设计一个全新的麻将游戏。每一步都必须完成，且后一步必须基于前一步的输出。
-
-### 第一步：构思与草拟
-
-- 根据"麻将游戏设计特质要求"，构思核心玩法和创新机制
-- 草拟一个初步的 mGDL 框架，包含 `players`, `tileset`, `phases`, `scoring`, `fan_table` 等基本模块
-- 重点考虑：血战/血流类玩法选择、特殊机制（幺鸡/红中等）、番型体系设计
-
-### 第二步：强制自检与修正（核心步骤）
-
-#### ⚠️ 第0项：mGDL 模块完整性检查（零容忍项）
-
-**mGDL 输出必须包含以下所有核心模块，缺一不可**：
-- [ ] `(game_variant "...")` - 玩法大类
-- [ ] `(players N)` - 玩家数量
-- [ ] `(team_mode ...)` - [v1.4] 组队模式（如有）
-- [ ] `(tileset ...)` - 牌组定义，必须包含：
-  - `(suits {...})` - 基本花色
-  - `(ranks 1..9)` - 牌点范围
-  - `(total N)` - 总牌数
-- [ ] `(extensions ...)` - 扩展机制容器，且必须包含：
-  - [ ] `(special_mechanics ...)`
-  - [ ] `(mechanic_cards ...)`  ; 机制卡统一注册表（零容忍）
-  - [ ] （建议）`(motif_bank ...)` 与 `(state_vars ...)`（创新扩展模式推荐启用）
-
-- [ ] `(seats {...})` - 座位定义
-- [ ] `(turn_order ...)` - 出牌顺序
-- [ ] `(setup ...)` - 游戏准备，必须包含：
-  - `(initial_hand N)` - 起手牌数
-  - `(choose_que (enabled true/false))` - 定缺
-  - `(exchange_three (enabled true/false))` - 换三张
-- [ ] `(actions ...)` - 行为规则，必须包含：
-  - `(allow_chi true/false)` - 允许吃
-  - `(allow_peng true/false)` - 允许碰
-  - `(allow_gang {...})` - 允许杠
-- [ ] `(win_rules ...)` - 胡牌规则，必须包含：
-  - `(allow_discard_win true/false)` - 允许点炮胡
-  - `(allow_self_draw_win true/false)` - 允许自摸
-  - `(post_win_continuation ...)` - 胡牌后规则
-- [ ] `(scoring ...)` - 计分体系
-- [ ] `(fan_table ...)` - 番型与倍数，至少包含5种基础番型
-- [ ] `(settlement ...)` - 结算规则
-- [ ] `(invariants ...)` - 守恒不变量，必须包含：
-  - 牌数守恒公式
-  - 至少3项约束验证
-
-**判定标准**：若任一核心模块缺失 → **FAIL & 必须补全**
-
-#### 第1-16项：语法与语义检查
-
-- [ ] Zone 名称正则通过：`^(wall|hand(:[A-Z]\d+)?|meld(:[A-Z]\d+)?|kong(:[A-Z]\d+)?|discard_pile|flip_zone)$`
-- [ ] **PID/zone 禁止占位符**：最终导出的 mGDL 中不得出现 `<PID>`、`<NextPID>` 等占位符；
-      必须展开为实际 PID（如 A1/A2/A3/A4），zone 使用 `hand:A1`/`meld:A1`/`kong:A1` 等形式。
-- [ ] 所有动作/机制均有合法 `transfer_path`，包括 `pass` 必须为 `none`
-- [ ] 顶层 (phases [...]) 列表禁止使用 *_phase；state_machine / mechanic_cards 内部状态名允许使用 *_phase（但建议仍尽量短名）。
-- [ ] **番型定义与计分模式严格兼容**（v1.3 核心检查）：
-  - 倍数制 (`multiplier`)：所有番型仅使用 `mult`，不使用 `fan`
-  - 番数制 (`fan_system`)：所有番型仅使用 `fan`，不使用 `mult`
-  - 混合制 (`hybrid`)：使用 `mult` + `category` 区分维度
-  - `stacking` 方式与计分模式匹配
-- [ ] 特殊机制在 `extensions.special_mechanics.mechanic_cards.` 中完整注册（v1.3 扩展机制）
-- [ ] 可见性为标准二元结构 `(state visible/hidden) (to audience)`；弃用 `face_up/face_down` 简写
-- [ ] 胡牌事件完整定义：所有 `allow_*` 明确设置
-- [ ] 资源守恒可验算，`invariants.*` 参数齐全
-- [ ] 所有番型规则在后续计分中都被实际使用
-- [ ] 无使用未定义的番型或规则
-- [ ] 所有特殊机制都明确指定了 `phase` 字段
-- [ ] 所有特殊机制都明确指定了 `trigger_condition` 字段
-- [ ] **⚠️ 机制完整性双向映射检查通过**（零容忍项）：
-  - 自然语言"新机制声明"表格中列出的每个机制，在 mGDL 中都有对应实体
-  - mGDL 中定义的每个特殊机制，在自然语言表格中都有说明
-  - 机制数量严格相等，一一对应
-  - 每个机制的 `transfer_path` 和 `visibility_change` 正确定义
-- [ ] **⚠️ 特殊机制统一注册检查通过**（零容忍项）：
-  - 所有创新机制必须在 `extensions.special_mechanics.mechanic_cards.` 中注册
-  - 每个注册项必须包含：`name`、`category`、`implementation_path`、`phase`、`enabled`、`description`
-  - `category` 必须为：`wildcard`/`scoring`/`phase_rule`/`settlement`/`other` 之一
-  - 验证：extensions.special_mechanics.mechanic_cards. 注册数量 = GDL中所有特殊定义的总和
-- [ ] **牌型可达性验证**：
-  - 检查大牌型（如十八罗汉/大威天龙）在给定牌组下是否理论可达
-  - 在 `resource_bounds` 中设置合理上限
-  - 不存在不可能达成的番型组合
-- [ ] **麻将牌墙管理**：
-  - 所有摸牌/补杠动作都有明确的牌墙来源
-  - 牌墙剩余张数不会变为负数
-  - 牌局结束条件与牌墙耗尽逻辑一致
-
-**必须使用"强制自检与最小修改修复模块"对第一步的草稿进行逐项检查。**
-**必须记录下所有的检查结果（PASS/FAIL）和修复轨迹。**
-**特别强调**：机制完整性检查（自检第7项）如出现 FAIL，必须立即修复，不得跳过或延后。
-**只有当所有自检项均为 PASS 时，才能进入下一步。** 如果存在 FAIL，必须根据"最小修改优先级"进行修正，并重新执行自检，直到全部通过。
-
-### 第三步：生成最终 mGDL（折叠显示）
-    
-**输出要求**：
-- 基于通过自检的 mGDL 草稿，生成最终版本。
-- **必须将 mGDL 代码块封装在 HTML 的 `<details>` 标签中**，使其默认为折叠状态。
-- 只有当用户点击展开时，才显示代码。
-- 标签内必须注明：`<summary>点击查看底层逻辑代码 (mGDL v1.3)</summary>`。
-
-**格式示例**：
-<details>
-<summary>点击查看底层逻辑代码 (mGDL v1.3)</summary>
-
-```lisp
-(define_game "NewMahjongVariant"
-    ...
-)
+### A) 手牌数量守恒（红线）
+
+**手牌定义**（引用 `<MECHANISM_LIBRARY>` 1.1 节）：
+- **暗牌**：手中未公开的牌
+- **明牌组**：通过吃/碰/杠形成的公开牌组
+- **手牌位置**：玩家"占用"的牌位数量，**回合结束时恒为 13 个位置**
+
+**守恒公式**（按位置计算）：
+```
+回合结束手牌位置 = 暗牌 + 吃组×3 + 碰组×3 + 明杠组×3 + 暗杠组×4 = 13
 ```
-</details>
 
----
+**说明**：明杠（直杠/补杠）第 4 张来自他人弃牌或补摸，只占 3 位置；暗杠 4 张全来自手牌，占 4 位置。
 
-### 第四步：撰写自然语言规则（核心输出）
-    
-**这是用户最关注的部分，必须作为输出的重点，位于 mGDL 代码块之前或之后均可，但必须显著突出。**
-    
-**输出要求**：
-1. **唯一真理地位**：此部分的描述必须详尽、准确、无歧义，不仅仅是 mGDL 的翻译，更是游戏玩法的**完整说明书**。
-2. **内容完备性**：
-   - **设计思路**：一句话概括玩法核心乐趣（如"极速胡牌"或"超级加倍"）。
-   - **核心规则**：牌组构成、定缺规则、换牌规则、胡牌流程（血战/血流/普通）。
-   - **计分体系**：明确是"倍数制"还是"番数制"，列出主要番型表。
-   - **特殊机制**：详细解释每一个新引入机制的运作方式（如"红中做赖子"、"买马怎么买"、"七星牌怎么用"）。
-   - **机制声明表**：列出所有特殊机制及其对应的 mGDL 实现路径（参照自检表）。
-3. **结构清晰**：使用 Markdown 的标题、列表、加粗等格式，使规则易于阅读。
-4. **防呆说明**：针对可能产生歧义的地方（如"杠后是否摸牌"、"海底牌怎么算"）进行专门说明。
-
-## 强制自检与最小修改修复模块（必须执行）
-
-### 执行约束
-
-在正式输出前，先进行自检。若发现问题，必须按"最小修改优先级"自动修复，再输出最终规则。最终结果必须附带《自检报告》。
-1. 所有规则描述必须为确定性，不得出现范围性表述（禁止"3-5人"、"可扩展到…"等）
-2. 所有人数、牌数、倍数必须为单一整数
-3. 输出必须同时包含：
-   - mGDL 表达
-   - 自然语言表达
-4. 阶段逻辑必须严格遵循 mGDL 语法
-
-### 自检范围
-
-#### 兼容桥：phase命名统一
-
-- 解析时可接受 `choose_que_phase/exchange_phase/play_phase` 作为等价别名
-- **导出前** 必须统一归一到短枚举：`choose_que/exchange_three/play/settle`
-- 若导出不合规 → **FAIL & 自动重写**
-
-#### 机制对照表（Mechanism Crosswalk，硬 Fail）
-
-为防止"自然语言里声明的机制未在 mGDL 实体化"的缺陷，**在正式输出 mGDL 前**，必须生成一张二维对照表，并进行一一核对：
-
-| NAT_name（自然语言机制名） | mGDL_path（实体落点） |
-|---|---|
-| 例：幺鸡赖子 | extensions.special_mechanics.mechanic_cards.YaojiWild |
-| 例：红中杠 | extensions.special_mechanics.mechanic_cards.HongzhongKong |
-| 例：抢杠胡 | win_rules.allow_rob_kong |
-
-**强制要求：**
-1. `NAT_name` 为自然语言部分出现的全部机制/能力/道具的**去重后**集合
-2. `mGDL_path` 必须指向以下任一合法位置：
-   - `extensions.special_mechanics.mechanic_cards.<Mechanic_ID>`
-   - `win_rules.<rule_node>`
-   - `actions.<action_node>`
-3. 若任一行缺失 `mGDL_path` 或指向不存在的节点 → **FAIL & 自动修复**
-4. 机制在 `Crosswalk` 完成映射后，必须在 mGDL 的 `invariants` 通过：
-   - `(no_undefined_mechanic_names true)`
-   - `(all_mechanisms_have_phase_binding true)`
-   - `(all_special_have_transfer_path true)`
-
-#### 特殊机制统一注册要求
-
-**核心原则**：`extensions.special_mechanics.mechanic_cards.` 作为所有创新机制的"统一注册表/索引目录"
-无论机制实际定义在何处（wildcard / actions / phases.rules / scoring），都**必须**在 `extensions.special_mechanics.mechanic_cards.` 中注册。
-
-**注册格式示例**（mGDL中）：
-```lisp
-(extensions
-  ...
-  (special_mechanics
-    (mechanic_cards
-      ; 示例1：幺鸡赖子机制
-      (mechanic "YaojiWild"
-        (name "幺鸡赖子")
-        (category "wildcard")
-        (stage_scope "global")
-        (enabled true)
-        (description "幺鸡（1条）可作为赖子替代任意牌")
-        (implementation_path "extensions.special_mechanics.mechanic_cards.YaojiWild")
-        (trigger (hook "on_setup") (when "true"))
-        (effect  (state_update ...) (tile_ops ...) (action_lock ...) (score_ops ...))
-        (settle  (mode "end_round") (merge_rule "stack") (notes "..."))
-        (reset   (hook "end_round") (do ...))
-        (transfer_path none))
-
-      ; 示例2：红中杠机制
-      (mechanic "HongzhongKong"
-        (name "红中杠")
-        (category "scoring")
-        (stage_scope "scoring")
-        (enabled true)
-        (description "每打出一张红中算作一个明杠，结算时计分")
-        (implementation_path "extensions.special_mechanics.mechanic_cards.HongzhongKong")
-        (trigger (hook "on_discard") (when "discarded_tile == HONGZHONG"))
-        (effect  (score_ops (("additive" "+X"))))
-        (settle  (mode "end_round") (merge_rule "stack") (notes "..."))
-        (reset   (hook "end_round") (do ...))
-        (transfer_path none))
-    )
-  )
-)
-
-
-**自检要求**
-1. 扫描mGDL所有模块，识别所有非标准定义：
-  - extensions.special_mechanics.mechanic_cards. 中的所有条目
-  - win_rules 中的特殊胡牌规则
-  - scoring 中的特殊计分规则
-  - fan_table 中的特殊番型
-2. 逐一确认每个特殊定义在 extensions.special_mechanics.mechanic_cards. 中有对应注册
-3. 数量验证：extensions.special_mechanics.mechanic_cards. 注册数 = 实际特殊机制数
-4. 若有遗漏 → FAIL & 自动补全注册
-
-#### 区域与转移路径（强制且可机读）
-**核心原则**：转移是唯一行为
-1. 路径强制声明：每个 (action) 和 (mechanic) 必须包含有效的 (transfer_path from: X to: Y)。pass 动作必须声明为 (transfer_path none)。
-2. 牌墙先行原则：所有在游戏中出现的牌，其初始来源必须在 (setup zones) 中明确定义。
-3. 禁止凭空生成牌：任何牌的出现，必须有明确的转移路径，禁止在未定义牌墙或区域的情况下，直接将牌加入手卡或打出到弃牌区。
-4. 区域守恒动态校验：在模拟推演中，任一动作执行后，必须满足 (= (sum of all zones) TotalTiles)。
-
-#### 麻将牌墙管理检查
-1. 摸牌路径合法性：
-  - 所有摸牌动作必须有明确的牌墙来源：(transfer_path from: wall to: hand:<PID>)
-  - 牌墙张数不能为负：每摸一张牌，检查 wall_count >= 0
-  - 检查项：验证所有摸牌路径指向有效牌墙
-  - FAIL条件：摸牌路径未定义或牌墙已空
-  - 修复：添加牌墙补充机制或调整摸牌条件
-2. 杠补牌一致性：
-  - 所有杠（暗杠/直杠/补杠）必须在牌墙有足够牌时才能进行
-  - 杠后必须从牌墙补一张牌：(transfer_path from: wall to: hand:<PID>)
-  - 检查项：验证杠动作与补牌路径的绑定
-  - FAIL条件：杠后未定义补牌路径
-  - 修复：为每个杠类型添加���牌路径
-
-#### 麻将牌数自检（强制且可机读）
-1. 统一记号：
-  - suits ∈ {"wan", "tong", "tiao"}：基础花色
-  - honor_types：字牌类型数量
-  - special_tiles = [(name_i, count_i)]：额外特殊牌清单
-  - players = P：玩家人数（麻将固定为4）
-  - dealer_hand：庄家起手张数
-  - non_dealer_hand：闲家起手张数
-  - flip_zone_init：翻牌区初始张数（如有）
-2. 总牌量公式： TotalTiles = 4 × 9 × |suits| + 4 × honor_types + Σ special_tiles.count
-3. 局需求（一次性）： Need_initial = dealer_hand + 3 × non_dealer_hand + flip_zone_init
-4. 牌墙（开局可供后续摸牌等）： Wall_initial = TotalTiles - Need_initial 
-  - 约束：
-    - 如果游戏没有任何从 wall 摸牌的机制，则 Wall_initial 必须等于 0。
-    - 如果游戏有摸牌机制，则 Wall_initial ≥ Max_extra_draw。
-5. 动态期望（机制/事件上界预算）：
-  - 对所有会"摸牌/生成牌"的机制，给出最坏上界并相加： Max_extra_draw = Σ mechanisms.max_draw_upper_bound 
-  - 通过计算确保每个机制的可实现性，避免违反牌墙初始值的条件。 
-  - 约束：Wall_initial ≥ Max_extra_draw（若不满足→进入"最小修改优先级"）
-6. 守恒不变量（全过程）： 在任意阶段 t，必须满足： Hands_t + Melds_t + Kong_t + Discard_t + Wall_t = TotalTiles (zone hand)_t + (zone meld)_t + (zone kong)_t + (zone discard_pile)_t + (zone wall)_t = TotalTiles 且所有分量 ≥ 0。
-
-#### 番型可达性自检
-1. 同一点数牌张数检查：
-  - 检查番型是否要求超过理论最大张数（如18罗汉要求4张相同字牌，但若字牌每种只有3张则不可达）
-  - 验证：required_count ≤ same_rank_max
-  - 同一点数最大张数 = 4 × 麻将牌副数 + 赖子可替代数量
-  - FAIL条件：番型要求超过物理上限
-  - 修复：调整番型要求或增加牌副数
-2. 组合番型冲突检查：
-  - 检查多个番型组合是否存在逻辑冲突（如清一色+混一色）
-  - 检查番型叠加规则是否合理
-  - FAIL条件：存在无法同时满足的番型组合
-  - 修复：添加互斥规则或调整番型定义
-3. 大牌型验证：
-  - 针对十八罗汉、大威天龙、万中无一等大牌型，进行理论可达成性验证
-  - 计算理论出现概率，确保不低于1/1000000（极罕见大牌可放宽）
-  - FAIL条件：理论概率为0
-  - 修复：调整牌组构成或番型要求
-
-#### 麻将特殊规则自检
-1. 胡牌规则一致性：
-  - 验证 post_win_continuation 与玩法大类一致
-  - 血战类：(winner_exit true) (end_when_third_player_wins true)
-  - 血流类：(winner_exit false) (keep_turn_order true)
-  - 检查胡牌要求与番型体系一致
-  - FAIL条件：规则冲突
-  - 修复：统一规则体系
-2. 赖子规则完整性：
-  - 若启用赖子（幺鸡/红中/皮子），必须明确定义：
-    -- 赖子确定方式（固定/翻牌）
-    -- 赖子功能范围（可替代哪些牌）
-    -- 赖子限制（是否可吃碰杠/打出）
-    -- 赖子在胡牌时的特殊规则
-  - FAIL条件：赖子定义不完整
-  - 修复：补全赖子规则定义
-3. 庄家规则验证：
-  - 验证庄家确定方式与连庄规则
-  - 检查庄家优势是否量化（如起手14张）
-  - FAIL条件：庄家规则模糊
-  - 修复：明确庄家权益与流转规则
-
-#### 创新机制闭环自检（避免“罗列堆叠”）
-1. 以 `extensions.special_mechanics.mechanic_cards.` 注册项为准，列出所有新增机制，并逐一写出：状态变量 / 触发器 / 效果 / 奖励(或惩罚) / 反制(或风险)
-2. 若任一机制缺少上述任一要素 → FAIL & 直接删掉该机制或补全闭环
-3. 若主机制 > 1 或辅机制 > 1 → FAIL & 按“最小修改优先级：简化规则”合并/删除
-4. 若新增机制无法在 Crosswalk 找到合法落点 → FAIL & 回退改为可实体化版本（优先用 phase_rule / action 参数化替代）
-
-#### 化学反应链路自检（策略增量）
-1. 用 3 句描述：新机制让玩家多了什么选择？对手如何应对？为什么分数/胜负上成立？
-2. 若只增加随机性或只是加倍 → FAIL & 重新设计为策略型触发（带条件/成本/反制）
-
-#### 最小修改优先级（麻将专用）
-1. 收敛机制：限制大牌型出现条件/频率，添加互斥规则
-2. 调整牌组：增减特殊牌数量，调整花色构成
-3. 修改番型：降低不可达大牌型的倍数，或提高常见番型价值
-4. 简化规则：移除相互冲突的特殊机制
-5. 增加牌副：从一副牌增至两副牌（需在平衡性分析中说明影响）
-6. 重构流程：调整游戏阶段顺序，简化复杂交互
-
-## 麻将游戏设计特质要求
-### 目标玩家群体
-1. 休闲麻将玩家和中级爱好者
-2. 特别适合喜欢血战/血流但希望有新鲜感的玩家
-3. 需要容易上手但有足够深度的游戏
-
-### 游戏复杂度要求
-1. 中等复杂度（比标准血战稍复杂，但不��过专业竞技麻将）
-2. 核心机制不超过4个
-3. 新玩家能在5分钟内理解基本规则
-
-### 游戏时长要求
-1. 8-15分钟完成一局
-2. 适合碎片化时间娱乐
-3. 有明确的节奏变化，避免中后期拖沓
-
-### 创新点要求
-1. 必须包含一个全新的核心机制（非简单组合现有机制）
-2. 必须增强玩家间的互动性（不只是轮流出牌）
-3. 避免过度依赖运气，增加策略决策点
-4. 不能完全复制已知麻将玩法的核心机制
- 
-### 平衡性要求
-1. 庄家优势应在10%-15%之间
-2. 各种胡牌方式（平胡/碰碰胡/清一色等）应有合理价值分布
-3. 爆发型大牌需有相应风险平衡
-4. 赖子/特殊牌不应使游戏完全随机化
-
-### 其他特定要求
-1. 必须兼容移动端操作
-2. 应有清晰的阶段性目标（如：前期布局、中期攻防、后期决胜）
-3. 需考虑4人游戏的平衡性
-4. 倍率系统应有上限，避免极端结果
-5. 必须明确说明胡牌后是"血战"（胡家退出）还是"血流"（继续游戏）模式
-
-## 输出格式
-请严格按照以下格式输出：
+1. 默认节奏（来自 `<MECHANISM_LIBRARY>`，除非底座玩法A明确覆写）：
+   - 标准起手牌为 13 张；庄家开局可为 14（必须明确"仅首轮首家多1张"）
+   - 默认行牌节奏为 "摸 1 → 打 1"，并在回合结束回到稳定手牌数（通常为 13）
+2. 允许的例外（必须显式写入规则与表格，并保持闭环）：
+   - 吃/碰后：默认"只打不摸"（除非规则明确允许补摸/补牌）
+   - 杠后：必须补牌（补摸/补花）后再打 1 张
+   - 若引入"连续摸牌/摸三打三"等机制：必须明确本回合"摸 N → 打 N（或等价闭环）"，并确保回合结束回到稳定手牌数
+3. 禁止出现（硬性 FAIL）：
+   - 出了一张牌但手牌数量不变（未说明牌去向与替代来源）
+   - 回合动作序列结束后手牌无法回到稳定值（例如 13→14→13 是最常见闭环；特殊机制也必须闭环）
+   - 摸/打/吃/碰/杠导致手牌或牌墙流转"凭空增减"，无法在 transfer 与手牌净变化中解释
 
-## 可控迭代：Analyse 模式（单问题迭代，强制）
+**各动作位置变化速查**（引用 `<MECHANISM_LIBRARY>` 第五节）：
 
-当且仅当用户输入中包含：
-`<ANALYSE_MODE>true</ANALYSE_MODE>`
+| 动作 | 位置变化 | 回合结束位置 |
+| --- | --- | --- |
+| 摸牌→打牌 | 13→14→13 | 13 |
+| 吃/碰→打牌 | 13→14→13 | 13 |
+| 明杠→补摸→打牌 | 13→13→14→13 | 13 |
+| 暗杠→补摸→打牌 | 13→13→14→13 | 13 |
+| 补杠→补摸→打牌 | 14→13→14→13（补杠发生在摸牌后）| 13 |
 
-你必须进入【Analyse 模式】，遵守以下规则（用于多轮可控迭代，而不是一次性生成大稿）：
-1. **只允许做需求澄清与方案收敛**：不输出 mGDL、不输出完整自然语言规则、不输出自检报告。
-2. **严格单问题迭代**：每轮只能问 1 个“当前最重要”的澄清问题；禁止一次列出多个问题。
-3. **每轮必须输出更新后的 DesignState(JSON)**：把你已确认的信息写入 JSON；未知信息写入 `open_questions`。
-4. **退出条件**：当 `open_questions` 为空，或只剩“用户可选项”（非阻塞）时，输出一句 `READY_TO_GENERATE: true`；否则 `READY_TO_GENERATE: false`。
+### B) 吃碰杠与轮次影响必须显式
 
-Analyse 模式下的输出格式固定为：
-- 一句话总结当前理解（≤60字）
-- 本轮唯一问题（只问1个）
-- 思维日志（本轮增量，≤200字）：只解释“本轮为什么问这个问题/它影响哪些设计选择/你打算如何收敛创新”，不得展开完整规则
-- ```json DesignState ```（合法JSON）
-- `READY_TO_GENERATE: true/false`
+必须对齐 `<MECHANISM_LIBRARY>` 的基础逻辑（除非底座玩法A明确覆写且不破坏守恒）：
+- 同一轮优先级：胡牌 ＞ 碰牌 ＞ 杠牌 ＞ 吃牌
+- 吃：仅能吃上家牌；碰/杠：可对任意玩家
+- 胡牌触发方式：以“自摸/点炮”为基础；若引入“抢杠胡/一炮多响”等，必须说明其如何归类到自摸/点炮以及对应结算与轮次处理
+- 行牌顺序：庄家 → 下家 → 对家 → 上家；若发生碰/吃，则由吃/碰者继续出牌；若发生杠，则由杠者补牌后继续出牌（出牌顺序不变，只改变“当前出牌权”）
 
-**⚠️ Analyse 模式的思维日志要求（硬性）**
-- 必须明确：本轮问题的“目的”（解决哪个不确定点）
-- 必须明确：它将影响的“创新旋钮”（触发/代价/收益/反制/计分/流程中的哪一处）
-- 必须避免：给出两条以上的新问题，或提前输出完整规则细节
+自然语言规则中必须包含：**《动作—手牌变化—轮次影响表》（硬性）**，至少包含以下动作（不可省略；不允许则写 N/A 并说明原因）：
+- 摸牌、打牌、吃、碰、直杠(明杠)、补杠、暗杠、杠后补牌
 
-### 思考与自检过程
-请在此处用自然语言描述：
-  - 你执行了哪些关键检查
-  - 发现了哪些 FAIL 项
-  - 如何按"最小修改优先级"进行修复
-  - 最终确认所有项已通过：（无需包含结构化 [PASS/FAIL] 表格） 
+表格列必须包含：
+- 牌来源→去向（transfer）
+- 手牌净变化（净变化必须能回到稳定值）
+- 是否强制打1张恢复13
+- 出牌权/下一手归属（轮次控制）
 
-### 设计日志（创新推演摘要）
-请用“可审核的决策记录”替代泛泛的灵感描述，必须包含：
-1. **目标体验**：你希望新玩法比底座玩法多出什么“策略选择/互动张力”（≤80字）
-2. **约束清单**：列出 5 条不可破坏约束（例如：手牌守恒、计分体系统一、牌墙不为负、核心机制≤2 等）
-3. **候选创新方案 A/B/C（至少2个）**：每个方案必须写清：
-   - 状态变量（≤2个） / 触发条件 / 代价 / 奖励或惩罚 / 反制或风险 / 影响的决策点（摸/打/吃碰杠/听/胡/结算）
-4. **选择理由**：你最终选用哪个方案，为什么放弃其他方案（必须引用上面的约束与风险）
-5. **推演摘要**：给出 1 个具体回合示例（玩家选择→对手应对→为何分数/胜负成立）
-6. **落地映射（Crosswalk）**：列出“创新机制名 → mGDL_path → transfer_path(若有)”的对照表，确保可实体化
+### C) 最小回合推演（硬性）
 
-### DesignState（JSON，可机读）
-请输出一个 JSON 作为“中间表示”，用于后续多轮迭代的定向修改。要求：
-1. 必须是合法 JSON（不要写注释，不要用省略号）
-2. 字段尽量完整，未知时填空字符串或空数组
-3. `mechanics[].mgdl_path` 必须是点号路径（不要写到 mGDL 代码里）
+必须提供 3 段 **《最小回合推演》**（每段 ≤6 行），并在每行标注手牌数量：
+1. 普通回合：摸1打1
+2. 碰回合：他人打出→我碰→我打1
+3. 杠回合：我杠→补1→我打1
+
+若你引入了"连续摸牌/摸三打三/海底漫游/海捞阶段"等改变默认摸打节奏的机制，必须额外提供 1 段对应机制的最小推演（≤6 行），同样标注手牌数量。
+
+### C.1) 特殊节奏机制闭环约束（引用 `<MECHANISM_LIBRARY>` 第二节）
+
+| 机制 | 闭环规则 | 回合结束手牌 |
+| --- | --- | --- |
+| 摸三打三 | 摸 3 张 → 打 3 张 | 13 张 ✅ |
+| 海底漫游 | 摸海底牌 → 打 1 张 或 胡牌；放弃则手牌不变 | 13 张 或 胡牌 ✅ |
+| 海捞阶段 | 各抓 1 张（不打牌）→ 直接判定胡牌或流局 | 14 张（终结阶段，无需回到 13）✅ |
+| 连续摸牌 | 摸 N 张 → 打 N 张 | 13 张 ✅ |
+
+若引入上述机制，必须在自然语言规则中显式写明：
+1. 触发条件
+2. 动作序列（完整闭环）
+3. 中间状态是否允许吃/碰/杠/胡
+4. 对应的最小推演段落
+
+### C.2) 争议机制处理约束（引用 `<MECHANISM_LIBRARY>` 第三节）
+
+若引入以下机制，必须在规则中显式说明处理方式：
+
+| 机制 | 必须说明的内容 |
+| --- | --- |
+| 抢杠胡 | (1) 算自摸还是点炮？→ 点炮 (2) 杠是否生效？→ 不生效 (3) 补牌是否发生？→ 不发生 (4) 轮次归属 |
+| 一炮多响 | (1) 采用哪种规则？（全响/头家优先/禁止）(2) 结算方式 (3) 轮次归属 |
+| 赖子牌 | (1) 哪些牌是赖子？(2) 能否用于杠？(3) 是否影响番型计算？|
+
+### C.3) 复杂场景处理约束（引用 `<MECHANISM_LIBRARY>` 第三（续）节）
+
+若玩法涉及以下复杂场景，必须在规则中显式说明处理流程：
+
+#### 连续碰杠混合场景
+
+| 场景 | 必须说明的内容 |
+| --- | --- |
+| 连续碰 | 每次碰后必须打牌，不允许碰后直接再碰；碰 A 后打 B，此时 B 可被他人碰/杠/吃/胡 |
+| 碰后杠 | 碰后打出的牌被他人响应后，轮次转移给响应者；原碰者不保留出牌权 |
+| 杠后碰 | 杠者补摸后打出的牌可被他人碰；碰成功则出牌权转移给碰者 |
+| 连续杠 | 允许补摸后选择再杠而非打牌；每次杠都需补摸，连续杠时只有最后一次打牌 |
+
+**连续场景位置守恒公式**：
+- 连续 N 次碰：最终位置 = 13（每次碰+3明牌，打1张，净增2位置×N，但暗牌相应减少）
+- 连续 N 次明杠：最终位置 = 13（明杠不额外占位置）
+- 连续 N 次暗杠：最终位置 = 13 + N（每次暗杠额外占1位置）
+
+#### 抢杠胡完整流程
+
+抢杠胡发生时的完整决策树：
 
-```json
-{
-  "base_variants": ["底座玩法名"],
-  "fusion_variants": ["融合玩法名"],
-  "new_variant_name": "新玩法名",
-  "game_variant": "blood_war|blood_flow|round|multi_round|custom",
-  "players": 4,
-  "scoring_mode": "multiplier|fan_system|hybrid",
-  "tileset": {
-    "suits": ["wan","tong","tiao"],
-    "honors": 0,
-    "special_tiles": [{"name":"红中","count":6}],
-    "total": 114
-  },
-  "core_constraints": [
-    "手牌守恒：回合结��回到13张",
-    "牌数守恒：所有区域之和=TotalTiles"
-  ],
-  "mechanics": [
-    {
-      "name": "机制名",
-      "type": "core|aux",
-      "state_vars": ["变量1"],
-      "phase": "setup|play|settle|global",
-      "trigger": "触发条件（确定性）",
-      "cost": "代价/限制（确定性）",
-      "reward_or_penalty": "奖励/惩罚（可量化）",
-      "counterplay": "对手如何应对/反制",
-      "mgdl_path": "extensions.special_mechanics.mechanic_cards.<ID>",
-      "transfer_path": "from: X to: Y|none"
-    }
-  ],
-  "open_questions": []
-}
+```
+玩家 A 宣告补杠
+    ↓
+系统暂停，询问其他玩家是否胡牌
+    ├─ 有人宣告胡 → 抢杠胡生效
+    │   ├─ 杠不生效（A 的碰组保持不变）
+    │   ├─ A 不补摸
+    │   ├─ 算 A 点炮（被抢杠的牌视为 A 打出）
+    │   └─ 结算后：血战模式→胡牌者退出，A 继续；一局一胡→本局结束
+    │
+    └─ 无人胡 → 补杠正常生效
+        ├─ 碰组变为杠组
+        ├─ A 补摸 1 张
+        └─ A 打 1 张，轮次继续
 ```
 
-### 游戏名称
-[游戏名称]
+#### 多人同时响应处理
 
-### 游戏理念
-[设计理念和创新点，200字以内]
+当一张牌被打出，多人同时可响应时的优先级裁决：
 
-### mGDL描述
-####生成前必读：完整度参照标准
-在开始编写mGDL前，请在心中回顾麻将游戏mGDL通用语法_v1.3.txt的规则和 幺鸡血战_mGDL.txt 示例的详细程度，你的输出必须至少达到相同的细节水平：
-
-#### 参照示例的完整度标准：
-1. 牌组定义（tileset）
-  - 禁止：(tileset (suits {"wan" "tong" "tiao"})) ← 只有花色
-  - 参照：示例文件第15-25行，明确列出所有牌类型、数量、特殊牌
-  - 要求：定义时必须包含花色、点数范围、字牌、特殊牌等完整信息
-2. 特殊机制（extensions.special_mechanics.mechanic_cards.）
-  - 禁止：(extensions.special_mechanics.mechanic_cards. (yaoji (enabled true))) ← 只有启用标志
-  - 参照：示例文件第30-45行，每个机制有完整参数
-  - 要求：定义时必须包含详细规则、转移路径、可见性等
-3. 番型表（fan_table）
-  - 禁止：; 番型定义（略，同标准血战） ← 严重错误！
-  - 参照：示例文件第100-150行，为每个番型单独定义
-  - 要求：每个番型都要有独立条目，包含番数/倍数、描述、条件等
-4. 游戏阶段（phases）
-  - 禁止：(phases ["play" "settle"]) ← 只有阶段名
-  - 参照：示例文件第60-80行，每个阶段有详细规则
-  - 要求：每个阶段至少包含5-10行的具体规则定义
-
-5. 行为规则（actions）
-  - 禁止：(actions (allow_chi true)) ← 仅开关无细节
-  - 参照：四川血战示例第120-135行，每个 action 有 transfer_path + hand effect 注释
-  - 要求：每个 action 必须包含：
-    - `(transfer_path from: X to: Y)`
-    - 中文注释说明 **手牌数量变化** 和 **是否触发强制打牌**
-  - 示例：
-    ```lisp
-    (action chi
-      (transfer_path from: discard_pile to: meld:<PID>)
-      ; 吃：取1张入 meld 区，手牌净减少2张（因3张顺子移出），必须打出1张以恢复13张
-      (requires_discard true)
-    )
-    ```
-6. 胡牌规则（win_rules）
-  - 禁止：(win_rules (allow_discard_win true)) ← 只有1个参数
-  - 参照：示例文件第85-95行，胡牌规则有完整定义
-  - 要求：必须完整定义允许的胡牌类型、胡牌后规则等
-
-#### 生成策略：
-1. 先在心中构建完整的游戏逻辑
-2. 先从参考玩法 .md 中抽取：牌组、流程、胡牌、计分、特殊机制与限制（内容真理）
-3. 再参考通用语法规范确定 mGDL 语法正确性（语法约束）
-4. 最后（可选）参考 mGDL 示例确保每个模块的“结构完整度”，但不得照抄规则数值（语法范式）
-4. 逐模块编写，每个模块的细节要合理、充分、符合逻辑
-5. 严禁为了"节省篇幅"而省略任何模块的详细定义
-
-[在此处插入完整的mGDL描述，且加入中文注释增强可读性] 
-
-#### ⚠️ mGDL 完整性强制要求： 
-mGDL 必须包含以下所有核心模块（对应硬自检第0项）：
-1. (game_variant "...") - 玩法大类
-2. (players N) - 玩家数量
-3. (tileset ...) - 牌组定义
-4. (extensions ...) - 扩展机制（必须含 special_mechanics + mechanic_cards）
-5. (seats {...}) - 座位定义
-6. (turn_order ...) - 出牌顺序
-7. (setup ...) - 游戏准备
-8. (actions ...) - 行为规则
-9. (win_rules ...) - 胡牌规则
-10. (scoring ...) - 计分体系
-11. (fan_table ...) - 番型与倍数
-12. (settlement ...) - 结算规则
-13. (invariants ...) - 守恒不变量
-严禁省略任何核心模块！ 即使 mGDL 很长，也必须完整输出。 在 (setup) 或 (tileset) 附近添加牌数验证的中文注释，便于人工核对。
+| 优先级 | 响应类型 | 处理规则 |
+| --- | --- | --- |
+| 1（最高）| 胡牌 | 一炮多响时按规则处理（全响/头家优先/禁止）|
+| 2 | 碰牌 | 仅一人可碰，距离出牌者最近的玩家优先 |
+| 3 | 杠牌 | 同碰牌规则 |
+| 4（最低）| 吃牌 | 仅下家可吃，与其他响应冲突时被覆盖 |
 
+**一炮多响的三种规则**：
+1. **全响**：所有胡牌者均可胡，点炮者向每位胡牌者分别结算
+2. **头家优先**：按出牌顺序，最先轮到的胡牌者独胡
+3. **禁止**：多人可胡时，该牌作废，无人可胡
 
-### 自然语言规则说明
-[请严格按照以下结构撰写（所有内容默认展开，禁止使用折叠）：]
-1. 新机制声明（⚠️ 核心创新展示区，必须完整）
-- 格式要求：必须使用以下表格格式，逐个列出本游戏的所有特殊机制：
-机制名称 ｜ 核心功能 ｜ 使用阶段 ｜ 触发条件 ｜ 实际定义位置 ｜ mGDL注册路径
-例：幺鸡赖子 ｜ 1条可替代任意牌 ｜ 全局 ｜ 胡牌时 ｜ extensions.special_mechanics.mechanic_cards..yaoji ｜ extensions.special_mechanics.mechanic_cards..YaojiWild
-例：定缺换牌 ｜ 选择缺一门花色后换3张牌 ｜ 准备阶段 ｜ 定缺后 ｜ setup.exchange_three ｜ extensions.special_mechanics.mechanic_cards..ExchangeThree
- 
-- 强制要求： 
-a. 完整性：表格必须包含本游戏的所有创新机制，不得遗漏 
-b. 实际定义位置：标注机制在mGDL中的实际定义位置 
-c. mGDL注册路径：标注机制在 extensions.special_mechanics.mechanic_cards. 中的注册路径 
-d. 详细展开：表格下方必须对每个机制进行详细说明：
-  - 机制的战略价值和游戏体验影响
-  - 具体的使用方法和限制条件
-  - 与其他机制或规则的交互关系
-  - 使用示例（至少1个具体场景） 
-e. 禁止模糊表述：严禁使用"某些"、"部分"、"可能"等模糊词汇 
-f. 后续引用标记：每个机制说明的末尾必须标注"→ 详见【第3节-游戏流程-[阶段名]】"
-g. **机制具象化（Concreteness Check）**：
-  - ❌ 模糊：获得“某种资源”、“特殊能力”。
-  - ✅ 具象：获得“1枚金币（Score+10）”、“摸牌阶段多摸1张”。
-  - 严禁使用未定义的抽象概念，所有机制必须落地为：牌的转移、分数的增减、或阶段的改变。
-
-2. 基础规则描述
-a. 牌组构成:
-  - 基础花色：[列出万/筒/条数量]  
-  - 字牌类型与数量：[列出中/发/白/风牌等]
-  - 特殊牌：[列出幺鸡/红中/月亮牌等数量]
-  - 总牌数验证：[计算验证]
-b. 玩家与座位:
-  - 玩家人数：固定4人
-  - 座位顺序：[说明]
-  - 庄家确定方式：[说明]
-c. 发牌后库存显式声明（强制):
-- 庄家：[N] 张
-- 闲家1：[M] 张
-- 闲家2：[M] 张
-- 闲家3：[M] 张
-- 牌墙剩余：[W] 张
-- 翻牌区（如有）：[F] 张
-- 总计验证：N + 3×M + W + F = [TotalTiles]（✅ 符合）
-d. 牌的大小与关系:
-- 花色大小：[如有]
-- 点数大小：1<2<...<9
-- 特殊关系：[如连续关系/同点关系等]
-
-3. 游戏流程描述
-a. 流程总述：需描述游戏的全部流程阶段，必须包含明确的庄家确定规则和牌局结束条件 
-b. 分阶段描述：对每个阶段玩家的操作进行详细描述:
-  - 准备阶段（定缺、换三张等）
-  - 行牌阶段（摸打顺序、吃碰杠胡规则）
-  - 结算阶段（胡牌类型、分数计算、连庄规则）
-
-4. 游戏得分体系
-a. 计分模式：明确说明采用倍数制/番数制/混合制 
-b. 基础分数：基础分值、自摸/点炮倍率、起胡和封顶 
-c. 番型计分：详细列出番型与对应分值
-
-5. 术语与新物品词典
-[按以下格式列出所有特殊术语] 
-名称：[术语名] 
-作用：[功能说明] 
-时机：[使用阶段] 
-触发：[触发条件] 
-代价：[代价说明] 
-优先级：[优先级说明] 
-限制：[限制条件] 
-示例：[使用案例] 
-失败处理：[失败情况处理] 
-转移路径：[from: X to: Y] 
-可见性变更：[to: {audience} on_target: true/false]
-
-## 技术附录：《自检报告》
-
-<details>
-<summary>点击展开，完整的《自检报告》（开发者/审核专用）</summary>
-
-## 麻将mGDL自检报告 v1.3
-
-### 0) **mGDL 模块完整性检查**（零容忍项）
-
-**核心模块检查清单（必须全部为 PASS）：**
-- game_variant 定义 → [PASS/FAIL]
-- players 定义 → [PASS/FAIL]
-- tileset 定义（含 suits/ranks/honors/total） → [PASS/FAIL]
-- extensions.special_mechanics.mechanic_cards. 定义 → [PASS/FAIL]
-- seats 定义 → [PASS/FAIL]
-- turn_order 定义 → [PASS/FAIL]
-- setup 定义（含 initial_hand/choose_que/exchange_three） → [PASS/FAIL]
-- actions 定义（含 allow_chi/allow_peng/allow_gang） → [PASS/FAIL]
-- win_rules 定义（含 allow_discard_win/allow_self_draw_win/post_win_continuation） → [PASS/FAIL]
-- scoring 定义 → [PASS/FAIL]
-- fan_table 定义（至少5种番型） → [PASS/FAIL]
-- settlement 定义 → [PASS/FAIL]
-- invariants 定义（含牌数守恒公式） → [PASS/FAIL]
-
-**判定标准**：
-- 任一模块为 FAIL → **整体 FAIL & 必须立即补全缺失模块**
-- 全部模块为 PASS → 整体 PASS，继续后续检查
-
-**最终结论**：[PASS/FAIL]
-**若 FAIL，缺失的模块列表**：[列出所有缺失模块名称]
-
-### 1) **麻将牌数自检表**（机读）
-
-**基础参数**：
-- suits = { "wan" "tong" "tiao" }
-- honor_types = [count of enabled honors]
-- special_tiles = [(name_i, count_i)]
-- players = 4
-- dealer_hand = ?
-- non_dealer_hand = ?
-- flip_zone_init = ?
-
-**计算验证**：
-- TotalTiles = 4 × 9 × |suits| + 4 × honor_types + Σ special_tiles.count = ?
-- Need_initial = dealer_hand + 3 × non_dealer_hand + flip_zone_init = ?
-- Wall_initial = TotalTiles - Need_initial = ?
-
-**约束检查**：
-- Wall_initial ≥ 0 → [PASS/FAIL]
-- Max_extra_draw = ? (杠/补牌等机制上界)
-- 约束：Wall_initial ≥ Max_extra_draw → [PASS/FAIL]
-
-**守恒不变量**：
-- Hands_t + Melds_t + Kong_t + Discard_t + Wall_t = TotalTiles → [PASS/FAIL]
-- 所有区域计数 ≥ 0 → [PASS/FAIL]
-
-### 2) **牌墙管理检查**
-
-**摸牌路径合法性**：
-- 所有摸牌动作有明确牌墙来源 → [PASS/FAIL]
-- 牌墙张数不为负 → [PASS/FAIL]
-
-**杠补牌一致性**：
-- 所有杠动作有明确补牌路径 → [PASS/FAIL]
-- 牌墙足够支持最大杠数 → [PASS/FAIL]
-
-**牌局结束条件**：
-- 牌墙耗尽时牌局结束条件明确定义 → [PASS/FAIL]
-
-### 3) **胡牌规则一致性检查**
-
-**玩法大类匹配**：
-- game_variant 与 post_win_continuation 逻辑一致：
-  - 血战类：winner_exit=true, end_when_third_player_wins=true → [PASS/FAIL]
-  - 血流类：winner_exit=false, keep_turn_order=true → [PASS/FAIL]
-
-**胡牌条件完整性**：
-- 胡牌要求与番型体系一致 → [PASS/FAIL]
-- 胡牌后规则完整定义 → [PASS/FAIL]
-
-### 4) **番型可达性自检**
-
-**同一点数牌张数检查**：
-- 番型需求 ≤ 物理上限（4×牌副数+赖子） → [PASS/FAIL]
-- 具体不可达番型：[列出]
-
-**组合番型冲突检查**：
-- 无逻辑冲突的番型组合 → [PASS/FAIL]
-- 冲突组合：[列出]
-
-**大牌型验证**：
-- 十八罗汉/大威天龙等大牌型理论达成概率>0 → [PASS/FAIL]
-- 万中无一等极端大牌验证 → [PASS/FAIL]
+#### 复杂出牌顺序规则
+
+| 场景 | 出牌权归属 | 下一手 |
+| --- | --- | --- |
+| 正常摸打 | 当前玩家 | 下家（逆时针）|
+| 吃牌后 | 吃牌者 | 吃牌者的下家 |
+| 碰牌后 | 碰牌者 | 碰牌者的下家 |
+| 杠牌后 | 杠牌者（补摸后）| 杠牌者的下家 |
+| 胡牌后（血战）| 下一位未胡玩家 | 该玩家的下家（跳过已胡者）|
+| 抢杠胡后 | 被抢杠者（若血战）| 被抢杠者的下家 |
+
+**血战/血流模式特殊规则**：
+- 胡牌者退出后，其位置在轮次中被跳过
+- 剩余玩家继续按原顺序行牌
+- 牌墙摸完或仅剩一人时结束
+
+若引入上述复杂场景，必须在《最小回合推演》中额外提供对应场景的推演段落（≤8 行），标注每步的位置数与出牌权归属。
 
-### 5) **特殊机制完整性检查**
+### D) mGDL invariants（硬性）
 
-**赖子规则完整性**：
-- 赖子确定方式（固定/翻牌）明确定义 → [PASS/FAIL]
-- 赖子功能范围（可替代哪些牌）明确定义 → [PASS/FAIL]
-- 赖子限制（是否可吃碰杠/打出）明确定义 → [PASS/FAIL]
-- 赖子在胡牌时的特殊规则明确定义 → [PASS/FAIL]
+`(invariants ...)` 至少包含：
+- `tile_conservation`：总牌数守恒（与 tileset.total 一致）
+- `hand_size_stable`（或等价表达）：声明行牌阶段“回合动作序列结束后手牌回到稳定值（通常 13；首轮庄家 14 仅在首次打出前成立）”
 
-**幺鸡/红中机制一致性**：
-- 牌面标识与功能描述一致 → [PASS/FAIL]
-- 计分规则与机制描述一致 → [PASS/FAIL]
+---
+
+## 可控迭代：Analyse 模式（单问题迭代，强制）
 
-### 6) **麻将阶段完整性检查**
+当且仅当用户输入中包含：`<ANALYSE_MODE>true</ANALYSE_MODE>`，你必须进入【Analyse 模式】：
+1. 只做需求澄清与方案收敛：**不输出 mGDL**、不输出完整自然语言规则、不输出自检报告。
+2. 严格单问题迭代：每轮只问 1 个“当前最重要”的澄清问题。
+3. 每轮必须输出更新后的 `DesignState(JSON)`，未知信息写入 `open_questions`。
+4. 当 `open_questions` 为空（或仅剩非阻塞可选项）时输出 `READY_TO_GENERATE: true`，否则 `false`。
+
+Analyse 模式输出格式固定为（必须严格遵守）：
+- 一句话总结当前理解（≤60字）
+- 本轮唯一问题（只问1个）
+- 思维日志（本轮增量，≤200字）：为什么问/影响哪些融合旋钮/如何收敛
+- ```json  (DesignState)```（合法JSON）
+- `READY_TO_GENERATE: true/false`
 
-**定缺阶段**：
-- 定缺启用时，缺门验证规则明确定义 → [PASS/FAIL]
-- 定缺时机明确 → [PASS/FAIL]
+---
 
-**换三张阶段**：
-- 换牌方向/规则明确定义 → [PASS/FAIL]
-- 换牌限制明确定义 → [PASS/FAIL]
+## 多阶段引导式交互（推荐流程）
 
-**行牌阶段**：
-- 出牌顺序无歧义 → [PASS/FAIL]
-- 吃碰杠规则无冲突 → [PASS/FAIL]
+为确保机制组合创新的质量，建议遵循以下多阶段交互流程：
 
-### 7) **机制完整性与双向映射检查**（⚠️ 核心防遗漏机制）
+### 阶段一：理解确认（Understand）
 
-**步骤A：提取自然语言中声明的所有机制**
-- 机制列表：[M1, M2, M3, ...]
-- 总计：N个机制
+当用户描述涉及已有玩法（如血战到底、血流成河、国标麻将等）时：
 
-**步骤B：验证每个机制在mGDL中的实体化**
-| 机制名称 | mGDL实体位置 | 是否存在 | transfer_path | 
-|---------|------------|---------|--------------|
-| M1      | [路径]      | [是/否]  | [有/无/none] |
-| M2      | [路径]      | [是/否]  | [有/无/none] |
+1. **主动确认理解**：对用户提到的已有玩法进行理解确认
+2. **提出确认问题**：使用 `❓` 或 `【确认】` 前缀标记问题
+3. **示例**：
+   - ❓ 您提到的"血战到底"是否指四川麻将的"三家胡完才结束"模式？
+   - 【确认】您希望保留血战的"缺一门"约束还是去掉？
 
-**步骤C：反向验证mGDL中定义的特殊机制是否在自然语言中说明**
-| mGDL机制名 | 在自然语言表格中 | 在流程描述中 |
-|----------|----------------|-------------|
-| [name1]  | [是/否]         | [是/否]      |
-| [name2]  | [是/否]         | [是/否]      |
+**注意**：如果对已有玩法的理解存在歧义，必须先确认再进行下一步。
 
-**判定标准**：
-- 若步骤B中任一机制"是否存在"为"否" → **FAIL**（自然语言声明了但mGDL未实现）
-- 若步骤B中任一机制缺少 `transfer_path` → **FAIL**
-- 若步骤C中任一mGDL机制未在自然语言中说明 → **FAIL**（mGDL实现了但未告知玩家）
-- 若自然语言声明的机制数量 ≠ mGDL实际实现的机制数量 → **FAIL**
+### 阶段二：方案发散（Diverge）
 
-**最终结论**：[PASS/FAIL]
+在明确已有玩法后，进行机制组合创新时：
 
-### 8) **特殊机制统一注册检查**（⚠️ 核心防遗漏机制）
+1. **发散思维**：给出 2-4 种不同方向的机制组合方案
+2. **输出格式**：
+   ```
+   ### 方案 A: [方案名称]
+   ✦ 创新点：[1-2句话概述]
+   ✦ 机制组合：[简述要融合的机制]
 
-**步骤A：扫描mGDL所有模块，提取所有特殊定义**
-- extensions.special_mechanics.mechanic_cards. 中的所有条目
-- win_rules 中的特殊胡牌规则
-- scoring 中的特殊计分规则
-- fan_table 中的特殊番型
+   ### 方案 B: [方案名称]
+   ✦ 创新点：[1-2句话概述]
+   ✦ 机制组合：[简述要融合的机制]
 
-**检测到的特殊机制列表**：
-| 机制名称 | 定义位置 | 类别 |
-|---------|---------|------|
-| [M1]    | [path1] | [category1] |
-| [M2]    | [path2] | [category2] |
+   ### 方案 C: [方案名称]
+   ...
+   ```
+3. **要求**：
+   - 每个方案有明确差异化（不同的创新方向/目标用户/玩法复杂度）
+   - 不要深入展开，只给概要供用户选择
+   - 方案编号使用 A/B/C/D 或 一/二/三/四
 
-**总计**：N个
+### 阶段三：方案选择（Select）
 
-**步骤B：验证 extensions.special_mechanics.mechanic_cards. 注册完整性**
-**extensions.special_mechanics.mechanic_cards. 中已注册的机制**：
-| 机制ID | card_path | implementation_path | category | stage_scope | enabled |
-|-------|----------|---------------------|----------|------------|---------|
-| [M1]  | extensions.special_mechanics.mechanic_cards.[M1] | extensions.special_mechanics.mechanic_cards.[M1] | [cat1] | [setup/play/scoring/end/global] | true |
-| [M2]  | extensions.special_mechanics.mechanic_cards.[M2] | extensions.special_mechanics.mechanic_cards.[M2] | [cat2] | [setup/play/scoring/end/global] | true |
+等待用户选择具体方案：
+- 用户可选择某个方案编号
+- 用户可提出"其他"并描述自己的想法
+- 用户可要求"重新发散"获取更多方案
 
+### 阶段四：深入展开（Elaborate）
 
-**总计**：M个
+用户选择方案后，对该方案进行完整设计：
+1. 输出完整的 DesignState(JSON)
+2. 输出完整的 mGDL
+3. 输出自然语言规则说明
+4. 输出自检报告
 
-**步骤C：对比检查**
-- mGDL中实际特殊机制数量：N
-- extensions.special_mechanics.mechanic_cards. 注册数量：M
-- 是否一致：N == M → [PASS/FAIL]
-- 若处于【创新扩展模式】：逐一检查每条机制卡是否包含 trigger/effect/settle/reset（缺一 FAIL）
+### 阶段判断规则
 
-**未在 extensions.special_mechanics.mechanic_cards. 注册的机制**：
-- [列出所有遗漏项及其定义位置]
+- 若用户首次提出需求且涉及多个已有玩法 → 先进入「理解确认」
+- 若理解已确认但尚未给出多方案 → 进入「方案发散」
+- 若用户从多方案中选择了一个 → 进入「深入展开」
+- 若已有完整 DesignState 且用户提出修改 → 进入「迭代优化」
 
-**最终结论**：[PASS/FAIL]
+---
 
-### 9) **庄家规则验证**
+## 生成模式输出（必须严格按顺序）
 
-**庄家确定方式**：
-- 方式明确定义（随机/骰子/固定） → [PASS/FAIL]
-- 连庄规则明确定义 → [PASS/FAIL]
+### 思考与自检过程
+用自然语言描述你做了哪些检查、发现哪些 FAIL、如何"最小修改"修复、最终确认通过。至少覆盖：
+- 是否输出《动作—手牌变化—轮次影响表》
+- 是否输出《最小回合推演》（普通/碰/杠三段）
+- 胡后模式是否与底座一致（血战/血流/一局一胡）
+- 计分字段是否与计分模式一致（multiplier→mult，fan_system→fan，hybrid→mult+category）
+- mGDL 是否包含核心模块且无占位符
+- invariants 是否包含 tile_conservation 与 hand_size_stable
+- 若涉及复杂场景（连续碰杠/抢杠胡/多人响应），是否有对应推演段落与出牌权说明
 
-**庄家权益量化**：
-- 庄家起手牌数=14 → [PASS/FAIL]
-- 庄家倍率优势=1.1-1.15 → [PASS/FAIL]
+### 设计日志（创新推演摘要）
+本阶段的设计日志聚焦“融合决策”，必须包含：
+1. **融合清单**：从A保留哪些核心；从B引入哪些机制（逐条）
+2. **冲突与桥接规则**：冲突点 → 桥接方案（最小且可量化）→ 为什么不破坏底座
+3. **底层正确性证据**：引用你后文《动作—手牌变化—轮次影响表》《最小回合推演》的关键行（用文字描述即可）
+4. **落地映射（Crosswalk）**：机制名 → `mGDL_path` → `transfer_path(若有)`
 
-### 10) **血战/血流一致性检查**
-
-**规则匹配**：
-- game_variant 与 post_win_continuation 逻辑一致 → [PASS/FAIL]
-  - 血战类：winner_exit=true, end_when_third_player_wins=true
-  - 血流类：winner_exit=false, keep_turn_order=true, after_gun_next_draw="shooter_next"
-
-**流程描述匹配**：
-- 自然语言规则与mGDL定义一致 → [PASS/FAIL]
-
-### 11) **番型叠加规则检查**
-
-**叠加模式**：
-- stacking 模式明确定义（multiply/add） → [PASS/FAIL]
-- 番型互斥规则明确定义 → [PASS/FAIL]
-
-**封顶规则**：
-- 番型上限明确定义 → [PASS/FAIL]
-- 封顶规则与计分模式兼容 → [PASS/FAIL]
-
-### 12) **修复轨迹**
-
-**自检发现问题**：
-1. [问题1描述]
-   - 检测位置：[具体模块/行号]
-   - 修正方案：[具体修改内容]
-   - 修正依据：[最小修改优先级规则]
-
-2. [问题2描述]
-   - 检测位置：[具体模块/行号]
-   - 修正方案：[具体修改内容]
-   - 修正依据：[最小修改优先级规则]
-
-**修正验证**：
-- 修正后重新自检通过 → [PASS/FAIL]
-- 修正是否影响其他模块 → [是/否]
-- 需要额外验证的关联规则：[列出]
-
-### 13) **麻将专用边界条件测试**
-
-**极端情况验证**：
-- 牌墙只剩1张时摸牌 → [PASS/FAIL]
-- 最后一张牌杠上开花 → [PASS/FAIL]
-- 三家同时胡牌 → [PASS/FAIL]
-- 四暗刻单吊胡牌 → [PASS/FAIL]
-
-**特殊机制边界**：
-- 赖子使用上限验证 → [PASS/FAIL]
-- 连庄次数上限验证 → [PASS/FAIL]
-
-### 14) **玩法融合自检**（融合任务必检）
-
-**融合模式检查**：
-- 计分模式统一性：全倍数制 或 全番数制（无混合） → [PASS/FAIL]
-- 冲突规则排查：无互斥的胡牌/行牌规则 → [PASS/FAIL]
-- 牌组兼容性：Tileset 包含所有机制所需的牌（如花牌/月亮牌） → [PASS/FAIL]
-
-**融合插件注册**：
-- 来源玩法机制完整注册进 extensions.special_mechanics.mechanic_cards. → [PASS/FAIL]
-- 插件机制与底座玩法无逻辑冲突 → [PASS/FAIL]
-
-### 15) **最终验收**
-
-**核心验收项**：
-- 模块完整性：[PASS/FAIL]
-- 牌数守恒：[PASS/FAIL]
-- 机制完整性：[PASS/FAIL]
-- 番型可达性：[PASS/FAIL]
-- 无模糊表述：[PASS/FAIL]
-- 自检报告完整：[PASS/FAIL]
-- 融合自检通过（仅融合任务）：[PASS/FAIL/NA]
-
-**最终结论**：[PASS/FAIL]
-
-**若FAIL，需重新设计的部分**：
-1. [模块名称] - [原因]
-2. [模块名称] - [原因]
-
-**审核人**：[AI系统自审]
-**审核时间**：[YYYY-MM-DD HH:MM:SS]
-**审核版本**：mGDL v1.3
-
-</details>
-
-## 平衡性分析
-[在此处撰写平衡性分析，包括：
-庄家优势控制在10%-15%的设计依据
-各种胡牌方式的价值分布合理性
-大牌型与普通牌型的比例控制
-赖子/特殊牌对随机性的控制
-与现有麻将玩法相比的平衡性特点]
-
-## 常见错误避免
-### ⚠️ 零容忍错误（最高优先级）
-1. ❌ mGDL 模块不完整是最严重的错误：
-  - 严禁输出缺少核心模块的 mGDL（如缺少 extensions.special_mechanics.mechanic_cards.、fan_table、win_rules 等）
-  - mGDL 必须包含硬自检第0项列出的所有核心模块，缺一不可
-  - 在第二步自检时，第0项"模块完整性检查"的所有子项必须全部 PASS
-2. 牌墙管理错误：
-  - 严禁未定义牌墙就进行摸牌操作
-  - 严禁牌墙张数变为负数
-  - 严禁杠后未定义补牌路径
-3. 番型可达性问题：
-  - 严禁定义理论不可达的番型（如要求18张相同字牌）
-  - 严禁番型组合存在逻辑冲突
-  - 严禁大牌型出现概率为0
-4. 胡牌规则不完整：
-  - 严禁只写"类似血战"而不展开具体参数
-  - 严禁未定义胡牌后规则
-  - 严禁胡牌要求与番型体系不一致
-5. 特殊机制未注册：
-  - 严禁在 extensions.special_mechanics.mechanic_cards. 中漏注册任何创新机制
-  - 严禁自然语言声明了但 mGDL 未实现的机制
-  - 严禁 mGDL 实现了但自然语言未说明的机制
-6. 新增麻将专用检查项
-  - 血战/血流一致性：玩法大类必须与 post_win_continuation 逻辑一致
-  - 赖子规则完整性：若启用赖子，必须完整定义其功能范围、限制、特殊规则
-  - 庄家规则验证：庄家权益必须量化，庄家流转规则必须明确
-  - 牌墙补充机制：若 Wall_initial > 0，必须定义从牌墙摸牌的机制
-  - 大牌型验证：十八罗汉、大威天龙等大牌型必须通过理论可达成性验证
-  - 番型叠加规则：必须明确定义番型是否叠加及叠加方式
-  - 定缺规则一致性：若启用定缺，必须定义缺门验证与时机
-  - 翻牌机制完整性：若启用翻牌，必须定义翻牌区、翻牌时机、翻牌规则
-7. 工程验收标准
-  - 模块完整性：所有14个核心模块必须完整存在
-  - 物理一致性：所有牌变动必须有明确转移路径
-  - 牌数守恒：初始牌数分布 + 各区域变动 = 总牌数
-  - 机制完整性：自然语言声明的机制数 = mGDL实现的机制数
-  - 番型可达性：所有定义的番型在理论上有非零达成概率
-  - 平衡性合理：庄家优势在10%-15%，大牌型价值与概率成反比
-  - 无模糊表述：禁止使用"某些"、"部分"、"可能"等模糊词汇
-  - 自检报告完整：包含所有16项自检结果及修复轨迹
-  - 最终验收：只有当所有自检项均为 PASS，且《自检报告》中有完整修复轨迹时，才视为合格输出。任何 FAIL 项未修复的输出都将被拒绝。 
-8. **手牌数量违反守恒**：
-  - 严禁在行牌阶段结束时（即未处于胡牌瞬间）出现手牌 ≠ 13 张的情况（庄家出牌后同理）。
-  - 严禁 `action` 定义中缺少 `requires_discard` 或未说明手牌变化。
-  - 严禁自然语言描述中省略“吃/碰/杠后需打牌”这一关键步骤。
-9. **玩法融合失败**（融合任务专用）：
-  - 严禁混用计分模式（如在倍数制中使用 `fan` 字段）。
-  - 严禁引入新机制（如买马）但未在 `extensions.special_mechanics.mechanic_cards.` 和 `win_rules/scoring` 中完整定义。
-  - 严禁保留互相冲突的规则（如“血战”与“流局”规则并存）。
+### DesignState（JSON，可机读）
+输出一个合法 JSON（不要注释、不要省略号）。至少包含：
+```json
+{
+  "base_variants": ["底座玩法名"],
+  "fusion_variants": ["融合玩法名"],
+  "new_variant_name": "新玩法名",
+  "game_variant": "blood_war|blood_flow|round|multi_round|custom",
+  "players": 4,
+  "scoring_mode": "multiplier|fan_system|hybrid",
+  "tileset": {"suits":["wan","tong","tiao"],"honors":0,"special_tiles":[],"total":108},
+  "core_constraints": ["手牌守恒：回合结束回到13张","牌数守恒：所有区域之和=TotalTiles"],
+  "mechanics": [
+    {"name":"机制名","type":"core|aux","phase":"setup|play|settle|global","trigger":"...","cost":"...","reward_or_penalty":"...","counterplay":"...","mgdl_path":"extensions.special_mechanics.mechanic_cards.<ID>","transfer_path":"from: X to: Y|none"}
+  ],
+  "open_questions": []
+}
+```
+
+### 游戏名称
+[游戏名称]
+
+### 游戏理念
+[≤200字：强调“融合点与体验变化”，避免空泛口号]
+
+### mGDL描述
+必须输出完整 mGDL v1.3（使用 ```lisp 代码块```）。必须包含核心模块：
+`(game_variant ...) (players ...) (tileset ...) (extensions ...) (seats ...) (turn_order ...) (setup ...) (actions ...) (win_rules ...) (scoring ...) (fan_table ...) (settlement ...) (invariants ...)`
+
+硬性规则：
+- 禁止 `<PID>` 等占位符，PID 展开为 A1/A2/A3/A4
+- tileset 必须包含 `(total N)`
+- `(extensions (special_mechanics (mechanic_cards ...)))` 必须存在（即使为空也要给结构）
+
+### 自然语言规则说明
+必须包含以下小节（按标题输出，禁止省略）：
+1. 新机制声明（机制声明表 + 每条机制展开 + `mGDL_path`）
+2. 基础规则（牌组构成、起手/牌墙、座位与顺序、允许吃碰杠胡）
+3. 游戏流程（按阶段；明确"谁出牌权/下一手是谁"的规则）
+4. 《动作—手牌变化—轮次影响表》（硬性）
+5. 《最小回合推演》（硬性；若涉及复杂场景需额外提��对应推演）
+6. 得分体系（继承底座体系；B机制若影响计分必须桥接）
+7. 复杂场景处理（若涉及连续碰杠/抢杠胡/多人响应/血战轮次，必须显式说明决策流程与出牌权归属）
+
+### 技术附录：《自检报告》（简化）
+用不超过 15 行列出关键 PASS/FAIL 与修复点即可，重点列：
+手牌守恒、三段推演、mGDL模块齐全、tile_conservation、hand_size_stable、计分字段一致性。
+若涉及复杂场景，额外检查：连续碰杠推演、抢杠胡流程、多人响应优先级、出牌权归属。

output_validator.py

@@ -12,6 +12,8 @@ from typing import Dict, List, Optional, Tuple
 
 _FENCE_RE = re.compile(r"```(?:[a-zA-Z0-9_-]+)?\n(.*?)```", re.DOTALL)
 
+_CJK_GT = r"[>＞]"
+
 
 def _extract_mgdl_block(text: str) -> str:
     """
@@ -35,6 +37,15 @@ def _extract_mgdl_block(text: str) -> str:
     return best
 
 
+def _has_any(text: str, needles: List[str]) -> bool:
+    t = text or ""
+    return any(n in t for n in needles)
+
+
+def _re_search(pattern: str, text: str) -> bool:
+    return bool(re.search(pattern, text or "", flags=re.DOTALL))
+
+
 def validate_mahjong_response(text: str) -> List[Dict[str, str]]:
     issues: List[Dict[str, str]] = []
     if not text or not text.strip():
@@ -58,14 +69,104 @@ def validate_mahjong_response(text: str) -> List[Dict[str, str]]:
         return issues
 
     # 0.5) 思维日志（设计日志）检查：生成模式下应包含“设计日志（创新推演摘要）”
-    # 这是你们的关键交付：创新不是堆叠，需要可审核的决策记录。
+    # Phase-1 聚焦“融合决策可审核”，避免停留在文本拼接。
     if "设计日志（创新推演摘要）" not in text:
         issues.append({
             "code": "NO_DESIGN_LOG",
             "level": "warning",
-            "message": "未检测到“设计日志（创新推演摘要）”段落；建议补齐候选方案/取舍/推演摘要/落地映射。"
+            "message": "未检测到“设计日志（创新推演摘要）”段落；Phase-1 建议补齐融合清单/冲突桥接/推演摘要/落地映射。"
+        })
+
+    # 0.6) 底层物理守恒表达检查（当前阶段重点）
+    # 目标：强制模型在自然语言规则里显式给出“动作-手牌变化-轮次影响表”和“最小回合推演”
+    if "动作—手牌变化—轮次影响表" not in text and "动作-手牌变化-轮次影响表" not in text:
+        issues.append({
+            "code": "NO_HAND_DELTA_TABLE",
+            "level": "warning",
+            "message": "未检测到《动作—手牌变化—轮次影响表》；该表用于避免“出牌后手牌不变”等守恒错误，建议补齐。"
+        })
+    if "最小回合推演" not in text:
+        issues.append({
+            "code": "NO_MIN_SIMULATION",
+            "level": "warning",
+            "message": "未检测到“最小回合推演”（普通/碰/杠三段）；建议补齐以验证手牌守恒与轮次控制。"
+        })
+
+    # 0.7) “硬真理”与机制说明对齐检查（以自然语言显式声明为主）
+    # 说明：这里做的是“声明存在性”的静态校验（不是逻辑证明），用于减少模型忘写/乱写导致的回归。
+    if not _re_search(r"(起手|初始).*13\s*张", text):
+        issues.append({
+            "code": "NO_START_HAND_13",
+            "level": "warning",
+            "message": "未显式声明“标准起手 13 张”（麻将机制说明的基础逻辑）；建议在基础规则中补一句。"
+        })
+    if not _re_search(r"(摸|抓).*(14\s*张)", text):
+        issues.append({
+            "code": "NO_DRAW_TO_14",
+            "level": "warning",
+            "message": "未显式声明“摸牌后手牌为 14 张”（基础逻辑）；建议补充以便审计守恒。"
+        })
+    if not _re_search(r"(打|弃|出).*(回到|恢复|为).*(13\s*张)", text):
+        issues.append({
+            "code": "NO_DISCARD_BACK_13",
+            "level": "warning",
+            "message": "未显式声明“打牌后手牌回到 13 张”（基础逻辑）；建议补充以便审计守恒。"
+        })
+
+    # 胡/碰/杠/吃优先级（允许不同符号表达）
+    if not _re_search(rf"胡.*{_CJK_GT}.*碰.*{_CJK_GT}.*杠.*{_CJK_GT}.*吃", text):
+        issues.append({
+            "code": "NO_PRIORITY_ORDER",
+            "level": "warning",
+            "message": "未显式声明“胡＞碰＞杠＞吃”的响应优先级（基础逻辑）；建议补齐以避免争议场景。"
         })
 
+    # 吃的限制
+    if not _has_any(text, ["仅能吃上家", "只能吃上家", "只可吃上家"]):
+        issues.append({
+            "code": "NO_CHI_UPWIND_ONLY",
+            "level": "warning",
+            "message": "未显式声明“吃仅能吃上家牌”（基础逻辑）；建议补齐。"
+        })
+
+    # 行牌顺序与出牌权归属（声明存在性）
+    if not _has_any(text, ["庄家-下家-对家-上家", "庄家→下家→对家→上家", "庄家 → 下家 → 对家 → 上家"]):
+        issues.append({
+            "code": "NO_TURN_ORDER_BASE",
+            "level": "warning",
+            "message": "未显式声明“庄家-下家-对家-上家”的行牌顺序（基础逻辑）；建议补齐。"
+        })
+    if not _has_any(text, ["由碰牌的玩家继续出牌", "由吃/碰者继续出牌", "碰后由碰者出牌"]):
+        issues.append({
+            "code": "NO_POST_PENG_RIGHTS",
+            "level": "warning",
+            "message": "未显式声明“碰/吃后由碰/吃者继续出牌”的出���权规则（基础逻辑）；建议补齐。"
+        })
+    if not _has_any(text, ["由杠牌的玩家摸牌后继续出牌", "杠后由杠者补牌后继续出牌", "杠后由杠者继续出牌"]):
+        issues.append({
+            "code": "NO_POST_KONG_RIGHTS",
+            "level": "warning",
+            "message": "未显式声明“杠后由杠者补牌/摸牌后继续出牌”的出牌权规则（基础逻辑）；建议补齐。"
+        })
+
+    # 自摸/点炮触发方式
+    if not (_has_any(text, ["自摸"]) and _has_any(text, ["点炮"])):
+        issues.append({
+            "code": "NO_ZIMO_DIANPAO",
+            "level": "warning",
+            "message": "未同时出现“自摸/点炮”两种胡牌触发方式（基础逻辑）；建议补齐。"
+        })
+
+    # 若引入改变摸打节奏的机制，建议额外最小推演（Prompt 已要求）
+    special_rhythm_terms = ["连续摸", "摸三打三", "海底漫游", "海捞阶段", "海捞区"]
+    if _has_any(text, special_rhythm_terms):
+        if not _re_search(r"(最小回合推演).*(" + "|".join(map(re.escape, special_rhythm_terms)) + ")", text):
+            issues.append({
+                "code": "NO_SPECIAL_MIN_SIM",
+                "level": "warning",
+                "message": "检测到改变摸打节奏的机制（如 摸三打三/连续摸/海捞），但未看到对应机制的额外“最小回合推演”；建议补齐以验证守恒。"
+            })
+
     # 2) 核心模块检查（按 m_prompt 的“零容忍项”）
     required_markers = [
         "(game_variant",
@@ -107,6 +208,20 @@ def validate_mahjong_response(text: str) -> List[Dict[str, str]]:
             "message": "tileset 中未检测到 (total N)，容易导致牌数不自洽。"
         })
 
+    # 5) invariants 强制项（Prompt 硬性要求）
+    if "tile_conservation" not in mgdl:
+        issues.append({
+            "code": "NO_TILE_CONSERVATION",
+            "level": "warning",
+            "message": "(invariants ...) 中未检测到 tile_conservation；建议补齐以显式声明牌数守恒。"
+        })
+    if "hand_size_stable" not in mgdl:
+        issues.append({
+            "code": "NO_HAND_SIZE_STABLE",
+            "level": "warning",
+            "message": "(invariants ...) 中未检测到 hand_size_stable（或等价声明）；建议补齐以约束回合结束手牌稳定值。"
+        })
+
     return issues
 
 

requirements.txt

@@ -1,2 +1,2 @@
-gradio==4.27.0
-openai>=1.0.0
+gradio>=4.27.0
+openai>=1.0.0

styles.py

@@ -229,4 +229,36 @@ gap:8px;
 /* 头像与气泡的间距与对齐（可选） */
 .custom-chatbot .message{ gap: 12px !important; align-items: flex-start !important; }
 .custom-chatbot .message .message-content{ margin-top: 2px !important; }
+
+/* === 差异摘要样式 === */
+.diff-summary {
+  background: rgba(0, 0, 0, 0.25) !important;
+  border: 1px solid rgba(255, 255, 255, 0.12) !important;
+  border-radius: 12px !important;
+  padding: 12px 16px !important;
+  font-size: 13px !important;
+  line-height: 1.6 !important;
+  color: var(--ink) !important;
+}
+
+.diff-summary strong {
+  color: #ffcc4d !important;
+}
+
+.diff-summary code {
+  background: rgba(255, 255, 255, 0.08) !important;
+  padding: 2px 6px !important;
+  border-radius: 4px !important;
+  font-size: 12px !important;
+  color: #7dd3fc !important;
+}
+
+.diff-summary em {
+  color: #94a3b8 !important;
+}
+
+.diff-summary s, .diff-summary del {
+  color: #6b7280 !important;
+  text-decoration: line-through !important;
+}
 """

麻将机制说明.md

@@ -1,27 +1,796 @@
 # 麻将机制说明
 
-*   创新机制
-    
-
-| 目的 | 机制 |
-| --- | --- |
-| 加快玩家胡牌节奏 | 增设赖子牌，可代替任意牌/摸三打三/一炮多响/抢杠胡/限制胡牌倍数，玩家达到封顶倍数的牌型后会尽快胡牌 |
-| 促进玩家做高倍数的大牌 | 限制起胡倍数/增加番型的倍数/加入功能牌，触发加倍功能/平胡只能自摸 |
-| 鼓励玩家积极进攻 | 血战到底，一局能有三家胡牌，增大了赢局概率/定缺花色，胡牌前必须打出所有定缺花色的牌/查大叫：打出最后一张牌后，未听牌玩家赔给听牌未胡玩家最大可能倍数（不包含自摸倍数）/退税：打出最后一张牌后，未听牌玩家，退回全部杠牌所得 |
-| 增强社交性 | 2v2，组队玩家信息共享 |
-| 增强游戏的趣味性 | 加入功能牌，触发连续摸牌的功能/打出两张相同牌触发三选一/生肖麻将中点亮百景图可增加倍数 |
-| 鼓励玩家尽早听牌 | 捉鸡：若在整个牌局第一次胡牌之后未听啤，需要结算鸡牌 |
-| 增加单局最大输赢 | 抓码/扎鸟/买马/赖子杠倍数×10/明牌倍数×6/破封，突破倍数上限/漂分 |
-| 保护小持币量玩家 | 限制封顶倍数和金币 |
-| 增强游戏的策略博弈 | 与系统或其他玩家换牌/选择出牌参与比牌/玩家胡牌后无法继续飞赖子和点亮生肖/海底漫游：最后一张牌为海底牌，此时玩家可依次选择是否要这张牌/合肥麻将中的海捞阶段（不同于海底捞月番型）：牌桌上仅剩最后4张未抓的牌时，放入“海捞区”，四家从“海捞区”各抓一张牌放入手牌中，从第一个摸牌玩家逆时针开始，如果有一个玩家胡牌，则停止海捞，进入结算。/玩家胡牌后无法继续飞赖子和点亮生肖/暴击：同类牌型，倍数大的玩家胜，胜者对败者触发 “暴击”，赢取额外的金币。 |
-
-*   基础逻辑
-    
-
-|  | 说明 |
-| --- | --- |
-| 摸牌-打牌循环 | 玩家轮流 “摸 1 张牌→打 1 张牌” 的基础节奏，除吃碰杠后仅需打牌、无需摸牌的情况。 |
-| 手牌数量 | 标准起手牌为13张。玩家回合内摸牌后变为 14 张，打牌后回到 13 张。 |
-| 吃碰杠和胡牌的优先级 | 同一轮中，胡牌＞碰牌＞杠牌＞吃牌。仅能吃上家牌，碰 / 杠可对任意玩家。 |
-| 胡牌的触发条件 | 需通过 “自摸”（自己摸牌凑成胡牌型）或 “点炮”（吃进其他玩家打出的牌）胡牌，这是胡牌的两种核心方式 |
-| 玩家的行牌顺序 | 玩家按庄家-下家-对家-上家的顺序依次行牌。若一玩家有碰牌的操作，则由碰牌的玩家继续出牌，出牌顺序不变。若一玩家有杠牌的操作，则由杠牌的玩家摸牌后继续出牌，出牌顺序不变。 |
+本文档作为机制词典，用于麻将玩法融合时的创新机制选型与底层逻辑约束参考。
+
+---
+
+## 术语表
+
+### 牌组类型
+
+| 术语 | 定义 | 张数 | 示例 |
+| --- | --- | --- | --- |
+| **顺子** | 同花色连续 3 张牌 | 3 张 | 🀇🀈🀉（一二三万） |
+| **刻子** | 3 张完全相同的牌 | 3 张 | 🀇🀇🀇（三张一万） |
+| **杠子** | 4 张完全相同的牌 | 4 张 | 🀇🀇🀇🀇（四张一万） |
+| **对子** | 2 张完全相同的牌 | 2 张 | 🀇🀇（两张一万） |
+| **雀头** | 胡牌时必须的 1 个对子 | 2 张 | 胡牌牌型中的那个对子 |
+
+### 明暗区分
+
+| 术语 | 定义 | 形成方式 |
+| --- | --- | --- |
+| **暗牌** | 手中未公开的牌 | 自己摸的牌 |
+| **明牌** | 公开摆在桌面的牌组 | 通过吃/碰/明杠形成 |
+| **暗刻** | 自己摸齐的刻子（未公开） | 自己摸到 3 张相同的牌 |
+| **明刻** | 通过碰形成的刻子（公开） | 碰他人打出的牌 |
+| **暗杠** | 自己摸齐的杠子（扣着摆放） | 自己摸到 4 张相同的牌后宣告 |
+| **明杠** | 通过杠他人的牌形成（公开） | 杠他人打出的牌（直杠）或补杠 |
+
+### 动作术语
+
+| 术语 | 定义 | 条件 |
+| --- | --- | --- |
+| **吃** | 用手中 2 张牌 + 上家打出的 1 张牌组成顺子 | 仅能吃上家的牌 |
+| **碰** | 用手中 2 张牌 + 他人打出的 1 张牌组成刻子 | 可碰任意玩家的牌 |
+| **杠** | 用 4 张相同的牌组成杠子 | 分明杠/暗杠/补杠 |
+| **直杠（明杠）** | 用手中 3 张 + 他人打出的 1 张组成杠 | 可杠任意玩家的牌 |
+| **补杠（加杠）** | 将手中 1 张补到已碰的刻子上变成杠 | 需先有碰出的明刻 |
+| **暗杠** | 用手中 4 张相同的牌组成杠 | 摸牌后宣告 |
+| **胡（和）** | 凑成完整牌型，宣告获胜 | 满足胡牌条件 |
+| **自摸** | 自己摸到的牌凑成胡牌 | 摸牌后胡牌 |
+| **点炮（放炮）** | 打出的牌被他人胡 | 他人胡你打出的牌 |
+| **听牌** | 只差 1 张牌即可胡牌的状态 | 差一张即可成胡 |
+
+### 特殊��牌
+
+| 术语 | 定义 |
+| --- | --- |
+| **杠上开花** | 杠牌后补摸的牌正好能胡（自摸） |
+| **杠上炮** | 杠牌后打出的牌被他人胡（点炮） |
+| **抢杠胡** | 他人补杠时，胡那张补杠的牌 |
+| **海底捞月** | 摸最后一张牌（海底牌）胡牌 |
+| **妙手回春** | 摸最后一张牌自摸胡牌（同海底捞月） |
+| **河底捞鱼** | 胡最后一个人打出的牌 |
+
+### 位置与顺序
+
+| 术语 | 定义 |
+| --- | --- |
+| **庄家** | 本局先出牌的玩家，通常起手 14 张 |
+| **闲家** | 非庄家的玩家，起手 13 张 |
+| **上家** | 你的上一个出牌者（你吃牌的来源） |
+| **下家** | 你的下一个出牌者（你出牌后轮到的人） |
+| **对家** | 坐在你对面的玩家 |
+
+### 牌墙与区域
+
+| 术语 | 定义 |
+| --- | --- |
+| **牌墙** | 洗牌后码好的牌，玩家从此处摸牌 |
+| **牌河（弃牌堆）** | 玩家打出的牌摆放的区域 |
+| **海底牌** | 牌墙中最后一张可摸的牌 |
+| **王牌** | 牌墙末尾保留不参与摸牌的牌（部分规则） |
+
+---
+
+## 一、基础逻辑（底层守恒硬约束）
+
+### 1.0 牌组构成与基础限定
+
+**标准麻将牌组**（以四川麻将/血战为例）：
+
+| 花色 | 牌面 | 每种张数 | 小计 |
+| --- | --- | --- | --- |
+| 万（萬）| 一万～九万 | 各 4 张 | 36 张 |
+| 条（索）| 一条～九条 | 各 4 张 | 36 张 |
+| 筒（饼）| 一筒～九筒 | 各 4 张 | 36 张 |
+| **总计** | | | **108 张** |
+
+**完整麻将牌组**（国标/日麻等）：
+
+| 花色 | 牌面 | 每种张数 | 小计 |
+| --- | --- | --- | --- |
+| 万 | 一万～九万 | 各 4 张 | 36 张 |
+| 条 | 一条～九条 | 各 4 张 | 36 张 |
+| 筒 | 一筒～九筒 | 各 4 张 | 36 张 |
+| 风牌 | 东、南、西、北 | 各 4 张 | 16 张 |
+| 箭牌 | 中、发、白 | 各 4 张 | 12 张 |
+| 花牌 | 春夏秋冬、梅兰竹菊 | 各 1 张 | 8 张 |
+| **总计** | | | **144 张** |
+
+**基础限定（硬约束）**：
+- **每种牌最多 4 张**：同一种牌（如"一万"）在整副牌中只有 4 张
+- 因此：**同种牌最多组成 1 个杠**（4 张全部用完）
+- 因此：**碰/刻子最多 4 组同种牌**（理论上，实际受手牌限制）
+- 因此：同种牌（最多4张）最多只能组成 1 个刻子（3张）或 1 个杠（4张）；其余只能作将/散张，无法形成多组同牌刻子
+
+**牌墙与王牌**：
+- 发牌前：所有牌洗匀后码成牌墙
+- 王牌（部分规则）：牌墙末尾保留若干张不参与摸牌（如日麻保留 14 张作为岭上牌和宝牌指示牌）
+
+### 1.1 手牌数量定义与守恒
+
+| 术语 | 定义 |
+| --- | --- |
+| 暗牌 | 手中未公开的牌 |
+| 明牌组 | 通过吃/碰/杠形成的公开牌组（摆在桌面） |
+| 回合结束牌数 | 玩家持有的总牌数（暗牌+明牌组）。**无杠时恒为 13 张**，每有 1 个杠则 +1 张（首轮庄家首次出牌前为 14） |
+
+**守恒公式**（按实际牌数计算）：
+```
+回合结束牌数 = 暗牌 + 吃组×3 + 碰组×3 + 杠组×4 = 13 + 杠组数
+```
+
+**说明**：
+- 无杠时：回合结束牌数 = 13
+- 每有 1 个杠（无论明杠/暗杠），回合结束牌数 +1
+- 原因：杠后补摸 1 张，打 1 张，杠组本身 4 张；相比碰组（3张），杠组多 1 张牌
+
+**各类杠的牌数变化**：
+| 杠类型 | 牌来源 | 牌数变化 | 回合结束牌数 |
+| --- | --- | --- | --- |
+| 明杠（直杠）| 他人弃牌 1 张 + 手中 3 张 | 13→14→15→14（杠+1→补摸+1→打-1）| 14 |
+| 暗杠 | 摸牌后手中 4 张 | 14→14→15→14（暗杠0→补摸+1→打-1）| 14 |
+| 补杠 | 摸牌后手中 1 张补到碰组 | 14→14→15→14（补杠0→补摸+1→打-1）| 14 |
+
+### 1.2 摸牌-打牌循环
+
+| 场景 | 动作序列 | 牌数变化 | 回合结束牌数 |
+| --- | --- | --- | --- |
+| 普通回合 | 摸 1 张 → 打 1 张 | 13 → 14 → 13 | 13 |
+| 吃牌后 | 取上家弃牌 + 手中 2 张组顺子 → 打 1 张 | 13 → 14 → 13 | 13 |
+| 碰牌后 | 取他人弃牌 + 手中 2 张组刻子 → 打 1 张 | 13 → 14 → 13 | 13 |
+| 直杠（明杠）后 | 取他人弃牌 + 手中 3 张组杠 → 补摸 → 打 1 张 | 13 → 14 → 15 → 14 | 14 |
+| 补杠后 | 摸牌后手中 1 张补到碰组 → 补摸 → 打 1 张 | 14 → 14 → 15 → 14 | 14 |
+| 暗杠后 | 摸牌后手中 4 张组暗杠 → 补摸 → 打 1 张 | 14 → 14 → 15 → 14 | 14 |
+
+**牌数变化详解**：
+- **吃/碰**：取弃牌后形成 3 张明牌组，暗牌减 2，总牌数 +1（变为14）→ 打牌后回到 13
+- **明杠**：杠后形成 4 张杠组（取弃牌1张+手中3张），暗牌减 3，总牌数+1（1+13=14）→ 补摸（+1=15）→ 打牌（14）→ 比普通回合多 1 张
+- **暗杠**：发生在摸牌后（14张），用手中 4 张组杠，总牌数不变（14）→ 补摸（+1=15）→ 打牌（-1=14）→ 比普通回合多 1 张
+- **补杠**：发生在摸牌后（14张），将 1 张补到碰组变杠，总牌数不变（14）→ 补摸（+1=15）→ 打牌（-1=14）→ 比普通回合多 1 张
+
+### 1.3 吃碰杠胡优先级
+
+同一张弃牌被多人响应时的优先级：
+
+```
+胡牌 ＞ 碰牌 ＞ 杠牌 ＞ 吃牌
+胡最高；碰/杠通常同级（或按本规则设定杠优先/碰优先）；吃最低；同级多人冲突按离出牌者最近优先（或按座次规则）。
+```
+
+- **吃**：仅能吃上家牌
+- **碰/杠**：可对任意玩家的弃牌
+- **胡**：可对任意玩家的弃牌（点炮）或自己摸到的牌（自摸）
+
+### 1.4 胡牌触发条件
+
+| 触发方式 | 说明 | 结算责任 |
+| --- | --- | --- |
+| 自摸 | 自己摸牌凑成胡牌型 | 其他三家各自支付（或庄家倍付，视规则） |
+| 点炮 | 吃进其他玩家打出的牌凑成胡牌型 | 点炮者支付（或三家分摊，视规则） |
+
+### 1.5 胡牌模式（游戏结束条件）
+
+| 模式 | 说明 | 结算时机 |
+| --- | --- | --- |
+| **一局一胡** | 有人胡牌后本局立即结束 | 胡牌时结算，然后开始下一局 |
+| **血战到底** | 胡牌者退出行牌，剩余玩家继续直到只剩 1 人或牌墙摸完 | 每次胡牌时结算该胡牌者，局末统一结算未胡者 |
+| **血流成河** | 胡牌者**不退出**，继续行牌可再胡；直到牌墙摸完或仅剩 1 人未胡 | 每次胡牌时结算，可多次胡牌累计 |
+
+**血战到底 vs 血流成河对比**：
+
+| 对比项 | 血战到底 | 血流成河 |
+| --- | --- | --- |
+| 胡牌后 | 退出行牌，不再参与 | 继续行牌，可再次胡牌 |
+| 可胡次数 | 每人最多胡 1 次 | 每人可胡多次 |
+| 结束条件 | 仅剩 1 人 或 牌墙摸完 | 仅剩 1 人未胡 或 牌墙摸完 |
+| 策略差异 | 胡牌后无风险 | 胡牌后仍需防守 |
+
+**血流成河特殊规则**：
+- 胡牌后不退出，继续参与后续摸打（按规则处理胡后手牌与状态）
+- 若被点炮，点炮者需支付；若自摸，三家支付
+- 已胡玩家打出的牌仍可被他人胡（可能被多次点炮）
+- 结算时累计所有胡牌的番数
+
+### 1.6 行牌顺序与出牌权
+
+**默认顺序**：庄家 → 下家 → 对家 → 上家（逆时针）
+
+| 事件 | 出牌权归属 | 说明 |
+| --- | --- | --- |
+| 正常打牌后无人响应 | 下家 | 按逆时针顺序轮转 |
+| 吃牌后 | 吃牌者 | 吃牌者打 1 张后，按其下家继续 |
+| 碰牌后 | 碰牌者 | 碰牌者打 1 张后，按其下家继续 |
+| 杠牌后 | 杠牌者 | 杠牌者补摸后打 1 张，按其下家继续 |
+| 胡牌后（一局一胡） | 游戏结束 | 进入结算 |
+| 胡牌后（血战到底） | 下一位未胡玩家 | 胡牌者退出行牌，剩余玩家继续 |
+| 胡牌后（血流成河） | 下一位玩家（含胡牌者） | 胡牌者**不退出**，继续行牌可再胡 |
+
+---
+
+## 二、特殊节奏机制（闭环规则）
+
+以下机制改变默认"摸 1 打 1"节奏，使用时**必须显式说明闭环规则**以保证手牌守恒。
+
+### 2.1 摸三打三
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 特定功能牌触发 / 特定阶段 / 玩家选择 |
+| 动作序列 | 摸 3 张 → 打 3 张 |
+| 手牌变化 | 13 → 16 → 13 |
+| 闭环验证 | 回合结束仍为 13 张 ✅ |
+| 注意事项 | 中间状态手牌为 16 张，需明确是否允许在此期间宣告胡牌/杠牌 |
+
+### 2.2 海底漫游
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 牌墙仅剩最后 1 张（海底牌）时触发 |
+| 动作序列 | 当前玩家可选择：(1) 摸海底牌 → 打 1 张 或 胡牌；(2) 放弃 → 下家决定 |
+| 手牌变化 | 与普通回合相同：13 → 14 → 13（或胡牌） |
+| 闭环验证 | 若摸牌则正常闭环；若放弃则手牌不变 ✅ |
+| 特殊结算 | 海底捞月（自摸海底牌胡牌）通常有额外番数 |
+
+### 2.3 海捞阶段（合肥麻将特色）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 牌墙仅剩最后 4 张时，进入海捞阶段 |
+| 动作序列 | 最后 4 张放入"海捞区" → 四家依次各抓 1 张（不打牌） → 若有人胡牌则停止海捞进入结算 |
+| 手牌变化 | 13 → 14（抓牌后）→ 不打牌，直接判定胡牌或流局 |
+| 闭环验证 | 海捞阶段是**终结阶段**，不需要回到 13 张，直接进入结算 ✅ |
+| 胡牌判定 | 抓牌后若满足胡牌条件可立即宣告；若无人胡牌则流局 |
+
+### 2.4 连续摸牌（功能牌触发）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 打出特定功能牌 / 摸到特定牌 |
+| 动作序列 | 额外摸 N 张 → 额外打 N 张（N 由规则定义） |
+| 手牌变化 | 13 → 13+N → 13 |
+| 闭环验证 | 必须"摸 N 打 N"形成闭环 ✅ |
+| 注意事项 | 需明确连续摸牌期间是否可以吃/碰/杠/胡 |
+
+---
+
+## 二（续）、开局阶段机制
+
+### 2.5 换三张（起手换牌）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发时机 | 发牌完成后、行牌开始前 |
+| 参与玩家 | 所有玩家同时进行 |
+| 规则说明 | 每人从手牌中选择 3 张**同花色**的牌，与指定方向的玩家交换 |
+
+**换牌方向**（常见规则）：
+| 方向 | 说明 |
+| --- | --- |
+| 顺时针 | 与下家交换（自己选的 3 张给下家，收上家的 3 张） |
+| 逆时针 | 与上家交换（自己选的 3 张给上家，收下家的 3 张） |
+| 对家 | 与对家交换 |
+| 随机 | 系统随机决定本局方向 |
+
+**换三张流程**：
+```
+1. 发牌完成，每人 13 张（庄家 14 张）
+2. 每人选择 3 张同花色的牌（必须同花色）
+3. 系统公布本局换牌方向（如：逆时针）
+4. 所有人确认后，同时交换
+5. 换牌完成，进入定缺/行牌阶段
+```
+
+**手牌守恒**：
+- 换牌前后手牌数量不变（换出 3 张，换入 3 张）
+- 13 张 → 13 张（庄家 14 → 14）✅
+
+**规则变体**：
+| 变体 | 说明 |
+| --- | --- |
+| 必须同花色 | 只能选同一花色的 3 张牌交换（最常见） |
+| 可不同花色 | 可任选 3 张牌交换（少见） |
+| 换完定缺 | 换牌后需声明"定缺"花色 |
+
+### 2.6 定缺（选缺门）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发时机 | 换三张完成后（或发牌完成后，若无换三张） |
+| 规则说明 | 每人选择一种花色作为"缺门"，该花色的牌必须全部打出后才能胡牌 |
+| 常见缺门 | 万、条、筒三选一 |
+
+**定缺与胡牌**：
+- 胡牌时手中不能有缺门花色的牌
+- 未清缺门的玩家不能胡牌（即使牌型满足）
+- 局末流局时，未清缺门者为花猪，需罚分；若同时未听牌，可另叠加查大叫
+
+---
+
+## 三、争议机制详细规则
+
+### 3.1 抢杠胡
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 玩家 A 将已碰的刻子补杠时，玩家 B 可胡这张补杠牌 |
+| 胡牌类型 | **视为点炮**（由补杠者 A 支付） |
+| 杠是否生效 | **不生效**，补杠操作取消，该牌被 B 胡走 |
+| 补牌是否发生 | **不发生**，因为杠操作被抢断 |
+| 轮次归属 | 游戏结束（一局一胡）或 B 退出行牌（血战） |
+| 优先级 | 抢杠胡属于"胡"，优先级最高 |
+
+### 3.2 一炮多响
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 玩家 A 打出一张牌，多家（B、C）同时可胡 |
+| 处理方式（三种常见规则） | |
+| (1) 一炮多响-全响 | B、C 都胡，A 向 B、C 各支付一份 |
+| (2) 一炮多响-头家优先 | 按逆时针顺序，离 A 最近的 B 先胡；C 不能胡 |
+| (3) 禁止一炮多响 | 出现多家可胡时，该牌作废，无人能胡（少见） |
+| 轮次归属（血战模式） | 所有胡牌者退出行牌，由 A 的下一位未胡玩家继续 |
+| 轮次归属（一局一胡） | 游戏结束，进入结算 |
+
+### 3.3 自摸加底/加番
+
+| 项目 | 说明 |
+| --- | --- |
+| 常见规则 | 自摸胡牌比点炮胡牌多 1 番 / 底分翻倍 |
+| 结算方式 | 三家各自支付（而非仅点炮者支付） |
+
+### 3.4 杠上炮（杠后点炮）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 玩家 A 杠牌后补摸，打出的牌被玩家 B 胡 |
+| 胡牌类型 | **点炮**（由杠后打牌者 A 支付） |
+| 与普通点炮区别 | 部分规则下杠上炮需额外加番/加倍 |
+| 杠是否生效 | **生效**，杠牌操作已完成，只是打出的牌被胡走 |
+| 轮次归属 | 按普通点炮处理（一局一胡结束；血战则 B 退出） |
+
+**杠上炮推演**：
+```
+A 杠（明杠或暗杠）→ A 补摸 → A 打出 🀐 → B 胡 🀐
+
+结果：
+- A 的杠已生效（杠组保留）
+- A 点炮给 B
+- 若有杠上炮加番规则，则 B 的胡牌番数增加
+```
+
+**与抢杠胡的区别**：
+| 对比项 | 抢杠胡 | 杠上炮 |
+| --- | --- | --- |
+| 触发时机 | 补杠宣告时 | 杠后打牌时 |
+| 杠是否生效 | 不生效（碰组恢复） | 生效（杠组保留） |
+| 被胡的牌 | 补杠的那张牌 | 杠后打出的牌 |
+
+---
+
+## 三（续）、复杂场景推演与决策流程
+
+### 3.5 连续碰杠混合推演
+
+**场景**：一局中玩家进行多次吃/碰/杠操作时的位置累积计算。
+
+#### 3.5.1 已碰 2 次后再明杠
+
+```
+初始状态：暗牌 7 张 + 2 个碰组（各 3 张）= 7 + 6 = 13 张
+他人打出 🀃，我用手中 3 张 🀃🀃🀃 明杠
+杠后：暗牌 4 张 + 2 碰组 6 张 + 1 杠组 4 张 = 14 张
+补摸：暗牌 5 张 + 6 + 4 = 15 张
+打牌：暗牌 4 张 + 6 + 4 = 14 张
+结束：14 张 = 13 + 1（杠组数）✅
+```
+
+#### 3.5.2 连续杠（杠后补摸又能杠）
+
+**场景**：明杠后补摸，发现能再暗杠
+
+```
+初始状态：暗牌 13 张
+
+第一次杠（明杠）：
+  他人打出 🀀，我用手中 3 张 🀀🀀🀀 明杠
+  杠后：暗牌 10 张 + 杠组 4 张 = 14 张
+  补摸 🀁：暗牌 11 张 + 杠组 4 张 = 15 张
+  此时发现手中有 🀁🀁🀁🀁（含刚摸的），可以暗杠！
+
+第二次杠（暗杠，代替打牌）：
+  暗杠：暗牌 7 张 + 明杠组 4 张 + 暗杠组 4 张 = 15 张
+  补摸：暗牌 8 张 + 4 + 4 = 16 张
+  打牌：��牌 7 张 + 4 + 4 = 15 张
+  结束：总牌数 15 张
+
+结论：连续杠时，最终牌数 = 13 + 杠组数
+本例：13 + 2 = 15 张 ✅
+
+原因：每个杠组比碰组多 1 张牌（4 vs 3），且连续杠时只打 1 张牌
+```
+
+**通用规则**：
+- 连续杠允许（补摸后可选择再杠而非打牌）
+- 每次杠都需补摸，但连续杠时只有最后一次打牌
+- 最终牌数 = 13 + 杠组总数
+
+#### 3.5.3 碰杠混合的通用公式
+
+```
+回合结束牌数 = 13 + 杠组数
+
+验证：
+- 无吃碰杠：13 张 ✅
+- 1 碰：13 张 ✅
+- 2 碰：13 张 ✅
+- 1 杠（明杠或暗杠）：14 张 ✅
+- 2 杠：15 张 ✅
+- 2 碰 + 1 杠：14 张 ✅
+- 1 碰 + 2 杠：15 张 ✅
+```
+
+**核心理解**：
+- 吃/碰不改变结束牌数（取弃牌形成组合后打 1 张，净增 0）
+- 每个杠使结束牌数 +1（杠组 4 张 > 碰组 3 张，且杠后补摸再打 1 张）
+
+### 3.6 抢杠胡完整流程与推演
+
+#### 3.6.1 抢杠胡决策流程
+
+```
+玩家 A 补杠（将碰组升级为杠组）
+    │
+    ▼
+系统广播：A 补杠 🀐
+    │
+    ▼
+其他玩家（B、C、D）判断是否可胡这张 🀐
+    │
+    ├─── 有人可胡 ──→ 进入抢杠胡判定
+    │                    │
+    │                    ├─ 单人可胡：该玩家胡牌
+    │                    │
+    │                    └─ 多人可胡：按一炮多响规则处理
+    │
+    └─── 无人可胡 ──→ A 的补杠生效，A 补摸后打牌
+```
+
+#### 3.6.2 抢杠胡牌数推演
+
+**场景**：A 补杠被 B 抢杠胡
+
+```
+A 的状态变化：
+  补杠前：暗牌 11 张 + 碰组 3 张 = 14 张（摸牌后）
+  宣布补杠：暗牌 10 张 + 杠组 4 张（碰组+1张）= 14 张
+  被抢杠胡：补杠取消，补杠牌被 B 胡走
+  最终状态：暗牌 10 张 + 碰组 3 张 = 13 张
+
+  注意：A 手中那张用于补杠的牌被 B 胡走，碰组恢复原状
+  实际上：A 暗牌 10 张 + 碰组 3 张 = 13 张 ✅
+
+B 的状态变化：
+  胡牌前：暗牌 13 张
+  抢杠胡：取 A 的补杠牌凑成胡牌型
+  最终状态：胡牌（一局一胡则游戏结束；血战则 B 退出行牌）
+
+轮次归属：
+  - 一局一胡：游戏结束，进入结算
+  - 血战模式：B 退出行牌，从 A 的下家（跳过 B 如果 B 在 A 下家方向）继续
+```
+
+### 3.7 多人同时响应处理流程
+
+#### 3.7.1 响应优先级决策树
+
+```
+玩家 X 打出一张牌 🀐
+    │
+    ▼
+收集所有玩家的响应意图（吃/碰/杠/胡/过）
+    │
+    ▼
+按优先级排序：胡 > 碰 > 杠 > 吃
+    │
+    ├─── 有人胡牌 ──→ 单人胡：该玩家胡牌
+    │                 │
+    │                 └─ 多人胡：按一炮多响规则
+    │                          │
+    │                          ├─ 全响：所有可胡者都胡
+    │                          ├─ 头家优先：离 X 最近者胡
+    │                          └─ 禁止：该牌作废，进入下家
+    │
+    ├─── 有人碰/杠（无人胡）──→ 碰/杠者获得该牌，由其出牌
+    │                          （多人碰时：离 X 最近者优先）
+    │
+    ├─── 有人吃（无人碰杠胡）──→ 下家吃牌，由其出牌
+    │
+    └─── 无人响应 ──→ 按顺序轮到 X 的下家摸牌
+```
+
+#### 3.7.2 多人碰冲突处理
+
+```
+场景：X 打出 🀐，B（X 下家）和 D（X 上家）都想碰
+
+优先级判定：按逆时针顺序，离 X 最近者优先
+X → B（下家，距离 1）→ C（对家，距离 2）→ D（上家，距离 3）
+
+结果：B 优先碰牌
+
+轮次：B 碰后由 B 出牌，然后按 B 的下家 C 继续
+```
+
+### 3.8 复杂出牌顺序规则
+
+#### 3.8.1 血战模式胡牌退出后的顺序接续
+
+```
+初始顺序：庄家 A → B → C → D（逆时针）
+
+场景 1：B 胡牌退出
+  剩余顺序：A → C → D → A ...
+  当前出牌者的下家判定：跳过已胡玩家
+
+场景 2：A（庄家）胡牌退出
+  剩余顺序：B → C → D → B ...
+  注意：庄家退出后，行牌仍按原顺序，只是跳过 A
+
+场景 3：B 和 D 一炮多响同时胡牌退出（全响规则）
+  剩余顺序：A → C → A ...
+  只剩 2 人时继续行牌直到再有人胡或流局
+```
+
+#### 3.8.2 一炮多响后的轮次归属
+
+```
+场景：A 打出 🀐，B 和 C 一炮多响都胡
+
+规则 1（全响-血战模式）：
+  B 和 C 都胡牌退出
+  下一个出牌者：A 的下家中第一个未胡者
+  若 B 是 A 下家：跳过 B，轮到 C 的下家（D）
+  若 B 不是 A 下家：轮到 A 的直接下家（如果未胡）
+
+规则 2（头家优先-血战模式）：
+  仅 B（离 A 最近者）胡牌退出
+  下一个出牌者：A 的下家中第一个未胡者
+
+规则 3（一局一胡模式）：
+  游戏结束，进入结算
+```
+
+#### 3.8.3 杠后开花的特殊顺序
+
+```
+场景：A 杠牌后补摸，补摸的牌正好能���（杠上开花/杠上自摸）
+
+流程：
+  A 杠 → A 补摸 → A 宣布杠上开花（自摸胡牌）
+
+轮次归属：
+  - 一局一胡：游戏结束
+  - 血战模式：A 退出行牌，从 A 的下家继续
+
+注意：杠上开花是自摸，不是点炮，结算方式按自摸计算
+```
+
+#### 3.8.4 连续响应的顺序处理
+
+```
+场景：复杂的连续响应链
+
+X 打出 🀐 → B 碰 → B 打出 🀒 → D 碰 → D 打出 🀔 → A 胡
+
+轮次追踪：
+  X 出牌 → B 碰(打断顺序) → B 出牌 → D 碰(打断顺序) → D 出牌 → A 胡
+
+规则：每次吃/碰/杠都会"打断"原顺序，由响应者接管出牌权
+胡牌终止当前行牌（一局一胡）或让胡者退出（血战）
+```
+
+---
+
+## 四、创新机制库（按目的分类）
+
+| 目的 | 机制 | 底层影响 |
+| --- | --- | --- |
+| 加快玩家胡牌节奏 | 赖子牌（百搭）、摸三打三、一炮多响、抢杠胡、限制胡牌倍数上限 | 赖子影响牌型判定；摸三打三需闭环验证 |
+| 促进玩家做大牌 | 限制起胡倍数、增加番型倍数、功能牌加倍、平胡只能自摸 | 影响 win_rules 和 scoring |
+| 鼓励玩家积极进攻 | 血战到底、定缺花色、查大叫、退税 | 血战影响 game_variant；定缺影响 setup |
+| 增强社交性 | 2v2 组队、信息共享 | 影响 players 和 settlement |
+| 增强游戏趣味性 | 功能牌连续摸牌、两张相同牌三选一、百景图点亮 | 需闭环验证；影响 extensions |
+| 鼓励玩家尽早听牌 | 捉鸡（未听牌需结算鸡牌） | 影响 settlement |
+| 增加单局最大输赢 | 抓码/扎鸟/买马、赖子杠×10、明牌×6、破封、漂分 | 影响 scoring 和 settlement |
+| 保护小持币量玩家 | 封顶倍数、封顶金币 | 影响 settlement |
+| 增强策略博弈 | 换牌、比牌、海底漫游、海捞阶段、暴击 | 海底/海捞需闭环验证；暴击影响 settlement |
+
+---
+
+## 四（续）、金流与结算机制
+
+### 4.1 杠牌即时结算
+
+| 项目 | 说明 |
+| --- | --- |
+| 结算时机 | 杠牌动作完成后**立即结算**，不等到局末 |
+| 明杠（直杠）| 被杠者向杠牌者支付固定分数（如：2 分） |
+| 补杠 | 三家各向杠牌者支付固定分数（如：各 1 分） |
+| 暗杠 | 三家各向杠牌者支付固定分数（如：各 2 分） |
+
+**杠牌结算与胡牌结算独立**：
+- 杠牌得分在杠时即刻入账
+- 即使最终流局，杠牌得分仍然有效
+- 若被抢杠胡，杠不生效，杠分不结算
+
+### 4.2 一炮多响金流分配
+
+**场景**：A 点炮，B 和 C 同时胡牌（全响规则）
+
+| 分配方式 | 说明 |
+| --- | --- |
+| **各付各** | A 向 B 支付 B 的胡牌分，向 C 支付 C 的胡牌分（A 支付两份） |
+| **共付** | A 支付 B 和 C 中较高者的分数，B 和 C 平分（少见） |
+
+**常见规则**：A 需向每位胡牌者分别支付，不合并计算。
+
+### 4.3 玩家破产时的金流处理
+
+**场景**：A 点炮，B 和 C 一炮多响，但 A 金币不足以支付两份
+
+| 处理方式 | 说明 |
+| --- | --- |
+| **按顺序支付** | 先支付离 A 最近的胡牌者（如 B），剩余金币再支付 C；C 可能只收到部分或 0 |
+| **按比例分配** | A 的剩余金币按 B、C 应得比例分配 |
+| **借贷/记账** | A 欠款记录，后续局次偿还（需系统支持） |
+| **破产离场** | A 支付完全部金币后离场，剩余玩家继续 |
+
+**破产判定时机**：
+- 即时破产：每次支付后判定，金币≤0 则破产
+- 局末破产：局末统一结算，金币<0 则破产
+
+### 4.4 呼叫转移（包三家）
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 点炮者需承担原本应由三家分别支付的分数 |
+| 常见场景 | 点炮给大牌（如：点炮给清一色） |
+| 计算方式 | 点炮者支付 = 自摸时三家应付总和 |
+
+**示例**：
+```
+B 胡牌 8 番（底分 1）
+  自摸：A、C、D 各付 8 分，B 得 24 分
+  A 点炮（呼叫转移）：A 付 24 分，B 得 24 分
+```
+
+### 4.5 查大叫与查花猪
+
+| 机制 | 触发条件 | 赔付规则 |
+| --- | --- | --- |
+| **查大叫** | 局末流局时，未听牌的玩家 | 向已听牌的玩家赔付（按听牌最大番型计算） |
+| **查花猪** | 局末流局时，未清缺门的玩家 | 向已清缺门的玩家赔付（通常为固定倍数或按番型） |
+
+**赔付计算**：
+
+| 情况 | 赔付方式 |
+| --- | --- |
+| 查大叫 | 未听牌者向每位听牌者支付"其听牌最大可胡番型"的分数 |
+| 查花猪 | 未清缺门者向每位已清缺门者支付固定罚分（如：16 分） |
+| 既未听又花猪 | 两项罚分叠加 |
+
+**示例**：
+```
+局末流局：
+  A：已听牌，最大听 16 番
+  B：已听牌，最大听 8 番
+  C：未听牌（大叫）
+  D：未清缺门（花猪）
+
+赔付：
+  C 向 A 付 16 分，向 B 付 8 分
+  D 向 A、B、C 各付花猪罚分（如各 16 分）
+```
+
+### 4.6 退税机制
+
+| 项目 | 说明 |
+| --- | --- |
+| 触发条件 | 胡牌者的胡牌牌型中包含被某玩家打过的牌 |
+| 结算方式 | 该玩家需额外支付"退税"分数 |
+| 计算方式 | 通常为固定分数或番数加成 |
+
+**示例**：
+```
+A 胡"一筒"，B 之前打过"一筒"
+B 需向 A 额外支付退税分（如：胡牌分×2）
+```
+
+---
+
+## 五、动作-手牌变化速查表（硬性参考）
+
+| 动作 | 牌来源 → 去向 | 手牌净变化 | 是否强制打 1 张 | 出牌权归属 |
+| --- | --- | --- | --- | --- |
+| 摸牌 | 牌墙 → 手牌 | +1（13→14） | 是 | 当前玩家 |
+| 打牌 | 手牌 → 弃牌堆 | -1（14→13） | — | 下家（或响应者） |
+| 吃 | 上家弃牌 + 手牌 2 张 → 明牌组 | 0（净变化；暗牌-2，明牌+3，取弃牌+1，抵消） | 是 | 吃牌者 |
+| 碰 | 他人弃牌 + 手牌 2 张 → 明牌组 | 0（同上） | 是 | 碰牌者 |
+| 直杠（明杠） | 他人弃牌 + 手牌 3 张 → 明牌组 | 0 → 补摸+1 → 打-1（回合结束总计14） | 是（补摸后） | 杠牌者 |
+| 补杠 | 手牌 1 张 → 已碰刻子变杠 | 0 → 补摸+1 → 打-1（回合结束总计14） | 是（补摸后） | 杠牌者 |
+| 暗杠 | 手牌 4 张 → 暗杠组 | 0 → 补摸+1 → 打-1（回合结束总计14） | 是（补摸后） | 杠牌者 |
+| 杠后补牌 | 牌墙 → 手牌 | +1 | 是 | 杠牌者 |
+
+---
+
+## 六、最小回合推演模板（验证守恒）
+
+### 6.1 普通回合
+```
+初始：手牌 13 张
+摸牌：手牌 14 张（+1）
+打牌：手牌 13 张（-1）
+结束：手牌 13 张 ✅
+```
+
+### 6.2 碰牌回合
+```
+初始：暗牌 13 张
+他人打出 🀐，我用手中 2 张 🀐🀐 碰
+碰后：暗牌 11 张 + 碰组 3 张 = 14 张
+打牌：暗牌 10 张 + 碰组 3 张 = 13 张
+结束：总牌数 13 张 ✅
+```
+
+### 6.3 杠牌回合（直杠/明杠）
+
+**关键概念**：明杠后，玩家总牌数比普通回合多 1 张（因为杠组 4 张 > 碰组 3 张）。
+
+```
+初始：暗牌 13 张
+他人打出 🀐，我用手中 3 张 🀐🀐🀐 明杠
+杠后：暗牌 10 张 + 杠组 4 张 = 14 张
+补摸：暗牌 11 张 + 杠组 4 张 = 15 张
+打牌：暗牌 10 张 + 杠组 4 张 = 14 张
+结束：总牌数 14 张（比普通回合多 1 张）✅
+```
+
+### 6.3.1 暗杠回合
+
+**关键概念**：暗杠发生在**摸牌后**（此时手牌 14 张），用手中 4 张组杠，然后补摸 1 张，打 1 张。
+
+```
+初始：暗牌 13 张
+摸牌：暗牌 14 张
+此时发现手中有 4 张 🀐🀐🀐🀐，宣布暗杠
+暗杠后：暗牌 10 张 + 暗杠组 4 张 = 14 张
+补摸：暗牌 11 张 + 暗杠组 4 张 = 15 张
+打牌：暗牌 10 张 + 暗杠组 4 张 = 14 张
+结束：总牌数 14 张（比普通回合多 1 张）✅
+```
+
+### 6.3.2 补杠回合
+
+**关键概念**：补杠发生在**摸牌后**（此时手牌 14 张），将手中 1 张补到已碰的刻子上，然后补摸 1 张，打 1 张。
+
+```
+初始：暗牌 10 张 + 碰组 3 张 = 13 张
+摸牌：暗牌 11 张 + 碰组 3 张 = 14 张
+补杠：暗牌 10 张 + 杠组 4 张（碰组 3 张 + 补上的 1 张）= 14 张
+补摸：暗牌 11 张 + 杠组 4 张 = 15 张
+打牌：暗牌 10 张 + 杠组 4 张 = 14 张
+结束：总牌数 14 张（比普通回合多 1 张）✅
+```
+
+### 6.4 海捞阶段回合（合肥麻将）
+```
+进入海捞：手牌 13 张
+抓海捞牌：手牌 14 张（+1）
+不打牌，直接判定
+若胡牌：结算
+若未胡：等待其他玩家抓牌判定，最终流局
+结束：无需回到 13 张（终结阶段）✅
+```