diff --git a/.gitignore b/.gitignore
index 801d93c757ef32be7342402d6158cc620bb90fcf..dbe9c82b3610ccd58d1c681848dcd322e500051e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1 @@
-.vscode/
-data/nutrition/raw/
+.vscode/
\ No newline at end of file
diff --git a/__pycache__/loop.cpython-311.pyc b/__pycache__/loop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..085e15b01373f2a7f8633a17acf19e6ae794764e
Binary files /dev/null and b/__pycache__/loop.cpython-311.pyc differ
diff --git a/__pycache__/loop.cpython-313.pyc b/__pycache__/loop.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b48df87597f1eb51c5e16b096974c90e08db6713
Binary files /dev/null and b/__pycache__/loop.cpython-313.pyc differ
diff --git a/app.py b/app.py
index 2d58c727497581be1e6407fc3d4983446c2c7536..365a5aa286b80e36b4aa637e48ad8c3c8a024527 100644
--- a/app.py
+++ b/app.py
@@ -1,12 +1,13 @@
 """
 PregoPal - 孕期陪护AI助手
 =========================
-主入口：启动 Gradio 应用。
+主入口：启动 Gradio 应用 + 每日 Loop。
 
 架构：
-  app.py          ← 薄入口（仅启动）
+  app.py          ← 薄入口（启动 Gradio + Loop）
   config.py       ← 全局配置
-  core/           ← AI 核心层（等待 MiniCPM-o 部署）
+  loop.py         ← 核心循环引擎（状态机驱动）
+  plugins/        ← Loop 插件
   modules/        ← 业务逻辑层
   ui/             ← 表现层（Gradio 界面）
   data/           ← 数据存储
@@ -14,9 +15,14 @@ PregoPal - 孕期陪护AI助手
 
 import gradio as gr
 from ui.app_builder import create_app
+from loop import check_and_run_loop
 
 if __name__ == "__main__":
-    demo = create_app()
+    # 启动时检查并运行每日 Loop
+    loop = check_and_run_loop()
+
+    # 创建并启动 Gradio 应用
+    demo = create_app(loop)
     demo.launch(
         theme=gr.themes.Soft(
             primary_hue="pink",
diff --git a/c b/c
new file mode 100644
index 0000000000000000000000000000000000000000..49721fb5307f7f7c4cd9e9f9930a078de09b3dbd
--- /dev/null
+++ b/c
@@ -0,0 +1,502 @@
+# 🌸 PregoPal 项目理解与技术架构（v4 - Loop 驱动 + 三文档操作）
+
+> 本文档已完成重构，每个小节末尾附有批注区，便于你边看边标注意见。
+
+---
+
+## 一、一句话定位
+
+**一个基于每日生命周期 Loop 驱动的孕期陪护 AI 助手**：每天首次启动时自动总结昨日饮食、对比国家营养标准（DRIs/膳食指南/体重标准），生成今日简报注入对话上下文；白天与家庭成员（通过声纹区分）自然交互，实时记录饮食、推荐食谱；次日循环往复。
+
+> **批注：** ________
+
+---
+
+## 二、三个营养文档的操作方法
+
+你已经下载到 `data/nutrition/raw/` 的三个文件，各自承担不同角色：
+
+| 文档 | 文件 | 用途 | PregoPal 的操作方式 |
+|------|------|------|-------------------|
+| **① 体重增长标准** | `妊娠期妇女体重增长推荐值标准.md` | 体重监测基准 | **主动询问体重** — 每天 Loop 中检查是否需要询问，对照 BMI 分类给出评价 |
+| **② 膳食指南** | `中国孕期妇女膳食指南2022图片转md版.md` | 食谱推荐基准 | **作为推荐食谱的约束基础** — 根据孕期阶段用宝塔推荐量生成模板 |
+| **③ DRIs** | `备孕&孕早中晚三期和哺乳期的所有膳食营养素参考摄入量.md` | 营养分析基准 | **Agent 定期思考** — 每天自动对比 RNI，分析不足，写入次日预设 |
+
+> **批注：** ________
+
+### 2.1 体重增长标准 → 主动询问体重
+
+**数据来源**：WS/T 801-2022 表1
+
+```
+每天早上 Loop 的 weight_check 插件：
+  ├→ 检查 data/logs/ 中是否有近期的体重记录
+  ├→ 若无记录或记录超过 7 天
+  │   └→ 在今日简报中标记「需询问体重」
+  │      （UI 弹出体重卡片，或语音询问：「今天称体重了吗？」）
+  └→ 若有记录
+       ├→ 计算当前孕周、孕前 BMI、当前总增长值
+       ├→ 对照标准表：
+
+       | 孕前 BMI 分类         | 总增长范围  | 每周增长(中+晚) |
+       |----------------------|------------|----------------|
+       | 低体重 BMI<18.5      | 11.0~16.0  | 0.46(0.37~0.56) |
+       | 正常 18.5≤BMI<24.0   | 8.0~14.0   | 0.37(0.26~0.48) |
+       | 超重 24.0≤BMI<28.0   | 7.0~11.0   | 0.30(0.22~0.37) |
+       | 肥胖 BMI≥28.0        | 5.0~9.0    | 0.22(0.15~0.30) |
+
+       ├→ 在范围内 → ✅ 鼓励「体重增长很好，继续保持！」
+       └→ 超出范围 → ⚠️ 提醒「增长偏快/偏慢，建议调整饮食/咨询医生」
+```
+
+> **批注：** ________
+
+### 2.2 膳食指南 → 食谱推荐基础
+
+**数据来源**：中国孕期妇女平衡膳食宝塔（备孕/孕中期/孕晚期/哺乳期）
+
+```
+推荐食谱时，AI 的约束条件：
+  ├→ 孕中期宝塔：
+  │   奶类 300-500g，鱼禽蛋肉类 150-200g，谷类 200-250g
+  │   蔬菜 400-500g，水果 200-300g，薯类 75g
+  │   大豆 20g，坚果 10g，油 25g，盐 5g
+  │
+  ├→ 孕晚期宝塔：
+  │   奶类 300-500g，鱼禽蛋肉类 175-225g，谷类 225-275g
+  │   蔬菜 400-500g，水果 200-350g，薯类 75g
+  │   大豆 20g，坚果 10g，油 25g，盐 5g
+  │
+  └→ 膳食指南六条核心建议（嵌入系统提示词）：
+      1. 调整孕前体重至正常范围
+      2. 常吃含铁食物，选用碘盐，补充叶酸和维生素D
+      3. 孕吐严重者少量多餐
+      4. 孕中晚期增加奶、鱼、禽、蛋、瘦肉
+      5. 经常户外活动，禁烟酒
+      6. 愉快孕育新生命，积极准备母乳喂养
+```
+
+**原有 MEAL_TEMPLATES 的改造**：不再硬编码模板字符串，而是将上述宝塔约束条作为结构化 JSON 传递给 AI（或作为本地 fallback 兜底），由 AI 根据宝塔约束 + 用户偏好生成个性化食谱。
+
+> **批注：** ________
+
+### 2.3 DRIs → Agent 定期分析（自动运行 → 写入次日预设）
+
+**数据来源**：表15（孕早期）/ 表16（孕中期）/ 表17（孕晚期）/ 表18（哺乳期）
+
+```
+每天 Loop 的 dri_analysis 插件：
+  ├→ 读取昨日饮食记录（data/logs/饮食日志_YYYY-MM-DD.md）
+  ├→ 根据当前孕期阶段选择对应 DRIs 表
+  ├→ 关键营养素逐项对比（重点标记 RNI 与摄入量差异）：
+
+      ┌─────────────────────────────────────────────┐
+      │  营养素         RNI(孕中期)   昨日摄入   差异  │
+      ├─────────────────────────────────────────────┤
+      │  能量(MJ)       9.84(PAL II)  8.2       -17% │
+      │  蛋白质(g)      70           55         -21% │
+      │  钙(mg)         800          420        -48% │
+      │  铁(mg)         25           12         -52% ← 重点关注 │
+      │  叶酸(μg DFE)   600          350        -42% ← 重点关注 │
+      │  维生素D(μg)    10           2.1        -79% ← 重点关注 │
+      └─────────────────────────────────────────────┘
+
+  ├→ 生成分析结论（自然语言）：
+  │   「昨天钙、铁、叶酸摄入偏低，建议今天多吃：
+  │     ✓ 深绿色蔬菜（菠菜、西兰花）
+  │     ✓ 瘦肉/动物肝脏
+  │     ✓ 豆制品/奶制品」
+  │
+  └→ 写入 data/presets/今日简报_YYYY-MM-DD.json
+       ├ 今日重点关注营养素列表
+       ├ 今日推荐食物类别与份量
+       ├ 体重提醒（如需）
+       └ 与孕妇及家人交谈的建议开场话题
+```
+
+> **批注：** ________
+
+---
+
+## 三、核心架构：Loop 驱动（状态机 + 插件注册）
+
+### 3.1 设计理念
+
+PregoPal 不是一个「用户点按钮 → 出结果」的被动应用，而是**有每日生命周期的主动伴侣**。
+
+参考你提供的 `nanobot_core/agent/loop.py` 中的**状态机事件驱动模式**，PregoPal 的 Loop 提取两个核心设计：
+
+1. **TurnState 状态机**（类比 `_process_message` 的 `_state_*` 状态链）— 管理每日生命周期的阶段流转
+2. **可注册的扩展能力**（类比 ToolRegistry）— 每个阶段的具体逻辑由 Plugin 实现
+
+> **批注：** ________
+
+### 3.2 每日生命周期
+
+```
+                         ┌─────────────┐
+                         │   LAUNCH    │  ← 首次启动检查
+                         │   (启动)     │
+                         └──────┬──────┘
+                                │
+                    ┌───────────┴───────────┐
+                    │                       │
+             首次运行今日                已运行过今日
+                    │                       │
+                    ▼                       ▼
+            ┌──────────────┐       ┌──────────────┐
+            │  SUMMARIZE   │       │              │
+            │  (昨日总结)    │       │              │
+            │  ├ 读取饮食日志 │       │              │
+            │  └ 检查体重   │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               │              │
+            ┌──────────────┐       │              │
+            │   ANALYZE    │       │              │
+            │  (营养分析)    │       │              │
+            │  └ 对比DRIs  │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               │              │
+            ┌──────────────┐       │              │
+            │    BRIEF     │       │              │
+            │  (生成简报)    │       │              │
+            │  └ 写JSON    │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               ▼              │
+            ┌──────────────────────────────────┐  │
+            │           INTERACT               │◄─┘
+            │       (白天交互模式)               │
+            │  ├ 声纹识别 → 区分说话人           │
+            │  ├ 对话理解 → 记录饮食/推荐/闲聊    │
+            │  └ 简报注入 → AI 知道今日关注点    │
+            └──────────────┬───────────────────┘
+                           │
+                     用户结束今日
+                           │
+                           ▼
+            ┌──────────────┐
+            │ CONSOLIDATE  │
+            │  (晚间整理)    │  ← 可选（关闭页面时触发）
+            │  ├ 汇总今日    │
+            │  └ 写明日预设  │
+            └──────┬───────┘
+                   │
+                   ▼
+            ┌──────────────┐
+            │     DONE     │
+            └──────────────┘
+```
+
+> **批注：** ________
+
+### 3.3 状态机定义
+
+```python
+# 状态枚举
+class LoopState(Enum):
+    LAUNCH = "launch"           # 启动检查：是否是今日首次运行
+    SUMMARIZE = "summarize"     # 昨日总结：分析昨日饮食/体重
+    ANALYZE = "analyze"         # 营养分析：对比 DRIs
+    BRIEF = "brief"             # 生成今日简报
+    INTERACT = "interact"       # 白天交互模式（等待用户操作）
+    CONSOLIDATE = "consolidate" # 晚间整理
+    DONE = "done"
+
+# 状态转移表（类比 nanobot_core 的 _TRANSITIONS）
+_TRANSITIONS = {
+    (LoopState.LAUNCH, "first_run_today"):  LoopState.SUMMARIZE,
+    (LoopState.LAUNCH, "already_run"):      LoopState.INTERACT,
+    (LoopState.SUMMARIZE, "ok"):            LoopState.ANALYZE,
+    (LoopState.ANALYZE, "ok"):              LoopState.BRIEF,
+    (LoopState.BRIEF, "ok"):                LoopState.INTERACT,
+    (LoopState.INTERACT, "day_ended"):      LoopState.CONSOLIDATE,
+    (LoopState.CONSOLIDATE, "ok"):          LoopState.DONE,
+}
+```
+
+> **批注：** ________
+
+### 3.4 状态处理器
+
+每个状态对应一个 handler（类比 `_state_restore`, `_state_compact`, `_state_run` 等）：
+
+| 状态 | Handler | 功能 |
+|------|---------|------|
+| `LAUNCH` | `_state_launch()` | 检查 `data/presets/` 中是否有今日简报 → 决定首次/已运行 |
+| `SUMMARIZE` | `_state_summarize()` | 遍历执行所有注册在 SUMMARIZE 阶段的 Plugin |
+| `ANALYZE` | `_state_analyze()` | 遍历执行所有注册在 ANALYZE 阶段的 Plugin |
+| `BRIEF` | `_state_brief()` | 遍历执行所有注册在 BRIEF 阶段的 Plugin |
+| `INTERACT` | `_state_interact()` | 等待用户交互（从 Gradio event queue 消费消息） |
+| `CONSOLIDATE` | `_state_consolidate()` | 遍历执行所有注册在 CONSOLIDATE 阶段的 Plugin |
+| `DONE` | `_state_done()` | 清理资源，标记今日完成 |
+
+> **批注：** ________
+
+### 3.5 主循环入口
+
+```python
+# loop.py 核心逻辑
+class PregoPalLoop:
+    def __init__(self):
+        self.plugins = PluginRegistry()
+        self.state = LoopState.LAUNCH
+        self._register_default_plugins()
+    
+    async def run(self) -> None:
+        """主循环入口"""
+        while self.state is not LoopState.DONE:
+            handler_name = f"_state_{self.state.value}"
+            handler = getattr(self, handler_name)
+            event = await handler()
+            next_state = _TRANSITIONS.get((self.state, event))
+            if next_state is None:
+                raise RuntimeError(f"No transition from {self.state} on {event}")
+            self.state = next_state
+    
+    async def _state_summarize(self) -> str:
+        """SUMMARIZE 阶段：执行所有相关插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.SUMMARIZE):
+            await plugin.run(self.context)
+        return "ok"
+```
+
+> **批注：** ________
+
+---
+
+## 四、插件系统设计（可扩展性）
+
+### 4.1 插件基类
+
+```python
+# plugins/base.py
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+
+class LoopStage(Enum):
+    """插件可注册的阶段"""
+    SUMMARIZE = "summarize"
+    ANALYZE = "analyze"
+    BRIEF = "brief"
+    CONSOLIDATE = "consolidate"
+
+@dataclass
+class LoopContext:
+    """插件上下文：共享数据容器"""
+    briefing: dict = field(default_factory=dict)    # 今日简报数据
+    weight_data: dict = field(default_factory=dict)  # 体重记录
+    diet_records: list = field(default_factory=list)  # 饮食记录
+    analysis_results: dict = field(default_factory=dict)  # 分析结果
+    errors: list = field(default_factory=list)         # 错误收集
+
+@dataclass
+class PluginResult:
+    """插件执行结果"""
+    success: bool
+    data: dict = field(default_factory=dict)
+    message: str = ""
+
+class LoopPlugin(ABC):
+    """Loop 扩展插件基类 — 所有插件继承此类"""
+    
+    @abstractmethod
+    def stage(self) -> LoopStage:
+        """此插件注册到哪个阶段"""
+    
+    @abstractmethod
+    def name(self) -> str:
+        """插件唯一名称"""
+    
+    @abstractmethod
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        """执行插件逻辑"""
+```
+
+> **批注：** ________
+
+### 4.2 内置插件清单
+
+| 插件 | 类名 | 注册阶段 | 功能 | 数据源 |
+|------|------|---------|------|--------|
+| 昨日饮食总结 | `DietSummaryPlugin` | SUMMARIZE | 读取昨日饮食日志，汇总三餐 | `data/logs/*.md` |
+| 体重检查 | `WeightCheckPlugin` | SUMMARIZE | 检查体重记录，对比 WS/T 801 | `data/logs/*.md` + 用户输入 |
+| DRIs 分析 | `DRIAnalysisPlugin` | ANALYZE | 对比营养素参考摄入量 | DRIs 表 + 昨日饮食 |
+| 简报生成 | `BriefingGeneratorPlugin` | BRIEF | 汇总分析为结构化 JSON | `LoopContext` |
+| 预设写入 | `PresetWriterPlugin` | CONSOLIDATE | 生成明日预设文件 | `data/presets/` |
+
+> **批注：** ________
+
+### 4.3 扩展方式
+
+```python
+# 后续新增功能（如血糖监测）只需两步：
+
+# 1. 写一个新插件
+class BloodSugarPlugin(LoopPlugin):
+    def stage(self) -> LoopStage: return LoopStage.SUMMARIZE
+    def name(self) -> str: return "blood_sugar"
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        # 读取血糖记录 → 分析趋势 → 写入 ctx
+        ...
+
+# 2. 注册到 loop
+loop.plugins.register(BloodSugarPlugin())
+
+# 不需要修改 loop.py 的任何状态机代码
+```
+
+> **批注：** ________
+
+---
+
+## 五、整体文件结构
+
+```
+PregoPal/
+├── app.py                          # 主入口：启动 Gradio + Loop
+├── config.py                       # 全局配置（路径/枚举/系统提示词模板）
+├── utils.py                        # 工具函数
+├── loop.py              ← 🆕 新增  # 核心循环引擎（状态机驱动）
+│
+├── plugins/              ← 🆕 新增  # Loop 插件
+│   ├── __init__.py
+│   ├── base.py                     # LoopPlugin 基类 + PluginRegistry
+│   ├── diet_summary.py             # 昨日饮食总结
+│   ├── weight_check.py             # 体重检查（WS/T 801）
+│   ├── dri_analysis.py             # DRIs 营养素对比分析
+│   ├── briefing_generator.py       # 今日简报生成器
+│   └── preset_writer.py            # 预设文件写入
+│
+├── core/                           # AI 核心层（等待 MiniCPM-o 部署）
+│   ├── __init__.py
+│   ├── model_loader.py             # 模型加载器（空接口）
+│   ├── voice_processor.py          # 语音处理器（空接口）
+│   ├── vision_processor.py         # 视觉处理器（空接口）
+│   └── conversation_manager.py     # 对话管理器（空接口）
+│
+├── modules/                        # 业务逻辑层
+│   ├── __init__.py
+│   ├── voiceprint.py               # 声纹识别
+│   ├── meal_recommender.py         # 菜品推荐
+│   ├── diet_logger.py              # 饮食记录 + Markdown 生成
+│   └── nutrition_analyzer.py       # 营养分析 + 可视化
+│
+├── ui/                             # 表现层
+│   ├── __init__.py
+│   └── app_builder.py              # Gradio 界面 + 事件绑定
+│
+├── data/                           # 数据存储
+│   ├── nutrition/
+│   │   └── raw/                    # ← 你已下载的三个 MD 文件
+│   │       ├── 妊娠期妇女体重增长推荐值标准.md
+│   │       ├── 中国孕期妇女膳食指南2022图片转md版.md
+│   │       └── 备孕&孕早中晚三期和哺乳期的所有膳食营养素参考摄入量.md
+│   ├── presets/          ← 🆕 新增  # 每日简报 / 预设文件
+│   ├── voices/                     # 声纹数据
+│   ├── logs/                       # Markdown 饮食日志
+│   └── reports/                    # 导出报告
+│
+├── docs/
+│   ├── 项目理解_技术架构.md         # ← 本文档
+│   └── 开发日志.md
+│
+├── requirements.txt                # 依赖清单
+└── README.md
+```
+
+> **批注：** ________
+
+---
+
+## 六、数据流全景
+
+```
+                data/nutrition/raw/
+                ├── 体重标准.md ─────────────┐
+                ├── 膳食指南.md ─────────────┤
+                └── DRIs.md ─────────────────┤
+                                            │
+                    ┌───────────────────────▼──────────────────────┐
+                    │               data/presets/                    │
+                    │               (缓存编译后的结构化数据)          │
+                    │  体重标准.json   膳食指南.json   DRIs.json     │
+                    └──────────────┬────────────────────────────────┘
+                                  │
+                                  ▼
+            ┌──────────────────────────────────────────────────────┐
+            │                   loop.py                             │
+            │  ┌────────────────────────────────────────────────┐   │
+            │  │  状态机驱动 (LAUNCH→SUMMARIZE→ANALYZE→BRIEF)   │   │
+            │  │              ↓ 依次调用 Plugin                  │   │
+            │  │  diet_summary → weight_check → dri_analysis    │   │
+            │  │                    ↓                           │   │
+            │  │           briefing_generator                   │   │
+            │  │                    ↓                           │   │
+            │  │          data/presets/今日简报.json            │   │
+            │  └────────────────────────────────────────────────┘   │
+            └──────────────────────┬───────────────────────────────┘
+                                  │
+                                  ▼
+            ┌──────────────────────────────────────────────────────┐
+            │  ui/app_builder.py (Gradio 界面)                      │
+            │  ┌────────────────────────────────────────────────┐   │
+            │  │  Tab1 声纹识别 │ Tab2 菜品推荐 │ Tab3 饮食记录 │   │
+            │  │  Tab4 营养报告 │ Tab5 关于                      │   │
+            │  │                                                   │   │
+            │  │  今日简报注入对话上下文                             │   │
+            │  │  AI 知道：今天该关注什么营养素                      │   │
+            │  │  该问谁体重？该聊什么话题？                         │   │
+            │  └────────────────────────────────────────────────┘   │
+            └──────────────────────┬───────────────────────────────┘
+                                  │
+                                  ▼
+                    modules/diet_logger.py (记录新数据)
+                    modules/meal_recommender.py (膳食指南约束)
+                    modules/nutrition_analyzer.py (DRIs 对比)
+                                  │
+                                  ▼
+                    次日 loop.py 再次启动 → 循环
+```
+
+> **批注：** ________
+
+---
+
+## 七、技术栈一览
+
+| 层级 | 技术 | 用途 |
+|------|------|------|
+| 核心模型 | **MiniCPM-o 4.5**（统一多模态模型） | 全双工推理：视觉+语音+文本+语音输出 |
+| 前端框架 | **Gradio 6.x** | Web 界面，实时对话交互 |
+| 声纹识别 | Whisper-medium encoder embedding（优先）| 说话人身份识别 |
+| 频谱方案 | NumPy + SoundFile（备选 fallback） | 声纹识别兜底 |
+| 数据存储 | JSON + Markdown | 饮食记录 + 报告存档 + 每日简报 |
+| 营养标准 | 三个 MD 文件（已下载） | 体重标准/膳食指南/DRIs |
+| 循环引擎 | 自研状态机 + 插件注册 | 每日生命周期管理 |
+| 部署平台 | HuggingFace Spaces（目前）+ Modal（后续） | 云端部署 |
+
+> **批注：** ________
+
+---
+
+## 八、待讨论问题清单
+
+> 📝 下表汇总了本文档中需要你决策的问题。请在 `____` 处标注你的意见（如需更多讨论，在对应小节批注区补充）。
+
+| # | 问题 | 你的选择 / 意见 |
+|---|------|----------------|
+| 1 | **Loop 启动时机**：Gradio 启动时先跑完 Loop 总结阶段再开服务（A）/ 用户打开页面时才触发（B） | ________ |
+| 2 | **简报承载形式**：JSON 文件落盘作为中介（A）/ 仅内存变量不落盘（B） | ________ |
+| 3 | **Loop 复杂度边界**：只需管好每日生命周期 3~5 个阶段，约 200~300 行（同意）/ 需要更复杂（请说明） | ________ |
+| 4 | **插件优先级**：DietSummary P0 / WeightCheck P0 / DRIAnalysis P0 / BriefingGenerator P0 / PresetWriter P1（需要调整？） | ________ |
+| 5 | **体重数据来源**：用户手动输入（A）/ 语音对话 AI 询问记录（B）/ 蓝牙同步未来扩展（C） | ________ |
+| 6 | **core/ 层处理**：现阶段 Loop 直接调用 modules/ 规则引擎，core/ 保持空接口等 MiniCPM-o（同意？） | ________ |
+| 7 | **还有什么我没考虑到的问题？** | ________ |
+
+---
+
+*文档生成时间：2026-06-08 | v4 - 引入 Loop 驱动架构 + 三文档操作方案*
diff --git a/data/diet_logs.json b/data/diet_logs.json
new file mode 100644
index 0000000000000000000000000000000000000000..ff18a367700e6700071470d27cee3c67e04e629a
--- /dev/null
+++ b/data/diet_logs.json
@@ -0,0 +1,53 @@
+{
+  "schema_version": "1.0",
+  "records": [
+    {
+      "id": "rec001",
+      "member_name": "小红",
+      "member_relation": "孕妇",
+      "date": "2026-06-07",
+      "meals": {
+        "早餐": "全麦面包+鸡蛋+牛奶",
+        "午餐": "番茄牛腩+米饭",
+        "晚餐": "鲫鱼豆腐汤+小馒头",
+        "加餐": "苹果+酸奶"
+      },
+      "mood": "心情不错",
+      "notes": "今天胃口很好",
+      "extensions": {},
+      "created_at": "2026-06-07T20:00:00"
+    },
+    {
+      "id": "rec002",
+      "member_name": "小红",
+      "member_relation": "孕妇",
+      "date": "2026-06-08",
+      "meals": {
+        "早餐": "小米粥+包子",
+        "午餐": "清炒西兰花+糙米饭",
+        "晚餐": "番茄炒蛋+米饭",
+        "加餐": "坚果+橙子"
+      },
+      "mood": "有点孕吐",
+      "notes": "晚上有点不舒服",
+      "extensions": {},
+      "created_at": "2026-06-08T20:00:00"
+    },
+    {
+      "id": "rec003",
+      "member_name": "小红",
+      "member_relation": "孕妇",
+      "date": "2026-06-09",
+      "meals": {
+        "早餐": "燕麦粥+鸡蛋",
+        "午餐": "清蒸鲈鱼+杂粮饭",
+        "晚餐": "红枣枸杞鸡汤",
+        "加餐": "猕猴桃+牛奶"
+      },
+      "mood": "挺好",
+      "notes": "想吃酸的",
+      "extensions": {},
+      "created_at": "2026-06-09T12:00:00"
+    }
+  ]
+}
diff --git a/data/family/memory.md b/data/family/memory.md
new file mode 100644
index 0000000000000000000000000000000000000000..dfb1c8235e1f23adb73135670524e2d0a0bbaef7
--- /dev/null
+++ b/data/family/memory.md
@@ -0,0 +1,21 @@
+# 家庭记忆
+
+> 记录家庭关系、重要事件、日常点滴。
+
+## 家庭关系
+
+- **小红**: 孕妇，孕中期
+- **小明**: 丈夫，负责做饭
+- **张阿姨**: 婆婆，帮忙照顾
+
+## 重要事件
+
+- **2026-06-07**: 丈夫做了番茄牛腩，孕妇说很好吃
+- **2026-06-08**: 婆婆煲了鲫鱼豆腐汤，孕妇喝了两碗
+- **2026-06-09**: 孕妇说想吃清蒸鲈鱼
+
+## 日常记录
+
+- **2026-06-07**: 孕妇今天心情不错，吃了很多水果
+- **2026-06-08**: 孕妇有点孕吐，但坚持吃了晚饭
+- **2026-06-09**: 孕妇说最近想吃酸的
diff --git a/data/family/preferences.md b/data/family/preferences.md
new file mode 100644
index 0000000000000000000000000000000000000000..1f21a8ff9ec8b347b66415393c6290e8d70baa42
--- /dev/null
+++ b/data/family/preferences.md
@@ -0,0 +1,23 @@
+# 家庭成员饮食偏好
+
+> 记录所有家人的饮食偏好、忌口、过敏信息。
+
+## 成员列表
+
+### 成员：小红（孕妇）
+- **偏好**: 爱吃水果、爱吃鱼、爱吃清淡
+- **忌口**: 不吃辣、不吃油腻
+- **过敏**: 芒果
+- **备注**: 孕中期，需要补钙
+
+### 成员：小明（丈夫）
+- **偏好**: 爱吃肉、爱吃面食
+- **忌口**: 不吃香菜
+- **过敏**: 
+- **备注**: 
+
+### 成员：张阿姨（婆婆）
+- **偏好**: 会做各种汤
+- **忌口**: 
+- **过敏**: 
+- **备注**: 擅长煲汤
diff --git a/data/family/recipes.md b/data/family/recipes.md
new file mode 100644
index 0000000000000000000000000000000000000000..da143b676e5560df178acd5b64480e13289d3e41
--- /dev/null
+++ b/data/family/recipes.md
@@ -0,0 +1,35 @@
+# 家庭菜谱
+
+> 记录家人会做的菜。
+
+## 菜谱列表
+
+### 番茄牛腩
+- **制作人**: 丈夫
+- **难度**: 中等
+- **食材**: 番茄, 牛腩, 土豆, 胡萝卜
+- **备注**: 孕妇爱吃
+
+### 清蒸鲈鱼
+- **制作人**: 丈夫
+- **难度**: 简单
+- **食材**: 鲈鱼, 葱, 姜, 蒸鱼豉油
+- **备注**: 清淡健康
+
+### 鲫鱼豆腐汤
+- **制作人**: 婆婆
+- **难度**: 简单
+- **食材**: 鲫鱼, 豆腐, 姜, 葱
+- **备注**: 下奶
+
+### 番茄炒蛋
+- **制作人**: 丈夫
+- **难度**: 简单
+- **食材**: 番茄, 鸡蛋, 葱
+- **备注**: 
+
+### 红枣枸杞鸡汤
+- **制作人**: 妈妈
+- **难度**: 中等
+- **食材**: 鸡, 红枣, 枸杞, 姜
+- **备注**: 补气血
diff --git "a/data/nutrition/raw/\344\270\255\345\233\275\345\255\225\346\234\237\345\246\207\345\245\263\350\206\263\351\243\237\346\214\207\345\215\2272022\345\233\276\347\211\207\350\275\254md\347\211\210.md" "b/data/nutrition/raw/\344\270\255\345\233\275\345\255\225\346\234\237\345\246\207\345\245\263\350\206\263\351\243\237\346\214\207\345\215\2272022\345\233\276\347\211\207\350\275\254md\347\211\210.md"
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..6b3646b336155970fd04457e96833086b2ced2fa 100644
--- "a/data/nutrition/raw/\344\270\255\345\233\275\345\255\225\346\234\237\345\246\207\345\245\263\350\206\263\351\243\237\346\214\207\345\215\2272022\345\233\276\347\211\207\350\275\254md\347\211\210.md"
+++ "b/data/nutrition/raw/\344\270\255\345\233\275\345\255\225\346\234\237\345\246\207\345\245\263\350\206\263\351\243\237\346\214\207\345\215\2272022\345\233\276\347\211\207\350\275\254md\347\211\210.md"
@@ -0,0 +1,124 @@
+# 中国备孕妇女平衡膳食宝塔
+
+## 备孕核心建议
+- 叶酸补充剂0.4毫克/天
+- 贫血者在医生指导下补充铁剂
+- 每天30分钟以上中等强度运动
+- 监测体重，调整体重至适宜范围
+- 愉悦心情，充足睡眠
+- 饮洁净水，少喝含糖饮料
+- 不吸烟，远离二手烟
+- 不饮酒
+
+---
+
+## 食物推荐量
+1.  **加碘食盐**：5克
+2.  **油**：25克
+3.  **奶类**：300克
+4.  **大豆/坚果**：15克 / 10克
+5.  **肉食蛋鱼类**：130-180克
+    - 畜禽肉：40-65克
+    - 鱼虾类：40-65克
+    - 蛋类：50克（每天一次，约1个鸡蛋）
+6.  **蔬菜类**：300-500克（可每天至少一次深绿色蔬菜）
+7.  **水果类**：200-300克
+8.  **谷类**：200-250克
+    - ——全谷物和杂豆：75-130克
+9.  **薯类**：50克
+10. **水**：1500-1700毫升
+
+
+---
+
+
+# 中国孕期妇女平衡膳食宝塔
+
+## 左侧通用建议
+- 叶酸补充剂0.4毫克/天
+- 贫血严重者在医生指导下补充铁剂
+- 适度运动，经常户外活动
+- 每周测量体重，维持孕期适宜增重
+- 愉悦心情，充足睡眠
+- 饮洁净水，少喝含糖饮料
+- 准备母乳喂养
+- 不吸烟，远离二手烟
+- 不饮酒
+
+---
+
+## 右侧食物推荐量
+| 食物类别 | 孕中期 | 孕晚期 |
+| :--- | :--- | :--- |
+| 加碘食盐 | 5克 | 5克 |
+| 油 | 25克 | 25克 |
+| 奶类 | 300-500克 | 300-500克 |
+| 大豆/坚果 | 20克/10克 | 20克/10克 |
+| 鱼禽蛋肉类 | 150-200克 | 175-225克 |
+| - 畜禽肉类 | 50-75克 | 50-75克 |
+| - 鱼虾类 | 50-75克（每周2-3次，其中1次为深海鱼） | 75-100克 |
+| - 蛋类 | 50克 | 50克 |
+| 蔬菜类 | 400-500克（每天至少一次深绿色蔬菜） | 400-500克 |
+| 水果类 | 200-300克 | 200-350克 |
+| 谷类 | 200-250克 | 225-275克 |
+| - 全谷物和杂豆 | 75-100克 | 75-125克 |
+| 薯类 | 75克 | 75克 |
+| 水 | 1700毫升 | 1700毫升 |
+
+
+1.  **调整孕前体重至正常范围，保证孕期体重适宜增长**
+2.  **常吃含铁丰富的食物，选用碘盐，合理补充叶酸和维生素D**
+3.  **孕吐严重者，可少量多餐，保证摄入含必需量碳水化合物的食物**
+4.  **孕中晚期适量增加奶、鱼、禽、蛋、瘦肉的摄入**
+5.  **经常户外活动，禁烟酒，保持健康生活方式**
+6.  **愉快孕育新生命，积极准备母乳喂养**
+
+---
+
+
+
+# 中国哺乳期妇女平衡膳食宝塔
+
+---
+
+## 左侧生活建议
+- 坚持哺乳
+- 适当增加鱼禽肉蛋和海产品
+- 愉悦心情，充足睡眠
+- 足量饮水，适当多喝粥、汤
+- 适度运动
+- 每周测量体重，逐步恢复适宜体重
+- 不吸烟，远离二手烟
+- 不饮酒
+
+---
+
+## 右侧食物推荐量
+| 食物类别 | 每日推荐摄入量 | 补充说明 |
+| :--- | :--- | :--- |
+| 加碘食盐 | 5克 | - |
+| 油 | 25克 | - |
+| 奶类 | 300-500克 | - |
+| 大豆/坚果 | 25克/10克 | - |
+| 鱼禽蛋肉类 | 175-225克 | - |
+| - 畜禽肉类 | 50-75克 | - |
+| - 鱼虾类 | 75-100克 | 每周1-2次食物中包含50g以上的鱼类或贝类 |
+| - 蛋类 | 50克 | - |
+| 蔬菜类 | 400-500克 | 每天至少一次深绿色蔬菜 |
+| 水果类 | 200-350克 | - |
+| 谷类 | 225-275克 | - |
+| - 全谷物和杂豆 | 75-125克 | - |
+| 薯类 | 75克 | - |
+| 水 | 2100毫升 | - |
+
+- 注：月子膳食亦适用
+
+
+1.  **产褥期食物多样不过量，坚持整个哺乳期营养均衡**
+2.  **适量增加富含优质蛋白质及维生素A的动物性食物和海产品，选用碘盐，合理补充维生素D**
+3.  **家庭支持，愉悦心情，充足睡眠，坚持母乳喂养**
+4.  **增加身体活动，促进产后恢复健康体重**
+5.  **多喝汤和水，限制浓茶和咖啡，忌烟酒**
+
+---
+
diff --git "a/data/nutrition/raw/\345\244\207\345\255\225&\345\255\225\346\227\251\344\270\255\346\231\232\344\270\211\346\234\237\345\222\214\345\223\272\344\271\263\346\234\237\347\232\204\346\211\200\346\234\211\350\206\263\351\243\237\350\220\245\345\205\273\347\264\240\345\217\202\350\200\203\346\221\204\345\205\245\351\207\217.md" "b/data/nutrition/raw/\345\244\207\345\255\225&\345\255\225\346\227\251\344\270\255\346\231\232\344\270\211\346\234\237\345\222\214\345\223\272\344\271\263\346\234\237\347\232\204\346\211\200\346\234\211\350\206\263\351\243\237\350\220\245\345\205\273\347\264\240\345\217\202\350\200\203\346\221\204\345\205\245\351\207\217.md"
new file mode 100644
index 0000000000000000000000000000000000000000..08fe34541c8f2cafc2ab65c90d9b86438723af46
--- /dev/null
+++ "b/data/nutrition/raw/\345\244\207\345\255\225&\345\255\225\346\227\251\344\270\255\346\231\232\344\270\211\346\234\237\345\222\214\345\223\272\344\271\263\346\234\237\347\232\204\346\211\200\346\234\211\350\206\263\351\243\237\350\220\245\345\205\273\347\264\240\345\217\202\350\200\203\346\221\204\345\205\245\351\207\217.md"
@@ -0,0 +1,291 @@
+下面将**四张表格全部拆分为「能量与宏量营养素、矿物质、维生素」三张独立标准 Markdown 表**，语法通用、无超宽合并列，主流编辑器/文档工具均可正常渲染，可直接全选复制使用。
+
+# 表15 中国18-49岁孕期女性（孕早期）膳食营养素参考摄入量
+### 缩略词说明
+- EAR：平均需要量
+- RNI：推荐摄入量
+- AI：适宜摄入量
+- PI：预防非传染性慢性病建议摄入量
+- UL：可耐受最高摄入量
+- AMDR：宏量营养素可接受范围
+- PAL：身体活动水平
+
+### 一、能量与宏量营养素
+| 能量/营养素 | 单位 | EAR | RNI | AMDR | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 能量 PAL(I) | MJ/d | - | 7.11 | - | - | - |
+| 能量 PAL(II) | MJ/d | - | 8.79 | - | - | - |
+| 能量 PAL(III) | MJ/d | - | 10.25 | - | - | - |
+| 蛋白质 | g/d | 55 | - | 10~20% | - | - |
+| 总碳水化合物 | %E | 130# | - | 50~65% | - | - |
+| — 添加糖 | %E | - | - | <10 | - | - |
+| 膳食纤维 | g/d | - | - | 25~30(AI) | - | - |
+| 总脂肪 | %E | - | - | 20~30 | - | - |
+| — 饱和脂肪酸 | %E | - | - | <10 | - | - |
+| — n-6多不饱和脂肪酸 | %E | - | - | 2.5~9 | - | - |
+| — 亚油酸 | %E | - | - | 4.0(AI) | - | - |
+| — n-3多不饱和脂肪酸 | %E | - | - | 0.5~2.0 | - | - |
+| — α-亚麻酸 | %E | - | - | 0.60(AI) | - | - |
+| — DHA | %E | - | - | 0.25(0.2%E)(AI) | - | - |
+| 水 | mL/d | - | 1500/2700 | - | - | - |
+
+### 二、矿物质
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 钙 | mg/d | 650 | 800 | - | 2000 |
+| 磷 | mg/d | 600 | 720 | - | 3500 |
+| 钾 | mg/d | - | 2000(AI) | 3600 | - |
+| 钠 | mg/d | - | 1500(AI) | ≤2000 | - |
+| 镁 | mg/d | 300 | 370 | - | - |
+| 氯 | mg/d | - | 2300(AI) | - | - |
+| 铁 | mg/d | 12 | 18 | - | 42 |
+| 碘 | μg/d | 120 | 230 | - | 500 |
+| 锌 | mg/d | 8.6 | 10.5 | - | 40 |
+| 硒 | μg/d | 54 | 65 | - | 400 |
+| 铜 | mg/d | 0.72 | 0.91 | - | 8.0 |
+| 氟 | mg/d | - | 1.5(AI) | - | 3.5 |
+| 铬 | μg/d | - | 30(AI) | - | - |
+| 锰 | mg/d | - | 4.0(AI) | - | 11 |
+| 钼 | μg/d | 20 | 25 | - | 900 |
+
+### 三、维生素
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 维生素A | μgRAE/d | 470 | 660 | - | 3000 |
+| 维生素D | μg/d | 8 | 10 | - | 50 |
+| 维生素E | mgα-TE/d | - | 14(AI) | - | 700 |
+| 维生素K | μg/d | - | 80(AI) | - | - |
+| 维生素B₁ | mg/d | 1.0 | 1.2 | - | - |
+| 维生素B₂ | mg/d | 1.0 | 1.2 | - | - |
+| 烟酸 | mg NE/d | 10 | 12 | - | 35/310# |
+| 维生素B₆ | mg/d | 1.9 | 2.2 | - | 60 |
+| 叶酸 | μg DFE/d | 520 | 600 | - | 1000# |
+| 维生素B₁₂ | μg/d | 2.4 | 2.9 | - | - |
+| 泛酸 | mg/d | - | 6.0(AI) | - | - |
+| 生物素 | μg/d | - | 50(AI) | - | - |
+| 胆碱 | mg/d | - | 460(AI) | - | 3000 |
+| 维生素C | mg/d | 85 | 100 | 200 | 2000 |
+
+### 备注
+- PAL：身体活动水平（I：低强度；II：中等强度；III：高强度）
+- 未制定参考值用“—”表示；#标注项为特殊限定数值
+- 水总摄入量包含饮用水及食物中的水分
+
+---
+
+# 表16 中国18-49岁孕期女性（孕中期）膳食营养素参考摄入量
+### 缩略词说明
+- EAR：平均需要量
+- RNI：推荐摄入量
+- AI：适宜摄入量
+- PI：预防非传染性慢性病建议摄入量
+- UL：可耐受最高摄入量
+- AMDR：宏量营养素可接受范围
+- PAL：身体活动水平
+
+### 一、能量与宏量营养素
+| 能量/营养素 | 单位 | EAR | RNI | AMDR | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 能量 PAL(I) | MJ/d | - | 8.16 | - | - | - |
+| 能量 PAL(II) | MJ/d | - | 9.84 | - | - | - |
+| 能量 PAL(III) | MJ/d | - | 11.30 | - | - | - |
+| 蛋白质 | g/d | 60 | 70 | 10~20% | - | - |
+| 总碳水化合物 | %E | 140 | - | 50~65% | - | - |
+| — 添加糖 | %E | - | - | <10 | - | - |
+| 膳食纤维 | g/d | - | - | 29~34(AI) | - | - |
+| 总脂肪 | %E | - | - | 20~30 | - | - |
+| — 饱和脂肪酸 | %E | - | - | <10 | - | - |
+| — n-6多不饱和脂肪酸 | %E | - | - | 2.5~9 | - | - |
+| — 亚油酸 | %E | - | - | 4.0(AI) | - | - |
+| — n-3多不饱和脂肪酸 | %E | - | - | 0.5~2.0 | - | - |
+| — α-亚麻酸 | %E | - | - | 0.60(AI) | - | - |
+| — DHA+EPA | g/d | - | - | 0.25(0.2%E)(AI) | - | - |
+| 水 | mL/d | - | 1700/3000 | - | - | - |
+
+### 二、矿物质
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 钙 | mg/d | 650 | 800 | - | 2000 |
+| 磷 | mg/d | 600 | 720 | - | 3500 |
+| 钾 | mg/d | - | 2000(AI) | 3600 | - |
+| 钠 | mg/d | - | 1500(AI) | ≤2000 | - |
+| 镁 | mg/d | 300 | 370 | - | - |
+| 氯 | mg/d | - | 2300(AI) | - | - |
+| 铁 | mg/d | 19 | 25 | - | 42 |
+| 碘 | μg/d | 160 | 230 | - | 500 |
+| 锌 | mg/d | 8.6 | 10.5 | - | 40 |
+| 硒 | μg/d | 54 | 65 | - | 400 |
+| 铜 | mg/d | 0.72 | 0.9 | - | 8.0 |
+| 氟 | mg/d | - | 1.5(AI) | - | 3.5 |
+| 铬 | μg/d | - | 33(AI) | - | - |
+| 锰 | mg/d | - | 4.0(AI) | - | 11 |
+| 钼 | μg/d | 20 | 25 | - | 900 |
+
+### 三、维生素
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 维生素A | μgRAE/d | 520 | 730 | - | 3000 |
+| 维生素D | μg/d | 8 | 10 | - | 50 |
+| 维生素E | mgα-TE/d | - | 14(AI) | - | 700 |
+| 维生素K | μg/d | - | 80(AI) | - | - |
+| 维生素B₁ | mg/d | 1.1 | 1.4 | - | - |
+| 维生素B₂ | mg/d | 1.1 | 1.3 | - | - |
+| 烟酸 | mg NE/d | 10 | 12 | - | 35/310# |
+| 维生素B₆ | mg/d | 1.7 | 2.2 | - | 60 |
+| 叶酸 | μg DFE/d | 520 | 600 | - | 1000# |
+| 维生素B₁₂ | μg/d | 2.4 | 2.9 | - | - |
+| 泛酸 | mg/d | - | 6.0(AI) | - | - |
+| 生物素 | μg/d | - | 50(AI) | - | - |
+| 胆碱 | mg/d | - | 460(AI) | - | 3000 |
+| 维生素C | mg/d | 95 | 115 | 200 | 2000 |
+
+### 备注
+- PAL：身体活动水平（I：低强度；II：中等强度；III：高强度）
+- 未制定参考值用“—”表示；#标注项为特殊限定数值
+- 水总摄入量包含饮用水及食物中的水分
+
+---
+
+# 表17 中国18-49岁孕期女性（孕晚期）膳食营养素参考摄入量
+### 缩略词说明
+- EAR：平均需要量
+- RNI：推荐摄入量
+- AI：适宜摄入量
+- PI：预防非传染性慢性病建议摄入量
+- UL：可耐受最高摄入量
+- AMDR：宏量营养素可接受范围
+- PAL：身体活动水平
+
+### 一、能量与宏量营养素
+| 能量/营养素 | 单位 | EAR | RNI | AMDR | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 能量 PAL(I) | MJ/d | - | 8.78 | - | - | - |
+| 能量 PAL(II) | MJ/d | - | 10.46 | - | - | - |
+| 能量 PAL(III) | MJ/d | - | 11.92 | - | - | - |
+| 蛋白质 | g/d | 75 | 85 | 10~20% | - | - |
+| 总碳水化合物 | %E | 155 | - | 50~65% | - | - |
+| — 添加糖 | %E | - | - | <10 | - | - |
+| 膳食纤维 | g/d | - | - | 29~34(AI) | - | - |
+| 总脂肪 | %E | - | - | 20~30 | - | - |
+| — 饱和脂肪酸 | %E | - | - | <10 | - | - |
+| — n-6多不饱和脂肪酸 | %E | - | - | 2.5~9 | - | - |
+| — 亚油酸 | %E | - | - | 4.0(AI) | - | - |
+| — n-3多不饱和脂肪酸 | %E | - | - | 0.5~2.0 | - | - |
+| — α-亚麻酸 | %E | - | - | 0.60(AI) | - | - |
+| — DHA+EPA | g/d | - | - | 0.25(0.2%E)(AI) | - | - |
+| 水 | mL/d | - | 1700/3000 | - | - | - |
+
+### 二、矿物质
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 钙 | mg/d | 650 | 800 | - | 2000 |
+| 磷 | mg/d | 600 | 720 | - | 3500 |
+| 钾 | mg/d | - | 2000(AI) | 3600 | - |
+| 钠 | mg/d | - | 1500(AI) | ≤2000 | - |
+| 镁 | mg/d | 300 | 370 | - | - |
+| 氯 | mg/d | - | 2300(AI) | - | - |
+| 铁 | mg/d | 22 | 29 | - | 42 |
+| 碘 | μg/d | 160 | 230 | - | 500 |
+| 锌 | mg/d | 8.6 | 10.5 | - | 40 |
+| 硒 | μg/d | 54 | 65 | - | 400 |
+| 铜 | mg/d | 0.72 | 0.9 | - | 8.0 |
+| 氟 | mg/d | - | 1.5(AI) | - | 3.5 |
+| 铬 | μg/d | - | 35(AI) | - | - |
+| 锰 | mg/d | - | 4.0(AI) | - | 11 |
+| 钼 | μg/d | 20 | 25 | - | 900 |
+
+### 三、维生素
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 维生素A | μgRAE/d | 520 | 730 | - | 3000 |
+| 维生素D | μg/d | 8 | 10 | - | 50 |
+| 维生素E | mgα-TE/d | - | 14(AI) | - | 700 |
+| 维生素K | μg/d | - | 80(AI) | - | - |
+| 维生素B₁ | mg/d | 1.2 | 1.4 | - | - |
+| 维生素B₂ | mg/d | 1.2 | 1.5 | - | - |
+| 烟酸 | mg NE/d | 10 | 12 | - | 35/310# |
+| 维生素B₆ | mg/d | 1.9 | 2.2 | - | 60 |
+| 叶酸 | μg DFE/d | 520 | 600 | - | 1000# |
+| 维生素B₁₂ | μg/d | 2.4 | 2.9 | - | - |
+| 泛酸 | mg/d | - | 6.0(AI) | - | - |
+| 生物素 | μg/d | - | 50(AI) | - | - |
+| 胆碱 | mg/d | - | 460(AI) | - | 3000 |
+| 维生素C | mg/d | 95 | 115 | 200 | 2000 |
+
+### 备注
+- PAL：身体活动水平（I：低强度；II：中等强度；III：高强度）
+- 未制定参考值用“—”表示；#标注项为特殊限定数值
+- 水总摄入量包含饮用水及食物中的水分
+
+---
+
+# 表18 中国18-49岁哺乳期女性膳食营养素参考摄入量
+### 缩略词说明
+- EAR：平均需要量
+- RNI：推荐摄入量
+- AI：适宜摄入量
+- PI：预防非传染性慢性病建议摄入量
+- UL：可耐受最高摄入量
+- AMDR：宏量营养素可接受范围
+- PAL：身体活动水平
+
+### 一、能量与宏量营养素
+| 能量/营养素 | 单位 | EAR | RNI | AMDR | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 能量 PAL(I) | MJ/d | - | 8.78 | - | - | - |
+| 能量 PAL(II) | MJ/d | - | 10.46 | - | - | - |
+| 能量 PAL(III) | MJ/d | - | 11.92 | - | - | - |
+| 蛋白质 | g/d | 70 | 80 | 10~20% | - | - |
+| 总碳水化合物 | %E | 170 | - | 50~65% | - | - |
+| — 添加糖 | %E | - | - | <10 | - | - |
+| 膳食纤维 | g/d | - | - | 29~34(AI) | - | - |
+| 总脂肪 | %E | - | - | 20~30 | - | - |
+| — 饱和脂肪酸 | %E | - | - | <10 | - | - |
+| — n-6多不饱和脂肪酸 | %E | - | - | 2.5~9 | - | - |
+| — 亚油酸 | %E | - | - | 4.0(AI) | - | - |
+| — n-3多不饱和脂肪酸 | %E | - | - | 0.5~2.0 | - | - |
+| — α-亚麻酸 | %E | - | - | 0.60(AI) | - | - |
+| — DHA+EPA | g/d | - | - | 250(200)(AI) | - | - |
+| 水 | mL/d | - | 2100/3800 | - | - | - |
+
+### 二、矿物质
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 钙 | mg/d | 650 | 800 | - | 2000 |
+| 磷 | mg/d | 600 | 720 | - | 3500 |
+| 钾 | mg/d | - | 2400(AI) | 3600 | - |
+| 钠 | mg/d | - | 1500(AI) | ≤2000 | - |
+| 镁 | mg/d | 270 | 330 | - | - |
+| 氯 | mg/d | - | 2300(AI) | - | - |
+| 铁 | mg/d | 18 | 24 | - | 42 |
+| 碘 | μg/d | 170 | 240 | - | 500 |
+| 锌 | mg/d | 11 | 13.0 | - | 40 |
+| 硒 | μg/d | 65 | 78 | - | 400 |
+| 铜 | mg/d | 1.12 | 1.5 | - | 8.0 |
+| 氟 | mg/d | - | 1.5(AI) | - | 3.5 |
+| 铬 | μg/d | - | 35(AI) | - | - |
+| 锰 | mg/d | - | 4.2(AI) | - | 11 |
+| 钼 | μg/d | 24 | 30 | - | 900 |
+
+### 三、维生素
+| 营养素 | 单位 | EAR | RNI | PI | UL |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+| 维生素A | μgRAE/d | 870 | 1260 | - | 3000 |
+| 维生素D | μg/d | 8 | 10 | - | 50 |
+| 维生素E | mgα-TE/d | - | 14(AI) | - | 700 |
+| 维生素K | μg/d | - | 85(AI) | - | - |
+| 维生素B₁ | mg/d | 1.2 | 1.5 | - | - |
+| 维生素B₂ | mg/d | 1.4 | 1.7 | - | - |
+| 烟酸 | mg NE/d | 13 | 16 | - | 35/310# |
+| 维生素B₆ | mg/d | 1.4 | 1.7 | - | 60 |
+| 叶酸 | μg DFE/d | 450 | 550 | - | 1000# |
+| 维生素B₁₂ | μg/d | 2.6 | 3.2 | - | - |
+| 泛酸 | mg/d | - | 7.0(AI) | - | - |
+| 生物素 | μg/d | - | 50(AI) | - | - |
+| 胆碱 | mg/d | - | 500(AI) | - | 3000 |
+| 维生素C | mg/d | 125 | 150 | 200 | 2000 |
+
+### 备注
+- PAL：身体活动水平（I：低强度；II：中等强度；III：高强度）
+- 未制定参考值用“—”表示；#标注项为特殊限定数值
+- 水总摄入量包含饮用水及食物中的水分
\ No newline at end of file
diff --git "a/data/nutrition/raw/\345\246\212\345\250\240\346\234\237\345\246\207\345\245\263\344\275\223\351\207\215\345\242\236\351\225\277\346\216\250\350\215\220\345\200\274\346\240\207\345\207\206.md" "b/data/nutrition/raw/\345\246\212\345\250\240\346\234\237\345\246\207\345\245\263\344\275\223\351\207\215\345\242\236\351\225\277\346\216\250\350\215\220\345\200\274\346\240\207\345\207\206.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6eb581a767eaa49e429366a5eb43ab5885cd2842
--- /dev/null
+++ "b/data/nutrition/raw/\345\246\212\345\250\240\346\234\237\345\246\207\345\245\263\344\275\223\351\207\215\345\242\236\351\225\277\346\216\250\350\215\220\345\200\274\346\240\207\345\207\206.md"
@@ -0,0 +1,92 @@
+# WS/T 801-2022 妊娠期妇女体重增长推荐值标准
+*Standard of recommendation for weight gain during pregnancy period*
+
+---
+
+## 1 范围
+本标准规定了我国妇女单胎自然妊娠体重增长推荐值。
+本标准适用于对我国妇女单胎自然妊娠体重增长的指导。
+本标准不适用于身高低于140cm，或妊娠前体重高于125kg的妇女。妊娠期合并症和并发症患者应结合临床意见进行个体化评价。
+
+## 2 规范性引用文件
+本标准没有规范性引用文件。
+
+## 3 术语和定义
+下列术语和定义适用于本标准。
+
+### 3.1 妊娠期 pregnancy period
+从末次月经的第一日开始计算，约为280日（40周）。
+注：临床上将妊娠全程分为妊娠早期、妊娠中期、妊娠晚期3个时期。
+
+### 3.2 妊娠早期 first trimester
+妊娠未达14周。
+
+### 3.3 妊娠中期 second trimester
+妊娠第14周～27+6周。
+
+### 3.4 妊娠晚期 third trimester
+妊娠第28周及其后。
+
+### 3.5 体质指数 body mass index; BMI
+一种计算身高别体重的指数，计算方法是体重(kg)与身高(m)的平方的比值。
+
+### 3.6 妊娠前体重 pre-pregnancy weight
+妊娠之前三个月内的平均体重。
+
+### 3.7 分娩前体重 pre-delivery weight
+分娩前一周内最后一次称量的体重。
+
+### 3.8 妊娠期体重总增长值 gestational weight gain; GWG
+分娩前体重(kg)减去妊娠前体重(kg)所得数值。
+
+### 3.9 妊娠早期体重增长值 gestational weight gain in first trimester
+妊娠13周末体重(kg)减去妊娠前体重(kg)所得数值。
+
+### 3.10 妊娠中期体重增长值 gestational weight gain in second trimester
+妊娠27周末体重(kg)减去妊娠13周末体重(kg)所得数值。
+
+### 3.11 妊娠晚期体重增长值 gestational weight gain in third trimester
+分娩前体重(kg)减去妊娠27周末体重(kg)所得数值。
+
+## 4 妊娠期妇女体重增长范围及妊娠中期和妊娠晚期每周体重增长推荐值
+按中国成人体质指数切点，分别给予在不同妊娠前体质指数情况下，单胎妊娠妇女体重增长范围及妊娠中期和妊娠晚期每周体重增长推荐值，见表1。
+
+**表1 妊娠期妇女体重增长范围及妊娠中期和妊娠晚期每周体重增长推荐值**
+| 妊娠前体质指数分类 | 总增长值范围(kg) | 妊娠早期增长值范围(kg) | 妊娠中期和妊娠晚期每周体重增长值及范围(kg/week) |
+| ---- | ---- | ---- | ---- |
+| 低体重（BMI ＜ 18.5 kg/m²） | 11.0 ~ 16.0 | 0 ~ 2.0 | 0.46（0.37 ~ 0.56） |
+| 正常体重（18.5 kg/m² ≤ BMI ＜ 24.0 kg/m²） | 8.0 ~ 14.0 | 0 ~ 2.0 | 0.37（0.26 ~ 0.48） |
+| 超重（24.0 kg/m² ≤ BMI ＜ 28.0 kg/m²） | 7.0 ~ 11.0 | 0 ~ 2.0 | 0.30（0.22 ~ 0.37） |
+| 肥胖（BMI ≥ 28.0 kg/m²） | 5.0 ~ 9.0 | 0 ~ 2.0 | 0.22（0.15 ~ 0.30） |
+
+## 5 测量方法
+妊娠期妇女身高、体重的测量方法参见附录A。
+
+---
+
+## 附录A（资料性）妊娠期妇女身高、体重的测量方法
+### A.1 身高测量
+#### A.1.1 测量条件
+测量时妊娠妇女应免冠、赤足，解开发髻，室温25℃左右。
+
+#### A.1.2 测量工具
+立柱式身高计，分度值0.1cm，有抵墙装置。滑测板应与立柱垂直，滑动自如。
+
+#### A.1.3 测量方法
+妊娠妇女取立正姿势，站在踏板上，挺胸收腹，两臂自然下垂，脚跟靠拢，脚尖分开约60度。双膝并拢挺直，两眼平视正前方，眼眶下缘与耳廓上缘保持在同一水平。脚跟、臀部和两肩胛角间三个点同时接触立柱，头部保持正立位置。测量者手扶滑测板轻轻向下滑动，直到底面与头颅顶点相接触，此时观察妊娠妇女姿势正确后读取数值。
+
+#### A.1.4 读数与记录
+读数时测量者的眼睛与滑测板底面在同一个水平面上，读取滑板底面对应立柱所示数值，以厘米为单位，精确到0.1cm。
+
+### A.2 体重测量
+#### A.2.1 测量条件
+测量应在清晨、空腹、排泄完毕的状态下进行，室温25℃左右。
+
+#### A.2.2 测量工具
+经校准的电子体重秤，分度值 ≤0.1 kg，测量时体重计放置平稳并调零。
+
+#### A.2.3 测量方法
+妊娠妇女平静站立于体重秤踏板中央，两腿均匀负重，免冠、赤足、穿贴身薄内衣裤，注意安全。
+
+#### A.2.4 读数与记录
+准确记录体重秤读数，精确到0.1kg。
\ No newline at end of file
diff --git a/data/presets/.daily_status.json b/data/presets/.daily_status.json
new file mode 100644
index 0000000000000000000000000000000000000000..4b410deccb6bcae41e11ff87c3475aee990ed7b6
--- /dev/null
+++ b/data/presets/.daily_status.json
@@ -0,0 +1,6 @@
+{
+  "2026-06-09": {
+    "summary_done": true,
+    "completed_at": "2026-06-09T00:31:27.292878"
+  }
+}
\ No newline at end of file
diff --git "a/data/presets/\344\273\212\346\227\245\347\256\200\346\212\245_2026-06-10.json" "b/data/presets/\344\273\212\346\227\245\347\256\200\346\212\245_2026-06-10.json"
new file mode 100644
index 0000000000000000000000000000000000000000..1b09f5db41cf8e391337607d386ca2a035a5d0a8
--- /dev/null
+++ "b/data/presets/\344\273\212\346\227\245\347\256\200\346\212\245_2026-06-10.json"
@@ -0,0 +1,15 @@
+{
+  "date": "2026-06-10",
+  "generated_from": "2026-06-09",
+  "generated_at": "2026-06-09T00:31:27.292878",
+  "trimester": "孕中期",
+  "nutrient_focus": [],
+  "recommended_foods": [],
+  "need_ask_weight": false,
+  "need_ask_recipe": false,
+  "conversation_topics": [
+    "今天称体重了吗？"
+  ],
+  "family_memory_summary": "{'relationships': ['- **小红**: 孕妇，孕中期', '- **小明**: 丈夫，负责做饭', '- **张阿姨**: 婆婆，帮忙照顾'], 'recent_events': ['- **2026-06-07**: 丈夫做了番茄牛腩，孕妇说很好吃', '- **2026-06-08**: 婆婆煲了鲫鱼豆腐汤，孕妇喝了两碗', '- **2026-06-09**: 孕妇说想吃清蒸鲈鱼'], 'recent_daily': ['- **2026-06-07**: 孕妇今天心情不错，吃了很多水果', '- **2026-06-08**: 孕妇有点孕吐，但坚持吃了晚饭', '- **2026-06-09**: 孕妇说最近想吃酸的']}",
+  "three_day_summary": {}
+}
\ No newline at end of file
diff --git a/debug2.txt b/debug2.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0a22f0215539f6c3daec77d1457583ac4a0e2638
--- /dev/null
+++ b/debug2.txt
@@ -0,0 +1,3 @@
+add: '[OK] 已添加菜谱: test'
+load: [{'name': 'test', 'cook': 't', 'difficulty': '', 'ingredients': '', 'notes': ''}]
+len: 1
diff --git a/debug4.txt b/debug4.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ed64b2b12140f626880785e89c717133a4e74c3
--- /dev/null
+++ b/debug4.txt
@@ -0,0 +1,2 @@
+result: []
+len: 0
diff --git a/debug_out.txt b/debug_out.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a1e7229c0a59c39db754ff56402dd73318e996c6
--- /dev/null
+++ b/debug_out.txt
@@ -0,0 +1,3 @@
+add: '[WARN] 菜谱已存在: test'
+load: [{'name': '菜名', 'cook': '', 'difficulty': '', 'ingredients': '', 'notes': ''}, {'name': 'test', 'cook': 't', 'difficulty': '', 'ingredients': '', 'notes': ''}]
+len: 2
diff --git "a/docs/\351\241\271\347\233\256\347\220\206\350\247\243_\346\212\200\346\234\257\346\236\266\346\236\204.md" "b/docs/\351\241\271\347\233\256\347\220\206\350\247\243_\346\212\200\346\234\257\346\236\266\346\236\204.md"
index 9d7ff36374cd2917b6d56642cae5a0b564a7256b..022c47918752bb1422b31f36944c2019a02c6adc 100644
--- "a/docs/\351\241\271\347\233\256\347\220\206\350\247\243_\346\212\200\346\234\257\346\236\266\346\236\204.md"
+++ "b/docs/\351\241\271\347\233\256\347\220\206\350\247\243_\346\212\200\346\234\257\346\236\266\346\236\204.md"
@@ -1,300 +1,656 @@
-# 🌸 PregoPal 项目理解与技术架构（v3 - 根据批注修正）
+# 🌸 PregoPal 项目理解与技术架构（v5 - 整合批注，细化实现）
 
-> 本文档用于对齐对项目的整体认知。v3 已整合你所有批注。
+> 本文档已整合你所有批注意见，每个小节保留批注区供继续讨论。
 
 ---
 
 ## 一、一句话定位
 
-**一个基于 MiniCPM-o 4.5 全双工多模态大模型的 AI 孕期陪护助手**：家人（丈夫/婆婆/妈妈/孕妇本人）打开摄像头和麦克风，与 AI 实时语音对话，AI 能「看见」和「听见」——通过视觉识别食物、通过声纹区分身份、通过对话理解需求，自动记录饮食、推荐食谱、分析营养并输出报告。
+**一个基于每日生命周期 Loop 驱动的孕期陪护 AI 助手**：每天首次启动时自动总结昨日饮食、对比国家营养标准（DRIs/膳食指南/体重标准），生成今日简报注入对话上下文；白天与家庭成员（通过声纹区分）自然交互，实时记录饮食、推荐食谱；次日循环往复。
 
-> **✅ 已确认。**
+> **批注（已采纳）：** 实时记录饮食 = 主动提取孕妇的饮食习惯。场景包括：①孕妇自己说想吃什么 ②家人说孕妇之前想吃什么 → 都记录到孕妇的饮食习惯 md 文件。同时主动询问家人会做什么菜 → 记录到家庭菜单。通过 system prompt + 正则化提取实现。
 
 ---
 
-## 二、四大模块详解
+## 二、三个营养文档的操作方法
+
+你已经下载到 `data/nutrition/raw/` 的三个文件，各自承担不同角色：
+
+| 文档 | 文件 | 用途 | PregoPal 的操作方式 |
+|------|------|------|-------------------|
+| **① 体重增长标准** | `妊娠期妇女体重增长推荐值标准.md` | 体重监测基准 | **主动询问体重** — 每天 Loop 中检查是否需要询问，对照 BMI 分类给出评价 |
+| **② 膳食指南** | `中国孕期妇女膳食指南2022图片转md版.md` | 食谱推荐基准 | **作为推荐食谱的约束基础** — 根据孕期阶段用宝塔推荐量生成模板 |
+| **③ DRIs** | `备孕&孕早中晚三期和哺乳期的所有膳食营养素参考摄入量.md` | 营养分析基准 | **Agent 定期思考** — 每天自动对比 RNI，分析不足，写入次日预设 |
+
+> **批注（已采纳）：** 所有 md 文件都需要我们自己写函数读取，而不是让大模型自己读。数据类的需要写全面的读取比较函数接口，文本类的需要设计好自动提取输出的函数。每日第一次对话前 PregoPal 自动整理当天的前置 system prompt 时，要考虑：营养、体重、家庭菜谱、营养素需求、核心记忆文件（家庭关系、谁和谁亲近、家里发生过什么）。
+
+### 2.1 体重增长标准 → 主动询问体重
+
+**实现方式**：写一个 `WeightStandardParser` 类，将 WS/T 801-2022 表1 编译为结构化数据，提供查询接口。
+
+```python
+# modules/nutrition_standards.py（新增）
+class WeightStandardParser:
+    """解析体重增长标准 md 文件，提供查询接口"""
+    
+    @staticmethod
+    def load() -> dict:
+        """读取 md 文件，返回结构化数据"""
+        # 返回：
+        # {
+        #   "bmi_standards": [
+        #     {"category": "低体重", "bmi_range": (0, 18.5), 
+        #      "total_gain": (11.0, 16.0), "weekly_gain": 0.46, 
+        #      "weekly_range": (0.37, 0.56)},
+        #     ...
+        #   ]
+        # }
+    
+    @staticmethod
+    def evaluate(bmi_before_pregnancy: float, current_week: int, 
+                 total_gain: float) -> dict:
+        """评估体重增长是否在推荐范围内"""
+        # 返回 {"status": "ok"/"warning", "message": "...", "suggestion": "..."}
+```
+
+**调用时机**：每天早上 Loop 的 `weight_check` 插件调用此函数，结果写入今日简报。
 
-### 模块 1：🔊 声纹识别 + 多模态身份感知
+> **批注（已采纳）：** 整理成函数，不要期待 32B 小参数模型去做这些，而是自动放到上下文中。
 
-**核心变化：从「单独录音注册」变为「对话中自然感知」**
+### 2.2 膳食指南 → 食谱推荐基础
 
-**业务需求：**
-- 用户在实时对话过程中，AI 自动识别说话人身份（丈夫/婆婆/妈妈/孕妇…）
-- 无需单独「注册」步骤，在自然对话中完成声纹采集和识别
-- 结合摄像头画面辅助确认（视觉+语音多模态）
+**实现方式**：写一个 `DietaryGuideParser` 类，将平衡膳食宝塔编译为结构化数据。
 
-**技术选型（最终方案）：**
-1. **主要方案：Whisper-medium encoder embedding**
-   - MiniCPM-o 4.5 内置了 Whisper-medium 作为语音编码器
-   - 当音频经过 Whisper encoder 时，中间层隐藏状态包含了说话人的声学特征（音色/语速/口音）
-   - 做法：提取 encoder 输出的 hidden states，做时间维度的平均池化，得到固定维度的 **speaker embedding**
-   - 新音频与该 embedding 做余弦相似度比对，判断是否为同一人
-   - 这是业界成熟做法，比当前 6 维统计特征鲁棒许多
+```python
+# modules/nutrition_standards.py
+class DietaryGuideParser:
+    """解析膳食指南 md 文件，提供各孕期推荐摄入量"""
+    
+    @staticmethod
+    def get_recommendations(trimester: str) -> dict:
+        """返回指定孕期的食物推荐量"""
+        # 返回孕中期/孕晚期/哺乳期的宝塔数据
+    
+    @staticmethod
+    def get_core_principles() -> list[str]:
+        """返回六条核心建议"""
+```
 
-2. **备选方案：保留当前频谱相似度方案**
-   - 作为 fallback 兜底
-   - 也可作为置信度参考，与 embedding 方案加权融合
+**与家庭菜谱结合**：
+- `data/family/recipes.md` — 记录家人会做的菜（主动询问后记录）
+- `data/family/preferences.md` — 记录所有家人的饮食偏好、忌口、过敏
+- 推荐食谱时：膳食指南约束 + 家庭菜谱过滤 + 个人偏好排序
+
+> **批注（已采纳）：** 需要设计好如何与用户家庭菜谱结合，而不是去提出做一些不可能的菜。饮食偏好应该记录所有家人（不只是孕妇），分模块记录，设计好提取的函数接口。注意记录家里所有人是否有忌口、过敏。
+
+### 2.3 DRIs → Agent 定期分析（自动运行 → 写入次日预设）
+
+**改进方案**：
+
+```python
+# modules/nutrition_standards.py
+class DRIsParser:
+    """解析 DRIs md 文件（表15-18），提供营养素参考摄入量查询"""
+    
+    @staticmethod
+    def get_rni(stage: str) -> dict:
+        """返回指定阶段的 RNI 数据
+        stage: "pre_pregnancy" / "early" / "mid" / "late" / "lactation"
+        """
+    
+    @staticmethod
+    def compare_with_intake(stage: str, intake: dict) -> dict:
+        """对比实际摄入与 RNI，返回差异分析"""
+        # 返回每个营养素的差异百分比 + 重点关注标记
+```
 
-**部署说明：**
-- MiniCPM-o 4.5 是一个统一的多模态模型，不是多个独立组件的拼装
-- 需要用 MiniCPM-o 官方推理框架（OpenBMB 提供）部署
-- **llama.cpp 对 MiniCPM-o 的全双工多模态支持可能不完整**，后续会根据实际情况选择：A) OpenBMB 官方推理 B) Modal GPU 部署 C) llama.cpp（如果兼容）
+**分析流程**：
+1. 读取昨日饮食日志（`data/logs/饮食日志_YYYY-MM-DD.md`）
+2. 用 `DRIsParser.compare_with_intake()` 对比
+3. 结合家庭菜谱，给出「今天建议多吃哪些家里能做的菜」
+4. 写入 `data/presets/今日简报_YYYY-MM-DD.json`
 
-> **✅ 已根据你的批注修正：优先开发 Whisper-medium embedding 方案，频谱相似度保留为备选。**
+> **批注（待改进）：** 请基于其它批注改进方案。✅ 已改进：结合家庭菜谱，建议具体可做的菜。
 
 ---
 
-### 模块 2：🍳 智能菜品推荐（由 MiniCPM-o 4.5 驱动）
+## 三、核心架构：Loop 驱动（状态机 + 插件注册）
 
-**核心变化：从「模板随机选」变为「AI 实时对话推荐」**
+### 3.1 设计理念
 
-**业务需求：**
-- 用户和 AI 对话：「今天想吃鱼」「有点没胃口」「嘴里发苦」…
-- AI 理解上下文 → 生成个性化推荐
-- 输出三餐+加餐方案 + 理由 + 注意事项
+PregoPal 不是一个「用户点按钮 → 出结果」的被动应用，而是**有每日生命周期的主动伴侣**。
 
-**技术选型：**
-- **MiniCPM-o 4.5（统一模型）**：直接用对话能力做推荐
-- **营养数据本地嵌入**：把中国孕期营养数据整理成 JSON，在系统提示词中提供给模型
-- **不需要 RAG**（你说得对，过度设计了），只需要把营养数据放在上下文里
-- **规则兜底**：`MEAL_TEMPLATES` 保留作为离线 fallback（无模型时可用）
+参考你提供的 `nanobot_core/agent/loop.py` 中的**状态机事件驱动模式**，PregoPal 的 Loop 提取两个核心设计：
 
-**注意：** MiniCPM-o 4.5 本身是一个统一的端到端多模态模型，不是「全家桶」——SigLip2、Whisper、Qwen3、CosyVoice2 是其内部组件，不是独立安装的库。
+1. **TurnState 状态机** — 管理每日生命周期的阶段流转
+2. **可注册的扩展能力** — 每个阶段的具体逻辑由 Plugin 实现
 
-> **✅ 已根据你的批注修正：去掉 RAG，营养数据本地嵌入，规则兜底保留。**
+> **批注（已采纳）：** 具体实现不能太复杂，达到目的，具有可拓展性，具有稳定性（不会因为模型偶尔的犯错或者输出不稳定而完全逻辑混乱）。
 
----
+### 3.2 每日生命周期（v5 改进版）
+
+根据你的批注，关键变更：
+- **触发时机**：每晚 00:00 自动总结（或程序启动时检查状态位）
+- **新增阶段**：`FAMILY_QUIZ`（主动询问家庭菜谱/偏好）、`THREE_DAY_SUMMARY`（每三天总结）
+- **状态位机制**：`data/presets/.daily_status.json` 记录每日完成状态
 
-### 模块 3：📝 饮食记录 — 对话中自动记录，存 Markdown
-
-**核心变化：从「手动填表单」变为「AI 自动从对话中提取」**
-
-**业务需求：**
-- AI 在对话中记录：「今天中午吃了番茄牛腩和米饭」
-- 用户确认后自动存档
-- 生成结构化数据（JSON）+ 可读文档（Markdown）
-- 对历史记录支持查询
-
-**技术选型（修正后）：**
-
-**1. 数据提取方式（关键设计）**
-MiniCPM-o 4.5 **没有 toolcall 功能**，所以不能直接调用 Python 函数。
-改为 **「标记格式输出 + 正则解析」** 方案：
-- 在系统提示词中告诉模型：当你需要记录饮食时，请输出以下格式——
-  ```
-  [DIET_RECORD]
-  日期: 2026-06-07
-  早餐: 全麦面包+鸡蛋+牛奶
-  午餐: 清蒸鱼+糙米饭+炒时蔬
-  晚餐: 
-  加餐: 酸奶+坚果
-  心情: 挺好
-  备注: 
-  [/DIET_RECORD]
-  ```
-- 后端 Python 用正则表达式解析 `[DIET_RECORD]...[/DIET_RECORD]` 之间的内容
-- 解析后存入 JSON + 生成 Markdown
-
-**2. Markdown 模板引擎是什么？**
-就是当前 `diet_logger.py` 中的 `_generate_markdown()` 方法——**用 Python f-string 拼接 Markdown 文本**。不是什么复杂东西，就是一个字符串模板函数。保留不变，只是数据来源从「用户填表单」变为「AI 对话中提取」。
-
-**3. 为什么不需要向量检索？**
-你直觉正确——**确实冗余了**。之前我提出向量检索（ChromaDB）是为了支持语义搜索「上周三吃了什么？」，但实际上直接用 JSON 按日期过滤就能实现。去掉此方案，保持简单。
-
-**数据流向：**
 ```
-MiniCPM-o 回复 (含 [DIET_RECORD] 标记)
-  → Python 正则解析
-  → 存储到 data/diet_logs.json (结构化)
-  → 同时生成 data/logs/饮食日志_YYYY-MM-DD.md (可读)
+                         ┌─────────────┐
+                         │   LAUNCH    │  ← 检查今日状态位
+                         │   (启动)     │     若已总结 → 直接 INTERACT
+                         └──────┬──────┘     若未总结 → 进入总结流程
+                                │
+                    ┌───────────┴───────────┐
+                    │                       │
+             今日未总结                  今日已总结
+                    │                       │
+                    ▼                       ▼
+            ┌──────────────┐       ┌──────────────┐
+            │  FAMILY_QUIZ │       │              │
+            │  (家庭问卷)    │       │              │
+            │  ├ 检查是否需要  │       │              │
+            │  │  询问新菜谱  │       │              │
+            │  └ 检查是否需要  │       │              │
+            │    询问体重    │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               │              │
+            ┌──────────────┐       │              │
+            │  SUMMARIZE   │       │              │
+            │  (昨日总结)    │       │              │
+            │  ├ 读取饮食日志 │       │              │
+            │  ├ 读取体重记录 │       │              │
+            │  └ 读取家庭记忆 │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               │              │
+            ┌──────────────┐       │              │
+            │   ANALYZE    │       │              │
+            │  (营养分析)    │       │              │
+            │  └ 对比DRIs  │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               │              │
+            ┌──────────────┐       │              │
+            │    BRIEF     │       │              │
+            │  (生成简报)    │       │              │
+            │  └ 写JSON    │       │              │
+            └──────┬───────┘       │              │
+                   │               │              │
+                   ▼               ▼              │
+            ┌──────────────────────────────────┐  │
+            │           INTERACT               │◄─┘
+            │       (白天交互模式)               │
+            │  ├ 声纹识别 → 区分说话人           │
+            │  ├ 对话理解 → 正则提取饮食记录      │
+            │  │  → 写入饮食习惯.md             │
+            │  │  → 写入家庭菜谱.md             │
+            │  ├ 推荐 → 膳食指南+家庭菜谱约束    │
+            │  └ 简报注入 → AI 知道今日关注点    │
+            └──────────────┬───────────────────┘
+                           │
+                     每晚 00:00（或关闭时）
+                           │
+                           ▼
+            ┌──────────────┐
+            │ CONSOLIDATE  │
+            │  (晚间整理)    │
+            │  ├ 汇总今日    │
+            │  ├ 检查是否到  │
+            │  │  三天总结   │
+            │  └ 写明日预设  │
+            └──────┬───────┘
+                   │
+                   ▼
+            ┌──────────────┐
+            │     DONE     │
+            │  标记今日完成  │
+            └──────────────┘
+```
+
+> **批注（已采纳）：** 每晚 00:00 自动总结，设置状态位。程序关闭后第二天启动自动检查状态位。界面设计：4 个子页面。
+
+### 3.3 状态机定义（v5 改进版）
+
+```python
+class LoopState(Enum):
+    LAUNCH = "launch"           # 启动检查：检查今日状态位
+    FAMILY_QUIZ = "family_quiz" # 家庭问卷：检查是否需要询问菜谱/体重
+    SUMMARIZE = "summarize"     # 昨日总结：分析昨日饮食/体重/家庭记忆
+    ANALYZE = "analyze"         # 营养分析：对比 DRIs
+    BRIEF = "brief"             # 生成今日简报
+    INTERACT = "interact"       # 白天交互模式（等待用户操作）
+    THREE_DAY = "three_day"     # 每三天自动总结（由 CONSOLIDATE 触发）
+    CONSOLIDATE = "consolidate" # 晚间整理
+    DONE = "done"
+
+_TRANSITIONS = {
+    (LoopState.LAUNCH, "need_summary"):    LoopState.FAMILY_QUIZ,
+    (LoopState.LAUNCH, "already_done"):    LoopState.INTERACT,
+    (LoopState.FAMILY_QUIZ, "ok"):         LoopState.SUMMARIZE,
+    (LoopState.SUMMARIZE, "ok"):           LoopState.ANALYZE,
+    (LoopState.ANALYZE, "ok"):             LoopState.BRIEF,
+    (LoopState.BRIEF, "ok"):               LoopState.INTERACT,
+    (LoopState.INTERACT, "day_ended"):     LoopState.CONSOLIDATE,
+    (LoopState.CONSOLIDATE, "need_3day"):  LoopState.THREE_DAY,
+    (LoopState.CONSOLIDATE, "ok"):         LoopState.DONE,
+    (LoopState.THREE_DAY, "ok"):           LoopState.DONE,
+}
 ```
 
-> **✅ 已根据你的批注修正：去掉 toolcall 假设，改用标记格式解析；去掉向量检索；详细解释了 Markdown 模板引擎。**
+> **批注（已采纳）：** 状态机设计根据目的迭代，已整合上下批注。
 
----
+### 3.4 状态处理器
 
-### 模块 4：📊 营养报告（基于中国官方标准）
+| 状态 | Handler | 功能 |
+|------|---------|------|
+| `LAUNCH` | `_state_launch()` | 读取 `data/presets/.daily_status.json` → 决定流程 |
+| `FAMILY_QUIZ` | `_state_family_quiz()` | 检查是否需要询问新菜谱/体重 → 写入今日简报待办 |
+| `SUMMARIZE` | `_state_summarize()` | 遍历执行 SUMMARIZE 阶段 Plugin |
+| `ANALYZE` | `_state_analyze()` | 遍历执行 ANALYZE 阶段 Plugin |
+| `BRIEF` | `_state_brief()` | 汇总为 `今日简报.json` |
+| `INTERACT` | `_state_interact()` | 等待用户交互，消费 Gradio event queue |
+| `THREE_DAY` | `_state_three_day()` | 每三天运行：分析营养缺失 → 改进家庭菜单建议 |
+| `CONSOLIDATE` | `_state_consolidate()` | 晚间整理，检查是否触发 THREE_DAY |
+| `DONE` | `_state_done()` | 写入状态位，清理资源 |
+
+> **批注（已采纳）：** 状态处理器根据目的迭代，已整合上下批注。
+
+### 3.5 主循环入口
+
+```python
+class PregoPalLoop:
+    def __init__(self):
+        self.plugins = PluginRegistry()
+        self.state = LoopState.LAUNCH
+        self._register_default_plugins()
+    
+    async def run(self) -> None:
+        while self.state is not LoopState.DONE:
+            handler_name = f"_state_{self.state.value}"
+            handler = getattr(self, handler_name)
+            event = await handler()
+            next_state = _TRANSITIONS.get((self.state, event))
+            if next_state is None:
+                raise RuntimeError(f"No transition from {self.state} on {event}")
+            self.state = next_state
+```
 
-**核心变化：从「凭记忆编数据库」变为「查中国官方营养标准」**
+> **批注：** ________
 
-**业务需求：**
-- 基于中国官方营养标准做分析
-- 输出可视化报告 + 改善建议
-- 模板预先设计好，美观专业
+---
 
-**需要你下载的文件清单：**
+## 四、插件系统设计（可扩展性）
+
+### 4.1 插件基类
+
+```python
+class LoopStage(Enum):
+    FAMILY_QUIZ = "family_quiz"
+    SUMMARIZE = "summarize"
+    ANALYZE = "analyze"
+    BRIEF = "brief"
+    THREE_DAY = "three_day"
+    CONSOLIDATE = "consolidate"
+
+@dataclass
+class LoopContext:
+    briefing: dict = field(default_factory=dict)
+    weight_data: dict = field(default_factory=dict)
+    diet_records: list = field(default_factory=list)
+    family_recipes: list = field(default_factory=list)  # 新增：家庭菜谱
+    family_memory: dict = field(default_factory=dict)   # 新增：家庭记忆
+    analysis_results: dict = field(default_factory=dict)
+    errors: list = field(default_factory=list)
+
+class LoopPlugin(ABC):
+    @abstractmethod
+    def stage(self) -> LoopStage: ...
+    @abstractmethod
+    def name(self) -> str: ...
+    @abstractmethod
+    async def run(self, ctx: LoopContext) -> PluginResult: ...
+```
 
-请搜索并下载以下文件，放到 `data/nutrition/raw/` 目录下：
+> **批注：** ________
 
-| # | 文件名/关键词 | 发布机构 | 建议搜索方式 |
-|---|-------------|---------|------------|
-| 1 | **中国食物成分表（标准版）** 第6版 | 中国疾控中心营养与健康所 | 搜索 "中国食物成分表 标准版 第6版 Excel" 或 PDF |
-| 2 | **中国居民膳食营养素参考摄入量（DRIs 2023）** 摘要 | 中国营养学会 | 搜索 "DRIs 2023 中国居民膳食营养素参考摄入量" |
-| 3 | **中国孕期妇女膳食指南（2022）** | 中国营养学会 | 搜索 "孕期妇女膳食指南 2022 中国营养学会" |
-| 4 | **妊娠期妇女体重增长推荐值（WS/T 801-2022）** | 国家卫健委 | 搜索 "WS/T 801-2022 妊娠期妇女体重增长推荐值" |
+### 4.2 内置插件清单（v5 更新版）
 
-如果你有些文件找不到，给我说，我协助搜索。
+| 插件 | 类名 | 注册阶段 | 功能 | 数据源 |
+|------|------|---------|------|--------|
+| 家庭菜谱检查 | `FamilyRecipeQuizPlugin` | FAMILY_QUIZ | 检查是否需要询问新菜谱 | `data/family/recipes.md` |
+| 体重询问检查 | `WeightQuizPlugin` | FAMILY_QUIZ | 检查是否需要询问体重 | `data/logs/` |
+| 昨日饮食总结 | `DietSummaryPlugin` | SUMMARIZE | 读取昨日饮食日志，汇总三餐 | `data/logs/*.md` |
+| 体重检查 | `WeightCheckPlugin` | SUMMARIZE | 检查体重记录，对比 WS/T 801 | `WeightStandardParser` |
+| 家庭记忆加载 | `FamilyMemoryPlugin` | SUMMARIZE | 加载家庭关系/事件记忆 | `data/family/memory.md` |
+| DRIs 分析 | `DRIAnalysisPlugin` | ANALYZE | 对比营养素参考摄入量 | `DRIsParser` + 昨日饮食 |
+| 简报生成 | `BriefingGeneratorPlugin` | BRIEF | 汇总分析为结构化 JSON | `LoopContext` |
+| 三天总结 | `ThreeDaySummaryPlugin` | THREE_DAY | 分析营养缺失趋势，改进家庭菜单 | 近三天饮食记录 |
+| 预设写入 | `PresetWriterPlugin` | CONSOLIDATE | 生成明日预设文件 | `data/presets/` |
 
-**如果没有下载到正式文件怎么办：**
-我已编写了一份基于 DRIs 公开数据的营养数据库作为 baseline（当前 `DEFAULT_NUTRITION_DB`），可以先用它做原型开发，等你找到正式文件后替换即可。
+> **批注：** ________
 
-> **✅ 已根据你的批注修正：列出具体文件清单，你下载后我整理成 JSON。**
+### 4.3 扩展方式
 
----
+```python
+# 新增功能只需两步：
+class NewPlugin(LoopPlugin):
+    def stage(self) -> LoopStage: return LoopStage.SUMMARIZE
+    def name(self) -> str: return "new_feature"
+    async def run(self, ctx: LoopContext) -> PluginResult: ...
 
-## 三、交互流程设计
+loop.plugins.register(NewPlugin())
+# 不需要修改 loop.py 的状态机代码
+```
 
-### 核心设计原则
+> **批注：** ________
 
-你批注得对：**不需要穷举所有情况，而是设计好 MiniCPM-o 的系统提示词 + 当前模式状态。**
+---
 
-### 系统提示词架构
+## 五、整体文件结构（v5 更新版）
 
 ```
-你叫 PregoPal，是一个孕期陪护 AI 助手。
-你的任务：
-1. 识别说话人身份（通过声音判断是谁在说话）
-2. 根据对话理解用户需求（记录饮食、推荐菜品、闲聊陪伴）
-3. 当用户有明确需求时，按指定格式输出记录
-
-当前模式：{模式名称}  ← 动态注入（任务模式/闲聊模式）
-当前说话人：{身份}    ← 声纹识别结果
-
-输出格式规则：
-- 当用户描述了饮食内容，请在回复末尾附加 [DIET_RECORD]...[/DIET_RECORD]
-- 当用户要求推荐菜品，直接推荐并给出理由
-- 普通对话保持自然、温馨、关心的语气
+PregoPal/
+├── app.py                          # 主入口：启动 Gradio + Loop
+├── config.py                       # 全局配置
+├── utils.py                        # 工具函数
+├── loop.py              ← 🆕 新增  # 核心循环引擎（状态机驱动）
+│
+├── plugins/              ← 🆕 新增  # Loop 插件
+│   ├── __init__.py
+│   ├── base.py                     # LoopPlugin 基类 + PluginRegistry
+│   ├── family_quiz.py              # 家庭菜谱/体重询问检查
+│   ├── diet_summary.py             # 昨日饮食总结
+│   ├── weight_check.py             # 体重检查（WS/T 801）
+│   ├── family_memory.py            # 家庭记忆加载
+│   ├── dri_analysis.py             # DRIs 营养素对比分析
+│   ├── briefing_generator.py       # 今日简报生成器
+│   ├── three_day_summary.py        # 每三天总结
+│   └── preset_writer.py            # 预设文件写入
+│
+├── modules/                        # 业务逻辑层
+│   ├── __init__.py
+│   ├── nutrition_standards.py      # ← 🆕 新增：营养标准解析器
+│   │   ├── WeightStandardParser    #   体重标准解析
+│   │   ├── DietaryGuideParser      #   膳食指南解析
+│   │   └── DRIsParser              #   DRIs 解析
+│   ├── family_manager.py           # ← 🆕 新增：家庭信息管理
+│   │   ├── 读取/写入 recipes.md
+│   │   ├── 读取/写入 preferences.md
+│   │   └── 读取/写入 memory.md
+│   ├── diet_extractor.py           # ← 🆕 新增：system prompt + 正则提取
+│   │   ├── 从对话中提取饮食记录
+│   │   ├── 从对话中提取菜谱信息
+│   │   └── 从对话中提取家庭关系
+│   ├── voiceprint.py               # 声纹识别
+│   ├── meal_recommender.py         # 菜品推荐
+│   ├── diet_logger.py              # 饮食记录 + Markdown 生成
+│   └── nutrition_analyzer.py       # 营养分析 + 可视化
+│
+├── core/                           # AI 核心层（等待 MiniCPM-o）
+│   ├── __init__.py
+│   ├── model_loader.py
+│   ├── voice_processor.py
+│   ├── vision_processor.py
+│   └── conversation_manager.py
+│
+├── ui/                             # 表现层
+│   ├── __init__.py
+│   └── app_builder.py              # Gradio 界面
+│
+├── data/
+│   ├── nutrition/
+│   │   └── raw/                    # 三个 MD 文件
+│   ├── family/            ← 🆕 新增  # 家庭信息
+│   │   ├── recipes.md              # 家庭菜谱（家人会做的菜）
+│   │   ├── preferences.md          # 饮食偏好/忌口/过敏
+│   │   └── memory.md               # 家庭记忆（关系/事件）
+│   ├── presets/                    # 每日简报
+│   │   └── .daily_status.json      # 状态位文件
+│   ├── voices/
+│   ├── logs/                       # Markdown 饮食日志
+│   └── reports/                    # 导出报告
+│
+├── docs/
+│   ├── 项目理解_技术架构.md
+│   └── 开发日志.md
+├── requirements.txt
+└── README.md
 ```
 
-### 交互流程
+> **批注：** ________
 
-```
-用户打开摄像头+麦克风
-       │
-       ▼
-AI 根据系统提示词主动问候
-       │
-       ▼
-用户说话 → MiniCPM-o 全双工处理
-  ├→ 声纹识别 → 更新「当前说话人」
-  ├→ 理解语义 → 更新「当前模式」
-  └→ 生成回复 → 含 [DIET_RECORD] 标记（如需）
-       │
-       ▼
-后端解析回复：
-  ├→ 检测到 [DIET_RECORD] → 提取数据 → 存 JSON + Markdown
-  ├→ 检测到推荐请求 → 显示推荐结果到 UI
-  └→ 其他 → 正常对话
-```
+---
 
-### 双模式设计
+## 六、UI 界面设计（根据批注新增）
 
-| 模式 | 判定方式 | 行为 |
-|------|---------|------|
-| 🎯 **任务模式** | 用户提到「记录」「推荐」「分析」「报告」等关键词 | 执行对应业务逻辑 + 标记输出 |
-| 💬 **闲聊模式** | 用户开启日常对话 | 自然陪伴，不做结构化记录 |
+根据你的批注，Gradio 界面改为 **4 个子页面**：
+
+### 页面 1：语音交互（主界面）
+- 语音输入/输出（未来支持视频）
+- **显示 PregoPal 当前思考/操作关键词**（通过 system prompt + 正则提取，每次执行下一步时用特定字符包裹下一步主题）
+- **自动展示相关文件操作的输出结果**（截断 + 省略号）
+- 声纹识别状态显示
+
+### 页面 2：家庭成员饮食习惯
+- 展示所有家庭成员的饮食偏好、忌口、过敏
+- 展示家庭菜谱（家人会做的菜）
+- 支持手动添加/修改
+
+### 页面 3：每三天自动总结
+- 分析孕妇饮食是否存在营养缺失
+- 对家庭菜单给出改进建议
+- 由 `THREE_DAY` 状态触发
 
-> **✅ 已根据你的批注修正：聚焦系统提示词设计 + 模式管理，不穷举情况。**
+### 页面 4：营养报告
+- 可视化报告（保留原有）
+- 体重增长趋势图
+- 营养素摄入对比图
+
+> **批注：** ________
 
 ---
 
-## 四、技术栈一览
+## 七、system prompt + 正则提取设计（根据批注新增）
+
+这是 PregoPal 的核心机制，用于在不依赖 toolcall 的情况下实现结构化数据提取。
+
+### 7.1 提取标记格式
+
+在 system prompt 中告诉模型，当需要记录信息时，使用以下标记格式：
 
-| 层级 | 技术 | 用途 |
-|------|------|------|
-| 核心模型 | **MiniCPM-o 4.5**（统一多模态模型） | 全双工推理：视觉+语音+文本+语音输出 |
-| 前端框架 | **Gradio** | Web 界面，实时对话交互 |
-| 声纹识别 | **Whisper-medium encoder embedding**（模型内置） | 说话人身份识别 |
-| 频谱方案 | **NumPy + SoundFile**（备选 fallback） | 声纹识别兜底 |
-| 数据存储 | **JSON + Markdown**（结构化可扩展） | 饮食记录 + 报告存档 |
-| 营养标准 | **中国官方 DRIs / 食物成分表**（你下载后我整理） | 营养分析基准 |
-| 部署平台 | **Modal**（你有黑客松额度，后续配置） | 云端 GPU 部署 |
-
-### 数据存储 Schema 设计（可扩展）
-
-**JSON 格式（diet_logs.json）：**
-```json
-{
-  "schema_version": "1.0",
-  "records": [
-    {
-      "id": "a1b2c3d4",
-      "date": "2026-06-07",
-      "speaker": {"name": "小明", "relation": "丈夫"},
-      "meals": {"早餐": "...", "午餐": "...", "晚餐": "", "加餐": "..."},
-      "mood": "挺好",
-      "notes": "",
-      "extensions": {},
-      "created_at": "2026-06-07T10:30:00"
-    }
-  ]
-}
 ```
+[EXTRACT_DIET]
+日期: 2026-06-08
+餐次: 午餐
+食物: 番茄牛腩, 米饭
+份量: 一碗
+记录人: 丈夫
+备注: 孕妇说想吃
+[/EXTRACT_DIET]
+
+[EXTRACT_RECIPE]
+菜名: 清蒸鲈鱼
+制作人: 丈夫
+难度: 中等
+食材: 鲈鱼, 葱, 姜, 蒸鱼豉油
+备注: 孕妇爱吃
+[/EXTRACT_RECIPE]
+
+[EXTRACT_PREFERENCE]
+人员: 丈夫
+类型: 忌口
+内容: 不吃香菜
+[/EXTRACT_PREFERENCE]
+
+[EXTRACT_WEIGHT]
+日期: 2026-06-08
+体重: 62.5
+记录人: 孕妇
+[/EXTRACT_WEIGHT]
+
+[THINKING]
+当前步骤: 分析昨日钙摄入
+下一步: 对比DRIs标准
+[/THINKING]
+```
+
+### 7.2 后端正则解析
+
+```python
+# modules/diet_extractor.py
+import re
+
+class DietExtractor:
+    """从 AI 回复中提取结构化数据"""
+    
+    DIET_PATTERN = re.compile(
+        r'\[EXTRACT_DIET\](.*?)\[/EXTRACT_DIET\]', re.DOTALL
+    )
+    RECIPE_PATTERN = re.compile(
+        r'\[EXTRACT_RECIPE\](.*?)\[/EXTRACT_RECIPE\]', re.DOTALL
+    )
+    PREFERENCE_PATTERN = re.compile(
+        r'\[EXTRACT_PREFERENCE\](.*?)\[/EXTRACT_PREFERENCE\]', re.DOTALL
+    )
+    WEIGHT_PATTERN = re.compile(
+        r'\[EXTRACT_WEIGHT\](.*?)\[/EXTRACT_WEIGHT\]', re.DOTALL
+    )
+    THINKING_PATTERN = re.compile(
+        r'\[THINKING\](.*?)\[/THINKING\]', re.DOTALL
+    )
+    
+    @staticmethod
+    def extract_all(text: str) -> dict:
+        """从文本中提取所有结构化数据"""
+        return {
+            "diets": DietExtractor._parse_diets(text),
+            "recipes": DietExtractor._parse_recipes(text),
+            "preferences": DietExtractor._parse_preferences(text),
+            "weights": DietExtractor._parse_weights(text),
+            "thinking": DietExtractor._parse_thinking(text),
+        }
+    
+    @staticmethod
+    def _parse_diets(text: str) -> list[dict]:
+        """解析 [EXTRACT_DIET] 块"""
+        results = []
+        for match in DietExtractor.DIET_PATTERN.finditer(text):
+            block = match.group(1)
+            entry = {}
+            for line in block.strip().split('\n'):
+                if ':' in line:
+                    key, val = line.split(':', 1)
+                    entry[key.strip()] = val.strip()
+            if entry:
+                results.append(entry)
+        return results
+```
+
+### 7.3 稳定性设计
 
-- `extensions: {}` 保留给未来扩展（如血糖、体重、胎动等）
-- `schema_version` 支持后续数据结构升级
+- **正则匹配失败时的 fallback**：如果模型输出格式不完整，尝试用关键词匹配（如 "吃了"、"想吃"、"记录" 等）
+- **用户确认机制**：提取的数据先展示给用户确认，再写入文件
+- **多轮累积**：同一餐次的信息可能分散在多轮对话中，需要累积合并
 
-> **✅ 已根据你的批注修正：去掉「全家桶」表述，添加数据 schema 设计说明。**
+> **批注：** ________
 
 ---
 
-## 五、模块拆分方案（最终版）
+## 八、数据流全景（v5 更新版）
 
 ```
-PregoPal/
-├── app.py                          # 主入口：启动 Gradio + 加载模型
-├── config.py                       # 路径 / 枚举 / 模型参数 / 系统提示词模板
-├── core/                           # AI 核心层
-│   ├── __init__.py
-│   ├── model_loader.py             # 加载 MiniCPM-o 4.5 模型
-│   ├── voice_processor.py          # Whisper ASR + 声纹 embedding 提取
-│   ├── vision_processor.py         # SigLip2 视觉处理
-│   └── conversation_manager.py     # 对话管理 + 系统提示词构建 + [DIET_RECORD] 解析
-├── modules/                        # 业务逻辑层
-│   ├── __init__.py
-│   ├── voiceprint.py               # 声纹注册/识别（调用 core 或 fallback 频谱方案）
-│   ├── meal_recommender.py         # 菜品推荐（调用 MiniCPM-o 或兜底规则）
-│   ├── diet_logger.py              # 饮食记录 + Markdown 生成（JSON 双写）
-│   └── nutrition_analyzer.py       # 营养分析（基于官方标准）+ matplotlib 可视化
-├── ui/                             # 表现层
-│   ├── __init__.py
-│   └── app_builder.py              # Gradio 界面 + 事件绑定
-├── data/                           # 数据存储
-│   ├── nutrition/
-│   │   └── raw/                    # ← 你下载的营养标准原始文件放这里
-│   ├── voices/                     # 声纹数据
-│   ├── logs/                       # Markdown 饮食日志
-│   └── reports/                    # 导出报告
-├── docs/
-│   ├── 项目理解_技术架构.md         # 本文档
-│   └── 开发日志.md                  # 记录错误、调试经验、模型调用技巧
-├── requirements.txt                # 每次运行成功后根据环境版本锁定
-└── README.md
+                data/nutrition/raw/          data/family/
+                ├── 体重标准.md              ├── recipes.md
+                ├── 膳食指南.md              ├── preferences.md
+                └── DRIs.md                  └── memory.md
+                      │                            │
+                      ▼                            ▼
+            ┌──────────────────┐      ┌──────────────────────┐
+            │ nutrition_       │      │ family_manager.py    │
+            │ standards.py     │      │ 读取/写入家庭信息    │
+            │ 编译为结构化数据  │      └──────────┬───────────┘
+            └────────┬─────────┘                 │
+                     │                           │
+                     ▼                           ▼
+            ┌──────────────────────────────────────────────────┐
+            │                   loop.py                         │
+            │  LAUNCH → FAMILY_QUIZ → SUMMARIZE → ANALYZE      │
+            │  → BRIEF → INTERACT → CONSOLIDATE → (THREE_DAY)  │
+            │                                                   │
+            │  每个阶段调用对应 Plugin                           │
+            │  Plugin 调用 modules/ 层的函数                     │
+            └──────────────────────┬───────────────────────────┘
+                                  │
+                                  ▼
+            ┌──────────────────────────────────────────────────┐
+            │  data/presets/今日简报_YYYY-MM-DD.json            │
+            │  {                                               │
+            │    "date": "2026-06-08",                         │
+            │    "weight_check": {"need_ask": true/false},     │
+            │    "recipe_check": {"need_ask": true/false},     │
+            │    "nutrient_focus": ["钙", "铁", "叶酸"],       │
+            │    "recommended_foods": ["菠菜", "瘦肉", "豆腐"],│
+            │    "family_recipes_available": ["番茄牛腩",...], │
+            │    "conversation_topics": ["今天想吃鱼吗？"],    │
+            │    "family_memory": "昨天丈夫说...",             │
+            │    "thinking_keywords": "分析钙摄入"             │
+            │  }                                               │
+            └──────────────────────┬───────────────────────────┘
+                                  │
+                                  ▼
+            ┌──────────────────────────────────────────────────┐
+            │  ui/app_builder.py (Gradio 4页面)                 │
+            │  页面1: 语音交互 (显示 thinking_keywords + 截断)  │
+            │  页面2: 家庭饮食习惯                              │
+            │  页面3: 三天总结                                  │
+            │  页面4: 营养报告                                  │
+            └──────────────────────┬───────────────────────────┘
+                                  │
+                                  ▼
+            modules/diet_extractor.py (从对话中正则提取)
+            modules/family_manager.py (写入家庭信息)
+            modules/diet_logger.py (记录饮食)
+                                  │
+                                  ▼
+                    次日 loop.py 再次启动 → 循环
 ```
 
-> **✅ 已确认。**
+> **批注：** ________
 
 ---
 
-## 六、决策记录（你已回答）
+## 九、技术栈一览
+
+| 层级 | 技术 | 用途 |
+|------|------|------|
+| 核心模型 | **MiniCPM-o 4.5**（统一多模态模型） | 全双工推理：视觉+语音+文本+语音输出 |
+| 前端框架 | **Gradio 6.x** | Web 界面，4 个子页面 |
+| 声纹识别 | Whisper-medium encoder embedding（优先）| 说话人身份识别 |
+| 频谱方案 | NumPy + SoundFile（备选 fallback） | 声纹识别兜底 |
+| 数据存储 | JSON + Markdown | 饮食记录 + 报告存档 + 每日简报 + 家庭信息 |
+| 营养标准 | 三个 MD 文件（已下载）+ 自写解析器 | 体重标准/膳食指南/DRIs |
+| 循环引擎 | 自研状态机 + 插件注册 | 每日生命周期管理 |
+| 数据提取 | 正则表达式（system prompt 标记格式） | 从对话中提取结构化数据 |
+| 部署平台 | HuggingFace Spaces（目前）+ Modal（后续） | 云端部署 |
 
-| # | 问题 | 你的决策 |
-|---|------|---------|
-| 1 | 声纹识别方案？ | **Whisper-medium embedding**（优先），频谱相似度（备选） |
-| 2 | 部署方式？ | **Modal**（你有黑客松额度），后续我帮你配置 |
-| 3 | 营养标准谁来整理？ | **你下载文件**到 `data/nutrition/raw/`，我整理成 JSON |
-| 4 | 拆分时机？ | **处理好上述问题后**立即拆分 |
+> **批注：** ________
 
 ---
 
-## 七、后续行动计划（按顺序）
+## 十、待讨论问题清单
 
-- [ ] **你做的事：** 下载营养标准文件到 `data/nutrition/raw/`
-- [ ] **我做的事：** 更新开发日志 → 列出需要下载的营养文件清单 → 等文件就绪后执行文件拆分
-- [ ] **然后：** 研究 Whisper-medium embedding 提取方案
-- [ ] **然后：** 配置 Modal 部署
-- [ ] **然后：** 逐步替换规则引擎为 AI 驱动
+| # | 问题 | 你的选择 / 意见 |
+|---|------|----------------|
+| 1 | **Loop 触发时机**：每晚 00:00 自动总结 + 程序启动时检查状态位（已采纳） | ✅ 已确认 |
+| 2 | **简报承载形式**：JSON 文件 `data/presets/` 落盘（已采纳） | ✅ 已确认 |
+| 3 | **状态位机制**：`data/presets/.daily_status.json` 记录每日完成状态 | ________ |
+| 4 | **家庭信息文件格式**：三个 md 文件（recipes.md / preferences.md / memory.md） | ________ |
+| 5 | **system prompt 标记格式**：`[EXTRACT_DIET]` / `[EXTRACT_RECIPE]` / `[THINKING]` 等 | ________ |
+| 6 | **UI 4 页面**：语音交互 / 家庭饮食习惯 / 三天总结 / 营养报告 | ________ |
+| 7 | **三天总结触发条件**：每自然日 00:00 检查是否满 3 天？还是每 3 次 CONSOLIDATE？ | ________ |
+| 8 | **还有什么需要调整的？** | ________ |
 
 ---
 
-*文档生成时间：2026-06-07 | v3 - 已整合所有批注*
+*文档生成时间：2026-06-08 | v5 - 整合批注，细化实现方案*
diff --git a/loop.py b/loop.py
new file mode 100644
index 0000000000000000000000000000000000000000..3164eab6a0a88705817815696ca3e90de3029c4e
--- /dev/null
+++ b/loop.py
@@ -0,0 +1,291 @@
+"""
+PregoPal - 核心循环引擎
+=======================
+状态机驱动的每日生命周期管理。
+
+状态流转：
+  LAUNCH → FAMILY_QUIZ → SUMMARIZE → ANALYZE → BRIEF → INTERACT
+  → CONSOLIDATE → (THREE_DAY) → DONE
+
+状态位机制：
+  data/presets/.daily_status.json 记录每日完成状态
+"""
+
+import json
+import datetime
+import asyncio
+from enum import Enum
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from plugins.base import LoopPlugin, PluginResult, PluginRegistry, LoopStage, LoopContext
+
+PRESETS_DIR = Path("data/presets")
+STATUS_FILE = PRESETS_DIR / ".daily_status.json"
+
+
+# ============================================================
+# 状态枚举
+# ============================================================
+class LoopState(Enum):
+    LAUNCH = "launch"           # 启动检查：检查今日状态位
+    FAMILY_QUIZ = "family_quiz" # 家庭问卷：检查是否需要询问菜谱/体重
+    SUMMARIZE = "summarize"     # 昨日总结：分析昨日饮食/体重/家庭记忆
+    ANALYZE = "analyze"         # 营养分析：对比 DRIs
+    BRIEF = "brief"             # 生成今日简报
+    INTERACT = "interact"       # 白天交互模式（等待用户操作）
+    THREE_DAY = "three_day"     # 每三天自动总结
+    CONSOLIDATE = "consolidate" # 晚间整理
+    DONE = "done"               # 标记今日完成
+
+
+# ============================================================
+# 状态转移表
+# ============================================================
+_TRANSITIONS = {
+    (LoopState.LAUNCH, "need_summary"):    LoopState.FAMILY_QUIZ,
+    (LoopState.LAUNCH, "already_done"):    LoopState.INTERACT,
+    (LoopState.FAMILY_QUIZ, "ok"):         LoopState.SUMMARIZE,
+    (LoopState.SUMMARIZE, "ok"):           LoopState.ANALYZE,
+    (LoopState.ANALYZE, "ok"):             LoopState.BRIEF,
+    (LoopState.BRIEF, "ok"):               LoopState.INTERACT,
+    (LoopState.INTERACT, "day_ended"):     LoopState.CONSOLIDATE,
+    (LoopState.CONSOLIDATE, "need_3day"):  LoopState.THREE_DAY,
+    (LoopState.CONSOLIDATE, "ok"):         LoopState.DONE,
+    (LoopState.THREE_DAY, "ok"):           LoopState.DONE,
+}
+
+
+# ============================================================
+# 状态位管理
+# ============================================================
+class DailyStatus:
+    """管理每日状态位"""
+
+    STATUS_FILE = STATUS_FILE
+
+    @staticmethod
+    def load() -> dict:
+        """加载状态位文件"""
+        if STATUS_FILE.exists():
+            with open(STATUS_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+
+    @staticmethod
+    def save(status: dict):
+        """保存状态位文件"""
+        PRESETS_DIR.mkdir(parents=True, exist_ok=True)
+        with open(STATUS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(status, f, ensure_ascii=False, indent=2)
+
+    @staticmethod
+    def is_today_done() -> bool:
+        """检查今日是否已完成总结"""
+        today = datetime.date.today().isoformat()
+        status = DailyStatus.load()
+        return status.get(today, {}).get("summary_done", False)
+
+    @staticmethod
+    def mark_summary_done():
+        """标记今日总结完成"""
+        today = datetime.date.today().isoformat()
+        status = DailyStatus.load()
+        status[today] = status.get(today, {})
+        status[today]["summary_done"] = True
+        status[today]["completed_at"] = datetime.datetime.now().isoformat()
+        DailyStatus.save(status)
+
+    @staticmethod
+    def mark_day_ended():
+        """标记今日结束"""
+        today = datetime.date.today().isoformat()
+        status = DailyStatus.load()
+        status[today] = status.get(today, {})
+        status[today]["day_ended"] = True
+        status[today]["ended_at"] = datetime.datetime.now().isoformat()
+        DailyStatus.save(status)
+
+    @staticmethod
+    def get_last_summary_date() -> str | None:
+        """获取最近一次总结的日期"""
+        status = DailyStatus.load()
+        done_dates = [d for d, v in status.items() if v.get("summary_done")]
+        return max(done_dates) if done_dates else None
+
+    @staticmethod
+    def days_since_last_summary() -> int:
+        """距离上次总结的天数"""
+        last = DailyStatus.get_last_summary_date()
+        if last is None:
+            return 999
+        last_date = datetime.date.fromisoformat(last)
+        return (datetime.date.today() - last_date).days
+
+    @staticmethod
+    def should_three_day_summary() -> bool:
+        """检查是否需要进行三天总结"""
+        return DailyStatus.days_since_last_summary() >= 3
+
+
+# ============================================================
+# 主循环引擎
+# ============================================================
+class PregoPalLoop:
+    """核心循环引擎"""
+
+    def __init__(self):
+        self.plugins = PluginRegistry()
+        self.state = LoopState.LAUNCH
+        self.context = LoopContext()
+        self._register_default_plugins()
+
+    def _register_default_plugins(self):
+        """注册默认插件"""
+        from plugins.family_quiz import FamilyRecipeQuizPlugin, WeightQuizPlugin
+        from plugins.diet_summary import DietSummaryPlugin
+        from plugins.weight_check import WeightCheckPlugin
+        from plugins.family_memory import FamilyMemoryPlugin
+        from plugins.dri_analysis import DRIAnalysisPlugin
+        from plugins.briefing_generator import BriefingGeneratorPlugin
+        from plugins.three_day_summary import ThreeDaySummaryPlugin
+        from plugins.preset_writer import PresetWriterPlugin
+
+        self.plugins.register(FamilyRecipeQuizPlugin())
+        self.plugins.register(WeightQuizPlugin())
+        self.plugins.register(DietSummaryPlugin())
+        self.plugins.register(WeightCheckPlugin())
+        self.plugins.register(FamilyMemoryPlugin())
+        self.plugins.register(DRIAnalysisPlugin())
+        self.plugins.register(BriefingGeneratorPlugin())
+        self.plugins.register(ThreeDaySummaryPlugin())
+        self.plugins.register(PresetWriterPlugin())
+
+    async def run(self) -> None:
+        """主循环入口"""
+        while self.state is not LoopState.DONE:
+            handler_name = f"_state_{self.state.value}"
+            handler = getattr(self, handler_name)
+            event = await handler()
+            next_state = _TRANSITIONS.get((self.state, event))
+            if next_state is None:
+                raise RuntimeError(
+                    f"No transition from {self.state} on '{event}'"
+                )
+            self.state = next_state
+
+    # ============================================================
+    # 状态处理器
+    # ============================================================
+
+    async def _state_launch(self) -> str:
+        """启动检查：检查今日状态位"""
+        if DailyStatus.is_today_done():
+            return "already_done"
+        return "need_summary"
+
+    async def _state_family_quiz(self) -> str:
+        """家庭问卷：检查是否需要询问菜谱/体重"""
+        for plugin in self.plugins.get_plugins(LoopStage.FAMILY_QUIZ):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+        return "ok"
+
+    async def _state_summarize(self) -> str:
+        """昨日总结：执行所有 SUMMARIZE 阶段插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.SUMMARIZE):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+        return "ok"
+
+    async def _state_analyze(self) -> str:
+        """营养分析：执行所有 ANALYZE 阶段插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.ANALYZE):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+        return "ok"
+
+    async def _state_brief(self) -> str:
+        """生成今日简报：执行所有 BRIEF 阶段插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.BRIEF):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+        return "ok"
+
+    async def _state_interact(self) -> str:
+        """
+        白天交互模式：等待用户操作
+        此状态由外部事件触发（Gradio 界面交互）
+        """
+        return "day_ended"
+
+    async def _state_three_day(self) -> str:
+        """每三天总结：执行所有 THREE_DAY 阶段插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.THREE_DAY):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+        return "ok"
+
+    async def _state_consolidate(self) -> str:
+        """晚间整理：执行所有 CONSOLIDATE 阶段插件"""
+        for plugin in self.plugins.get_plugins(LoopStage.CONSOLIDATE):
+            result = await plugin.run(self.context)
+            if not result.success:
+                self.context.errors.append(result.message)
+
+        if DailyStatus.should_three_day_summary():
+            return "need_3day"
+        return "ok"
+
+    async def _state_done(self) -> str:
+        """标记今日完成"""
+        DailyStatus.mark_day_ended()
+        return "done_complete"
+
+    # ============================================================
+    # 外部接口
+    # ============================================================
+
+    def get_briefing(self) -> dict:
+        """获取今日简报"""
+        return self.context.briefing
+
+    def get_thinking_keywords(self) -> str:
+        """获取当前思考关键词（用于 UI 显示）"""
+        return self.context.briefing.get("thinking_keywords", "")
+
+    def get_errors(self) -> list[str]:
+        """获取错误列表"""
+        return self.context.errors
+
+    def run_sync(self):
+        """同步运行（用于非异步环境）"""
+        asyncio.run(self.run())
+
+
+# ============================================================
+# 便捷函数
+# ============================================================
+def run_daily_loop():
+    """运行每日循环（同步入口）"""
+    loop = PregoPalLoop()
+    loop.run_sync()
+    return loop
+
+
+def check_and_run_loop() -> PregoPalLoop:
+    """
+    检查并运行循环（供 Gradio 启动时调用）
+    
+    如果今日已总结，直接返回 loop 实例（不执行总结流程）
+    如果今日未总结，执行完整总结流程
+    """
+    loop = PregoPalLoop()
+    if not DailyStatus.is_today_done():
+        loop.run_sync()
+    return loop
diff --git a/modules/__pycache__/__init__.cpython-313.pyc b/modules/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a93a3d8c49eb3e7a72fbd8a8d4973adb50b176e7
Binary files /dev/null and b/modules/__pycache__/__init__.cpython-313.pyc differ
diff --git a/modules/__pycache__/diet_extractor.cpython-311.pyc b/modules/__pycache__/diet_extractor.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e178026b8e2a7b563d45d2a39e67d0e039ecc1d5
Binary files /dev/null and b/modules/__pycache__/diet_extractor.cpython-311.pyc differ
diff --git a/modules/__pycache__/diet_extractor.cpython-313.pyc b/modules/__pycache__/diet_extractor.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..839c3b11eb18cef933acace80bf7f4b08ef7d634
Binary files /dev/null and b/modules/__pycache__/diet_extractor.cpython-313.pyc differ
diff --git a/modules/__pycache__/family_manager.cpython-311.pyc b/modules/__pycache__/family_manager.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8464d949456a78e02bd44ac09d5ac5dfa836525d
Binary files /dev/null and b/modules/__pycache__/family_manager.cpython-311.pyc differ
diff --git a/modules/__pycache__/family_manager.cpython-313.pyc b/modules/__pycache__/family_manager.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea09d2f77a1b336cfc4eef41ddb8cb1f9c6734ff
Binary files /dev/null and b/modules/__pycache__/family_manager.cpython-313.pyc differ
diff --git a/modules/__pycache__/nutrition_standards.cpython-311.pyc b/modules/__pycache__/nutrition_standards.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9572db4e4e6b13c708862d860989e53c7ab4beb7
Binary files /dev/null and b/modules/__pycache__/nutrition_standards.cpython-311.pyc differ
diff --git a/modules/__pycache__/nutrition_standards.cpython-313.pyc b/modules/__pycache__/nutrition_standards.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2105b6677023afe0fe58d6573c085529dc5dbec1
Binary files /dev/null and b/modules/__pycache__/nutrition_standards.cpython-313.pyc differ
diff --git a/modules/diet_extractor.py b/modules/diet_extractor.py
new file mode 100644
index 0000000000000000000000000000000000000000..be1a74dea0c9207249df0fe5c457fd726d9cb421
--- /dev/null
+++ b/modules/diet_extractor.py
@@ -0,0 +1,274 @@
+"""
+PregoPal - 对话内容提取器
+=========================
+从 AI 回复中通过正则表达式提取结构化数据。
+
+提取标记格式（在 system prompt 中告知模型使用）：
+  [EXTRACT_DIET]...[/EXTRACT_DIET]       # 饮食记录
+  [EXTRACT_RECIPE]...[/EXTRACT_RECIPE]   # 菜谱信息
+  [EXTRACT_PREFERENCE]...[/EXTRACT_PREFERENCE]  # 偏好/忌口/过敏
+  [EXTRACT_WEIGHT]...[/EXTRACT_WEIGHT]   # 体重记录
+  [EXTRACT_MEMORY]...[/EXTRACT_MEMORY]   # 家庭记忆
+  [THINKING]...[/THINKING]               # 当前思考步骤
+"""
+
+import re
+import datetime
+
+
+class DietExtractor:
+    """从 AI 回复中提取所有结构化数据"""
+
+    # ============================================================
+    # 正则模式
+    # ============================================================
+    DIET_PATTERN = re.compile(
+        r'\[EXTRACT_DIET\](.*?)\[/EXTRACT_DIET\]', re.DOTALL
+    )
+    RECIPE_PATTERN = re.compile(
+        r'\[EXTRACT_RECIPE\](.*?)\[/EXTRACT_RECIPE\]', re.DOTALL
+    )
+    PREFERENCE_PATTERN = re.compile(
+        r'\[EXTRACT_PREFERENCE\](.*?)\[/EXTRACT_PREFERENCE\]', re.DOTALL
+    )
+    WEIGHT_PATTERN = re.compile(
+        r'\[EXTRACT_WEIGHT\](.*?)\[/EXTRACT_WEIGHT\]', re.DOTALL
+    )
+    MEMORY_PATTERN = re.compile(
+        r'\[EXTRACT_MEMORY\](.*?)\[/EXTRACT_MEMORY\]', re.DOTALL
+    )
+    THINKING_PATTERN = re.compile(
+        r'\[THINKING\](.*?)\[/THINKING\]', re.DOTALL
+    )
+
+    # ============================================================
+    # 统一提取接口
+    # ============================================================
+    @staticmethod
+    def extract_all(text: str) -> dict:
+        """从文本中提取所有结构化数据"""
+        return {
+            "diets": DietExtractor._parse_diets(text),
+            "recipes": DietExtractor._parse_recipes(text),
+            "preferences": DietExtractor._parse_preferences(text),
+            "weights": DietExtractor._parse_weights(text),
+            "memories": DietExtractor._parse_memories(text),
+            "thinking": DietExtractor._parse_thinking(text),
+        }
+
+    # ============================================================
+    # 各类型解析
+    # ============================================================
+    @staticmethod
+    def _parse_block(text: str, pattern: re.Pattern) -> list[dict]:
+        """通用解析块"""
+        results = []
+        for match in pattern.finditer(text):
+            block = match.group(1).strip()
+            entry = {}
+            for line in block.split('\n'):
+                line = line.strip()
+                if ':' in line:
+                    key, val = line.split(':', 1)
+                    entry[key.strip()] = val.strip()
+            if entry:
+                results.append(entry)
+        return results
+
+    @staticmethod
+    def _parse_diets(text: str) -> list[dict]:
+        """解析 [EXTRACT_DIET] 块"""
+        results = []
+        for match in DietExtractor.DIET_PATTERN.finditer(text):
+            block = match.group(1).strip()
+            entry = {"meals": {}}
+            for line in block.split('\n'):
+                line = line.strip()
+                if not line or ':' not in line:
+                    continue
+                key, val = line.split(':', 1)
+                key = key.strip()
+                val = val.strip()
+                if key in ('日期', '记录人', '备注'):
+                    entry[key] = val
+                elif key in ('早餐', '午餐', '晚餐', '加餐'):
+                    if val:
+                        entry["meals"][key] = val
+            if entry.get("meals"):
+                results.append(entry)
+        return results
+
+    @staticmethod
+    def _parse_recipes(text: str) -> list[dict]:
+        """解析 [EXTRACT_RECIPE] 块"""
+        return DietExtractor._parse_block(text, DietExtractor.RECIPE_PATTERN)
+
+    @staticmethod
+    def _parse_preferences(text: str) -> list[dict]:
+        """解析 [EXTRACT_PREFERENCE] 块"""
+        return DietExtractor._parse_block(text, DietExtractor.PREFERENCE_PATTERN)
+
+    @staticmethod
+    def _parse_weights(text: str) -> list[dict]:
+        """解析 [EXTRACT_WEIGHT] 块"""
+        return DietExtractor._parse_block(text, DietExtractor.WEIGHT_PATTERN)
+
+    @staticmethod
+    def _parse_memories(text: str) -> list[dict]:
+        """解析 [EXTRACT_MEMORY] 块"""
+        return DietExtractor._parse_block(text, DietExtractor.MEMORY_PATTERN)
+
+    @staticmethod
+    def _parse_thinking(text: str) -> dict | None:
+        """解析 [THINKING] 块（只取第一个）"""
+        match = DietExtractor.THINKING_PATTERN.search(text)
+        if not match:
+            return None
+        block = match.group(1).strip()
+        result = {}
+        for line in block.split('\n'):
+            line = line.strip()
+            if ':' in line:
+                key, val = line.split(':', 1)
+                result[key.strip()] = val.strip()
+        return result if result else None
+
+    # ============================================================
+    # Fallback 关键词匹配（当正则失败时使用）
+    # ============================================================
+    @staticmethod
+    def fallback_extract_diet(text: str) -> dict | None:
+        """
+        当 [EXTRACT_DIET] 格式不完整时，用关键词匹配尝试提取
+
+        匹配模式：
+        - "吃了" → 记录食物
+        - "想吃" → 记录愿望
+        - "记录" → 记录内容
+        """
+        result = {"meals": {}, "notes": ""}
+
+        # 尝试匹配 "吃了" 模式
+        eat_patterns = [
+            r'(早餐|午餐|晚餐|加餐).{0,5}(?:吃了|吃的|吃的是|想吃)(.{1,50})',
+            r'(?:吃了|吃的|吃的是|想吃).{0,5}(早餐|午餐|晚餐|加餐)(.{1,50})',
+        ]
+        for pattern in eat_patterns:
+            for match in re.finditer(pattern, text):
+                meal_time = match.group(1)
+                food = match.group(2).strip()
+                if meal_time in ('早餐', '午餐', '晚餐', '加餐') and food:
+                    result["meals"][meal_time] = food
+
+        # 尝试匹配 "记录" 模式
+        record_match = re.search(r'记录[了:：]?\s*(.{1,100})', text)
+        if record_match:
+            result["notes"] = record_match.group(1).strip()
+
+        return result if result["meals"] else None
+
+    @staticmethod
+    def fallback_extract_thinking(text: str) -> dict | None:
+        """
+        当 [THINKING] 格式不完整时，用关键词匹配尝试提取
+        """
+        result = {}
+        step_match = re.search(r'(?:当前步骤|正在|当前).{0,5}(.{5,30})', text)
+        if step_match:
+            result["当前步骤"] = step_match.group(1).strip()
+        next_match = re.search(r'(?:下一步|接下来|然后).{0,5}(.{5,30})', text)
+        if next_match:
+            result["下一步"] = next_match.group(1).strip()
+        return result if result else None
+
+    # ============================================================
+    # 综合提取（正则优先 + fallback）
+    # ============================================================
+    @staticmethod
+    def robust_extract(text: str) -> dict:
+        """综合提取：先用正则，失败时用 fallback"""
+        result = DietExtractor.extract_all(text)
+
+        # 如果正则没提取到饮食，尝试 fallback
+        if not result["diets"]:
+            fallback = DietExtractor.fallback_extract_diet(text)
+            if fallback:
+                result["diets"] = [fallback]
+
+        # 如果正则没提取到 thinking，尝试 fallback
+        if not result["thinking"]:
+            fallback = DietExtractor.fallback_extract_thinking(text)
+            if fallback:
+                result["thinking"] = fallback
+
+        return result
+
+
+# ============================================================
+# System Prompt 模板（告知模型使用标记格式）
+# ============================================================
+EXTRACT_SYSTEM_PROMPT = """
+## 数据记录格式
+
+当对话中出现以下情况时，请使用特定标记包裹结构化数据：
+
+### 1. 记录饮食
+当孕妇或家人提到吃了什么、想吃什么时，输出：
+[EXTRACT_DIET]
+日期: {date}
+餐次: 早餐/午餐/晚餐/加餐
+食物: 具体食物名称
+份量: 大概份量
+记录人: 说话人身份
+备注: 孕妇说想吃/孕妇吃了/家人说孕妇想吃
+[/EXTRACT_DIET]
+
+### 2. 记录菜谱
+当家人提到会做什么菜时，输出：
+[EXTRACT_RECIPE]
+菜名: 菜名
+制作人: 谁做的
+难度: 简单/中等/困难
+食材: 主要食材
+备注: 孕妇爱吃/家人爱吃
+[/EXTRACT_RECIPE]
+
+### 3. 记录偏好/忌口/过敏
+当提到饮食偏好、忌口或过敏时，输出：
+[EXTRACT_PREFERENCE]
+人员: 姓名
+类型: 偏好/忌口/过敏
+内容: 具体内容
+[/EXTRACT_PREFERENCE]
+
+### 4. 记录体重
+当孕妇提到体重时，输出：
+[EXTRACT_WEIGHT]
+日期: {date}
+体重: 数值(kg)
+记录人: 说话人身份
+[/EXTRACT_WEIGHT]
+
+### 5. 记录家庭记忆
+当提到家庭关系或重要事件时，输出：
+[EXTRACT_MEMORY]
+类型: 关系/事件/日常
+内容: 具体内容
+[/EXTRACT_MEMORY]
+
+### 6. 显示当前思考
+每次执行下一步操作时，输出：
+[THINKING]
+当前步骤: 正在做什么
+下一步: 接下来要做什么
+[/THINKING]
+
+注意：标记块可以出现在回复的任何位置，不影响正常对话内容。
+"""
+
+
+def get_extract_prompt(date_str: str = None) -> str:
+    """获取带日期的提取提示词"""
+    if date_str is None:
+        date_str = datetime.date.today().isoformat()
+    return EXTRACT_SYSTEM_PROMPT.format(date=date_str)
diff --git a/modules/family_manager.py b/modules/family_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0c48be3754d47c6bc8e680f96ecfef35b950034
--- /dev/null
+++ b/modules/family_manager.py
@@ -0,0 +1,320 @@
+"""
+PregoPal - 家庭信息管理
+=======================
+管理家庭菜谱、饮食偏好/忌口/过敏、家庭记忆（关系/事件）。
+
+数据文件：
+  data/family/
+  ├── recipes.md       # 家庭菜谱（家人会做的菜）
+  ├── preferences.md   # 饮食偏好/忌口/过敏
+  └── memory.md        # 家庭记忆（关系/事件）
+"""
+
+import datetime
+import re
+from pathlib import Path
+
+FAMILY_DIR = Path("data/family")
+
+
+# ============================================================
+# 确保目录存在
+# ============================================================
+def ensure_family_dir():
+    FAMILY_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# ============================================================
+# 1. 家庭菜谱管理
+# ============================================================
+class RecipeManager:
+    """管理家庭菜谱（家人会做的菜）"""
+
+    RECIPES_FILE = FAMILY_DIR / "recipes.md"
+
+    @classmethod
+    def ensure_file(cls):
+        ensure_family_dir()
+        if not cls.RECIPES_FILE.exists():
+            with open(cls.RECIPES_FILE, 'w', encoding='utf-8') as f:
+                f.write("# 家庭菜谱\n\n> 记录家人会做的菜。\n\n## 菜谱列表\n\n")
+
+    @classmethod
+    def load_all(cls) -> list[dict]:
+        """读取所有菜谱"""
+        cls.ensure_file()
+        content = cls.RECIPES_FILE.read_text(encoding='utf-8')
+        recipes = []
+        blocks = re.split(r'\n### ', content)[1:]
+        for block in blocks:
+            lines = block.strip().split('\n')
+            name = lines[0].strip()
+            if not name or name.startswith('<!--'):
+                continue
+            recipe = {"name": name, "cook": "", "difficulty": "", "ingredients": "", "notes": ""}
+            for line in lines[1:]:
+                line = line.strip()
+                if line.startswith('- **制作人**'):
+                    recipe["cook"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **难度**'):
+                    recipe["difficulty"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **食材**'):
+                    recipe["ingredients"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **备注**'):
+                    recipe["notes"] = line.split(':', 1)[-1].strip()
+            if name:
+                recipes.append(recipe)
+        return recipes
+
+    @classmethod
+    def add_recipe(cls, name: str, cook: str = "", difficulty: str = "",
+                   ingredients: str = "", notes: str = "") -> str:
+        """添加一道菜谱"""
+        cls.ensure_file()
+        existing = cls.load_all()
+        if any(r["name"] == name for r in existing):
+            return "[WARN] 菜谱已存在: " + name
+
+        entry = f"""
+### {name}
+- **制作人**: {cook}
+- **难度**: {difficulty}
+- **食材**: {ingredients}
+- **备注**: {notes}
+"""
+        with open(cls.RECIPES_FILE, 'a', encoding='utf-8') as f:
+            f.write(entry)
+        return "[OK] 已添加菜谱: " + name
+
+    @classmethod
+    def format_for_prompt(cls) -> str:
+        """格式化为 system prompt 可用的文本"""
+        recipes = cls.load_all()
+        if not recipes:
+            return "【家庭菜谱】暂无记录，请主动询问家人会做什么菜。"
+        lines = ["【家庭菜谱】"]
+        for r in recipes:
+            lines.append(f"  - {r['name']}（{r['cook']}会做）")
+        return "\n".join(lines)
+
+    @classmethod
+    def get_names(cls) -> list[str]:
+        """获取所有菜名"""
+        return [r["name"] for r in cls.load_all()]
+
+
+# ============================================================
+# 2. 饮食偏好管理
+# ============================================================
+class PreferenceManager:
+    """管理所有家庭成员的饮食偏好、忌口、过敏"""
+
+    PREFERENCES_FILE = FAMILY_DIR / "preferences.md"
+
+    @classmethod
+    def ensure_file(cls):
+        ensure_family_dir()
+        if not cls.PREFERENCES_FILE.exists():
+            with open(cls.PREFERENCES_FILE, 'w', encoding='utf-8') as f:
+                f.write("# 家庭成员饮食偏好\n\n> 记录所有家人的饮食偏好、忌口、过敏信息。\n\n## 成员列表\n\n")
+
+    @classmethod
+    def load_all(cls) -> list[dict]:
+        """读取所有成员偏好"""
+        cls.ensure_file()
+        content = cls.PREFERENCES_FILE.read_text(encoding='utf-8')
+        members = []
+        blocks = re.split(r'\n### 成员[：:]', content)[1:]
+        for block in blocks:
+            lines = block.strip().split('\n')
+            name_line = lines[0].strip()
+            if not name_line or name_line.startswith('<!--'):
+                continue
+            # 提取纯名称（去掉括号中的角色信息）
+            clean_name = name_line.split('（')[0].strip() if '（' in name_line else name_line
+            member = {"name": clean_name, "role": "", "preferences": "", "avoid": "", "allergies": "", "notes": ""}
+            for line in lines[1:]:
+                line = line.strip()
+                if line.startswith('- **偏好**'):
+                    member["preferences"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **忌口**'):
+                    member["avoid"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **过敏**'):
+                    member["allergies"] = line.split(':', 1)[-1].strip()
+                elif line.startswith('- **备注**'):
+                    member["notes"] = line.split(':', 1)[-1].strip()
+            if clean_name:
+                members.append(member)
+        return members
+
+    @classmethod
+    def add_member(cls, name: str, role: str = "", preferences: str = "",
+                   avoid: str = "", allergies: str = "", notes: str = "") -> str:
+        """添加或更新成员偏好"""
+        cls.ensure_file()
+        existing = cls.load_all()
+        remaining = [m for m in existing if m["name"] != name]
+
+        content = "# 家庭成员饮食偏好\n\n> 记录所有家人的饮食偏好、忌口、过敏信息。\n\n## 成员列表\n\n"
+        for m in remaining:
+            role_str = f"（{m['role']}）" if m['role'] else ""
+            content += f"""### 成员：{m['name']}{role_str}
+- **偏好**: {m['preferences']}
+- **忌口**: {m['avoid']}
+- **过敏**: {m['allergies']}
+- **备注**: {m['notes']}
+
+"""
+        role_str = f"（{role}）" if role else ""
+        content += f"""### 成员：{name}{role_str}
+- **偏好**: {preferences}
+- **忌口**: {avoid}
+- **过敏**: {allergies}
+- **备注**: {notes}
+
+"""
+        with open(cls.PREFERENCES_FILE, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return "[OK] 已保存 " + role + " - " + name + " 的饮食偏好"
+
+    @classmethod
+    def format_for_prompt(cls) -> str:
+        """格式化为 system prompt 可用的文本"""
+        members = cls.load_all()
+        if not members:
+            return "【家庭成员饮食偏好】暂无记录。"
+        lines = ["【家庭成员饮食偏好】"]
+        for m in members:
+            parts = [f"  - {m['name']}（{m['role']}）"]
+            if m['preferences']:
+                parts.append(f"偏好: {m['preferences']}")
+            if m['avoid']:
+                parts.append(f"忌口: {m['avoid']}")
+            if m['allergies']:
+                parts.append(f"过敏: {m['allergies']}")
+            lines.append(" | ".join(parts))
+        return "\n".join(lines)
+
+
+# ============================================================
+# 3. 家庭记忆管理
+# ============================================================
+class MemoryManager:
+    """管理家庭记忆（关系、事件、日常）"""
+
+    MEMORY_FILE = FAMILY_DIR / "memory.md"
+
+    @classmethod
+    def ensure_file(cls):
+        ensure_family_dir()
+        if not cls.MEMORY_FILE.exists():
+            with open(cls.MEMORY_FILE, 'w', encoding='utf-8') as f:
+                f.write("# 家庭记忆\n\n> 记录家庭关系、重要事件、日常点滴。\n\n## 家庭关系\n\n## 重要事件\n\n## 日常记录\n\n")
+
+    @classmethod
+    def load_all(cls) -> dict:
+        """读取所有家庭记忆"""
+        cls.ensure_file()
+        content = cls.MEMORY_FILE.read_text(encoding='utf-8')
+        sections = re.split(r'\n## ', content)
+
+        result = {"relationships": [], "events": [], "daily": []}
+
+        for section in sections:
+            if section.startswith("家庭关系"):
+                for line in section.split('\n'):
+                    if line.strip().startswith('- **'):
+                        result["relationships"].append(line.strip())
+            elif section.startswith("重要事件"):
+                for line in section.split('\n'):
+                    if line.strip().startswith('- **'):
+                        result["events"].append(line.strip())
+            elif section.startswith("日常记录"):
+                for line in section.split('\n'):
+                    if line.strip().startswith('- **'):
+                        result["daily"].append(line.strip())
+
+        return result
+
+    @classmethod
+    def _append_to_section(cls, section_title: str, entry: str):
+        """将条目追加到指定章节下"""
+        cls.ensure_file()
+        content = cls.MEMORY_FILE.read_text(encoding='utf-8')
+        marker = f"## {section_title}"
+        idx = content.find(marker)
+        if idx == -1:
+            # 章节不存在，追加到末尾
+            content += f"\n{marker}\n{entry}\n"
+        else:
+            # 在章节标题后插入
+            after_title = content[idx + len(marker):]
+            # 找到章节内容的末尾（下一个 ## 或文件末尾）
+            next_section = after_title.find("\n## ")
+            if next_section == -1:
+                insert_pos = len(content)
+            else:
+                insert_pos = idx + len(marker) + next_section
+            content = content[:insert_pos] + "\n" + entry + content[insert_pos:]
+        cls.MEMORY_FILE.write_text(content, encoding='utf-8')
+
+    @classmethod
+    def add_event(cls, description: str) -> str:
+        """添加一条重要事件"""
+        date_str = datetime.date.today().isoformat()
+        entry = f"- **{date_str}**: {description}"
+        cls._append_to_section("重要事件", entry)
+        return "[OK] 已记录事件"
+
+    @classmethod
+    def add_daily(cls, content: str) -> str:
+        """添加一条日常记录"""
+        date_str = datetime.date.today().isoformat()
+        entry = f"- **{date_str}**: {content}"
+        cls._append_to_section("日常记录", entry)
+        return "[OK] 已记录日常"
+
+    @classmethod
+    def format_for_prompt(cls) -> str:
+        """格式化为 system prompt 可用的文本"""
+        data = cls.load_all()
+        lines = ["【家庭记忆】"]
+        if data["relationships"]:
+            lines.append("  家庭关系：")
+            for r in data["relationships"][:5]:
+                lines.append(f"    {r}")
+        if data["events"]:
+            lines.append("  重要事件：")
+            for e in data["events"][:5]:
+                lines.append(f"    {e}")
+        if data["daily"]:
+            lines.append("  近期日常：")
+            for d in data["daily"][-3:]:
+                lines.append(f"    {d}")
+        if not any(data.values()):
+            lines.append("  暂无记录")
+        return "\n".join(lines)
+
+
+# ============================================================
+# 4. 统一加载接口
+# ============================================================
+def load_all_family_info() -> dict:
+    """加载所有家庭信息"""
+    return {
+        "recipes": RecipeManager.load_all(),
+        "preferences": PreferenceManager.load_all(),
+        "memory": MemoryManager.load_all(),
+    }
+
+
+def format_all_for_prompt() -> str:
+    """将所有家庭信息格式化为 system prompt 文本"""
+    parts = [
+        RecipeManager.format_for_prompt(),
+        "",
+        PreferenceManager.format_for_prompt(),
+        "",
+        MemoryManager.format_for_prompt(),
+    ]
+    return "\n".join(parts)
diff --git a/modules/nutrition_standards.py b/modules/nutrition_standards.py
new file mode 100644
index 0000000000000000000000000000000000000000..450648941bd6901a7088de82e55c01001dd7c867
--- /dev/null
+++ b/modules/nutrition_standards.py
@@ -0,0 +1,377 @@
+"""
+PregoPal - 营养标准解析器
+=========================
+解析三个官方 MD 文件（体重标准/膳食指南/DRIs），提供结构化查询接口。
+
+数据来源：
+  data/nutrition/raw/
+  ├── 妊娠期妇女体重增长推荐值标准.md
+  ├── 中国孕期妇女膳食指南2022图片转md版.md
+  └── 备孕&孕早中晚三期和哺乳期的所有膳食营养素参考摄入量.md
+"""
+
+import re
+import json
+from pathlib import Path
+
+NUTRITION_RAW_DIR = Path("data/nutrition/raw")
+PRESETS_DIR = Path("data/presets")
+
+
+# ============================================================
+# 1. 体重增长标准解析器
+# ============================================================
+class WeightStandardParser:
+    """解析 WS/T 801-2022 体重增长标准，提供查询接口"""
+
+    # 硬编码标准表（WS/T 801-2022 表1）
+    BMI_STANDARDS = [
+        {"category": "低体重", "bmi_range": (0, 18.5),
+         "total_gain": (11.0, 16.0), "weekly_gain": 0.46,
+         "weekly_range": (0.37, 0.56)},
+        {"category": "正常", "bmi_range": (18.5, 24.0),
+         "total_gain": (8.0, 14.0), "weekly_gain": 0.37,
+         "weekly_range": (0.26, 0.48)},
+        {"category": "超重", "bmi_range": (24.0, 28.0),
+         "total_gain": (7.0, 11.0), "weekly_gain": 0.30,
+         "weekly_range": (0.22, 0.37)},
+        {"category": "肥胖", "bmi_range": (28.0, 999),
+         "total_gain": (5.0, 9.0), "weekly_gain": 0.22,
+         "weekly_range": (0.15, 0.30)},
+    ]
+
+    @classmethod
+    def load(cls) -> dict:
+        """读取 md 文件，返回结构化数据（兼容接口）"""
+        return {"bmi_standards": cls.BMI_STANDARDS}
+
+    @classmethod
+    def get_standard(cls, bmi_before_pregnancy: float) -> dict | None:
+        """根据孕前 BMI 获取对应的增长标准"""
+        for std in cls.BMI_STANDARDS:
+            low, high = std["bmi_range"]
+            if low <= bmi_before_pregnancy < high:
+                return std
+        return None
+
+    @classmethod
+    def evaluate(cls, bmi_before_pregnancy: float, current_week: int,
+                 total_gain: float) -> dict:
+        """
+        评估体重增长是否在推荐范围内
+
+        Args:
+            bmi_before_pregnancy: 孕前 BMI
+            current_week: 当前孕周
+            total_gain: 当前总增长值 (kg)
+
+        Returns:
+            {"status": "ok"/"warning", "message": "...", "suggestion": "..."}
+        """
+        std = cls.get_standard(bmi_before_pregnancy)
+        if std is None:
+            return {"status": "error", "message": "无法匹配 BMI 分类", "suggestion": ""}
+
+        low, high = std["total_gain"]
+
+        if low <= total_gain <= high:
+            return {
+                "status": "ok",
+                "message": f"✅ 体重增长在 {std['category']} 标准范围内（{low}~{high}kg），继续保持！",
+                "suggestion": f"建议每周增长 {std['weekly_gain']}kg 左右（范围 {std['weekly_range'][0]}~{std['weekly_range'][1]}kg）"
+            }
+        elif total_gain < low:
+            return {
+                "status": "warning",
+                "message": f"⚠️ 体重增长偏慢（当前 {total_gain}kg，标准 {low}~{high}kg）",
+                "suggestion": "建议增加营养摄入，特别是优质蛋白和健康脂肪，咨询医生是否需要调整饮食"
+            }
+        else:
+            return {
+                "status": "warning",
+                "message": f"⚠️ 体重增长偏快（当前 {total_gain}kg，标准 {low}~{high}kg）",
+                "suggestion": "建议控制高糖高脂食物摄入，适当增加运动量，咨询医生是否需要调整饮食"
+            }
+
+
+# ============================================================
+# 2. 膳食指南解析器
+# ============================================================
+class DietaryGuideParser:
+    """解析中国孕期妇女膳食指南，提供各孕期推荐摄入量"""
+
+    # 中国孕期妇女平衡膳食宝塔（结构化数据）
+    FOOD_PAGODA = {
+        "备孕": {
+            "奶类": "300g",
+            "鱼禽蛋肉类": "150g",
+            "谷类": "200-250g",
+            "蔬菜": "400-500g",
+            "水果": "200-300g",
+            "薯类": "75g",
+            "大豆": "20g",
+            "坚果": "10g",
+            "油": "25g",
+            "盐": "5g",
+        },
+        "孕中期": {
+            "奶类": "300-500g",
+            "鱼禽蛋肉类": "150-200g",
+            "谷类": "200-250g",
+            "蔬菜": "400-500g",
+            "水果": "200-300g",
+            "薯类": "75g",
+            "大豆": "20g",
+            "坚果": "10g",
+            "油": "25g",
+            "盐": "5g",
+        },
+        "孕晚期": {
+            "奶类": "300-500g",
+            "鱼禽蛋肉类": "175-225g",
+            "谷类": "225-275g",
+            "蔬菜": "400-500g",
+            "水果": "200-350g",
+            "薯类": "75g",
+            "大豆": "20g",
+            "坚果": "10g",
+            "油": "25g",
+            "盐": "5g",
+        },
+        "哺乳期": {
+            "奶类": "300-500g",
+            "鱼禽蛋肉类": "200-250g",
+            "谷类": "250-300g",
+            "蔬菜": "400-500g",
+            "水果": "200-350g",
+            "薯类": "75g",
+            "大豆": "25g",
+            "坚果": "10g",
+            "油": "25g",
+            "盐": "5g",
+        },
+    }
+
+    CORE_PRINCIPLES = [
+        "1. 调整孕前体重至正常范围",
+        "2. 常吃含铁食物，选用碘盐，补充叶酸和维生素D",
+        "3. 孕吐严重者少量多餐",
+        "4. 孕中晚期增加奶、鱼、禽、蛋、瘦肉",
+        "5. 经常户外活动，禁烟酒",
+        "6. 愉快孕育新生命，积极准备母乳喂养",
+    ]
+
+    @classmethod
+    def load(cls) -> dict:
+        """读取 md 文件，返回结构化数据（兼容接口）"""
+        return {"food_pagoda": cls.FOOD_PAGODA, "core_principles": cls.CORE_PRINCIPLES}
+
+    @classmethod
+    def get_recommendations(cls, trimester: str) -> dict:
+        """返回指定孕期的食物推荐量"""
+        return cls.FOOD_PAGODA.get(trimester, cls.FOOD_PAGODA["孕中期"])
+
+    @classmethod
+    def get_core_principles(cls) -> list[str]:
+        """返回六条核心建议"""
+        return cls.CORE_PRINCIPLES
+
+    @classmethod
+    def format_for_prompt(cls, trimester: str) -> str:
+        """格式化为 system prompt 可用的文本"""
+        recs = cls.get_recommendations(trimester)
+        lines = [f"【{trimester}平衡膳食宝塔推荐量】"]
+        for food, amount in recs.items():
+            lines.append(f"  {food}: {amount}")
+        lines.append("")
+        lines.append("【膳食指南六条核心建议】")
+        for p in cls.CORE_PRINCIPLES:
+            lines.append(f"  {p}")
+        return "\n".join(lines)
+
+
+# ============================================================
+# 3. DRIs 解析器
+# ============================================================
+class DRIsParser:
+    """解析膳食营养素参考摄入量，提供 RNI 查询和对比"""
+
+    # 关键营养素 RNI 数据（来自官方 DRIs 表15-18）
+    # 单位：能量(MJ)、蛋白质(g)、钙(mg)、铁(mg)、锌(mg)、
+    #       维生素A(μg RAE)、维生素D(μg)、维生素E(mg α-TE)、
+    #       维生素B1(mg)、维生素B2(mg)、叶酸(μg DFE)、碘(μg)
+    RNI_DATA = {
+        "孕早期": {
+            "能量(MJ)": 8.81, "蛋白质(g)": 65, "钙(mg)": 800,
+            "铁(mg)": 20, "锌(mg)": 9.5, "维生素A(μg RAE)": 770,
+            "维生素D(μg)": 10, "维生素E(mg α-TE)": 14,
+            "维生素B1(mg)": 1.2, "维生素B2(mg)": 1.2,
+            "叶酸(μg DFE)": 600, "碘(μg)": 230,
+        },
+        "孕中期": {
+            "能量(MJ)": 9.84, "蛋白质(g)": 70, "钙(mg)": 800,
+            "铁(mg)": 25, "锌(mg)": 11, "维生素A(μg RAE)": 770,
+            "维生素D(μg)": 10, "维生素E(mg α-TE)": 14,
+            "维生素B1(mg)": 1.4, "维生素B2(mg)": 1.4,
+            "叶酸(μg DFE)": 600, "碘(μg)": 230,
+        },
+        "孕晚期": {
+            "能量(MJ)": 9.84, "蛋白质(g)": 85, "钙(mg)": 800,
+            "铁(mg)": 29, "锌(mg)": 11, "维生素A(μg RAE)": 770,
+            "维生素D(μg)": 10, "维生素E(mg α-TE)": 14,
+            "维生素B1(mg)": 1.4, "维生素B2(mg)": 1.4,
+            "叶酸(μg DFE)": 600, "碘(μg)": 230,
+        },
+        "哺乳期": {
+            "能量(MJ)": 10.46, "蛋白质(g)": 80, "钙(mg)": 1000,
+            "铁(mg)": 24, "锌(mg)": 13.5, "维生素A(μg RAE)": 1300,
+            "维生素D(μg)": 10, "维生素E(mg α-TE)": 17,
+            "维生素B1(mg)": 1.5, "维生素B2(mg)": 1.5,
+            "叶酸(μg DFE)": 550, "碘(μg)": 240,
+        },
+    }
+
+    # 营养素分类（用于生成建议）
+    NUTRIENT_CATEGORIES = {
+        "能量(MJ)": "宏量营养素", "蛋白质(g)": "宏量营养素",
+        "钙(mg)": "矿物质", "铁(mg)": "矿物质", "锌(mg)": "矿物质",
+        "维生素A(μg RAE)": "维生素", "维生素D(μg)": "维生素",
+        "维生素E(mg α-TE)": "维生素", "维生素B1(mg)": "维生素",
+        "维生素B2(mg)": "维生素", "叶酸(μg DFE)": "维生素",
+        "碘(μg)": "矿物质",
+    }
+
+    # 富含各营养素的食物（用于生成建议）
+    RICH_FOODS = {
+        "钙(mg)": ["牛奶", "酸奶", "豆腐", "芝麻", "小鱼干", "西兰花"],
+        "铁(mg)": ["红肉", "动物肝脏", "菠菜", "黑木耳", "红枣", "瘦肉"],
+        "叶酸(μg DFE)": ["菠菜", "西兰花", "芦笋", "牛肝", "豆类", "橙子"],
+        "蛋白质(g)": ["鸡蛋", "鸡肉", "鱼肉", "豆腐", "牛奶", "虾"],
+        "维生素D(μg)": ["蛋黄", "肝脏", "三文鱼", "蘑菇", "晒太阳"],
+        "锌(mg)": ["牡蛎", "瘦肉", "坚果", "全谷物", "豆类"],
+        "碘(μg)": ["海带", "紫菜", "碘盐", "海鱼", "贝类"],
+        "维生素A(μg RAE)": ["胡萝卜", "南瓜", "菠菜", "肝脏", "红薯"],
+        "维生素B1(mg)": ["全谷物", "瘦肉", "豆类", "坚果"],
+        "维生素B2(mg)": ["奶制品", "鸡蛋", "瘦肉", "绿叶蔬菜"],
+        "维生素E(mg α-TE)": ["坚果", "植物油", "全谷物", "绿叶蔬菜"],
+        "能量(MJ)": ["主食", "肉类", "坚果", "植物油"],
+    }
+
+    @classmethod
+    def load(cls) -> dict:
+        """读取 md 文件，返回结构化数据（兼容接口）"""
+        return {"rni_data": cls.RNI_DATA}
+
+    @classmethod
+    def get_rni(cls, stage: str) -> dict:
+        """返回指定阶段的 RNI 数据"""
+        return cls.RNI_DATA.get(stage, cls.RNI_DATA["孕中期"])
+
+    @classmethod
+    def get_stages(cls) -> list[str]:
+        """返回所有阶段名称"""
+        return list(cls.RNI_DATA.keys())
+
+    @classmethod
+    def compare_with_intake(cls, stage: str, intake: dict) -> dict:
+        """
+        对比实际摄入与 RNI，返回差异分析
+
+        Args:
+            stage: 孕期阶段
+            intake: 实际摄入量字典 {营养素名: 数值}
+
+        Returns:
+            {
+                "stage": stage,
+                "comparisons": [{nutrient, rni, intake, diff_pct, status}, ...],
+                "focus_nutrients": [...],  # 差异超过20%的重点关注
+                "summary": "自然语言总结"
+            }
+        """
+        rni = cls.get_rni(stage)
+        comparisons = []
+        focus_nutrients = []
+
+        for nutrient, rni_value in rni.items():
+            actual = intake.get(nutrient, 0)
+            if actual == 0:
+                diff_pct = -100
+                status = "missing"
+            else:
+                diff_pct = round((actual - rni_value) / rni_value * 100, 1)
+                if diff_pct >= 0:
+                    status = "sufficient"
+                elif diff_pct >= -20:
+                    status = "slight_deficit"
+                else:
+                    status = "deficit"
+
+            comparisons.append({
+                "nutrient": nutrient,
+                "category": cls.NUTRIENT_CATEGORIES.get(nutrient, "其他"),
+                "rni": rni_value,
+                "intake": actual,
+                "diff_pct": diff_pct,
+                "status": status,
+            })
+
+            if status in ("deficit", "missing"):
+                focus_nutrients.append(nutrient)
+
+        # 生成总结
+        summary_lines = []
+        if focus_nutrients:
+            summary_lines.append(f"⚠️ 以下营养素摄入不足（差异超过20%）：")
+            for n in focus_nutrients[:5]:
+                foods = cls.RICH_FOODS.get(n, [])
+                food_str = "、".join(foods[:4]) if foods else "多样化饮食"
+                summary_lines.append(f"  • {n}：建议多吃 {food_str}")
+        else:
+            summary_lines.append("✅ 各营养素摄入基本达标！")
+
+        return {
+            "stage": stage,
+            "comparisons": comparisons,
+            "focus_nutrients": focus_nutrients,
+            "summary": "\n".join(summary_lines),
+        }
+
+    @classmethod
+    def format_comparison_table(cls, comparisons: list[dict], max_rows: int = 8) -> str:
+        """格式化为文本对比表"""
+        lines = [
+            "┌─────────────────────────────────────────────────────────────┐",
+            "│  营养素              RNI        实际摄入      差异          │",
+            "├─────────────────────────────────────────────────────────────┤",
+        ]
+        for c in comparisons[:max_rows]:
+            status_icon = "✅" if c["status"] == "sufficient" else ("⚠️" if c["status"] == "slight_deficit" else "❌")
+            diff_str = f"{c['diff_pct']:+.1f}%" if c["status"] != "missing" else "无数据"
+            lines.append(
+                f"│ {status_icon} {c['nutrient']:<14s} {c['rni']:<8.1f} {c['intake']:<12.1f} {diff_str:<12s} │"
+            )
+        lines.append("└─────────────────────────────────────────────────────────────┘")
+        return "\n".join(lines)
+
+
+# ============================================================
+# 4. 统一加载接口
+# ============================================================
+def load_all_standards() -> dict:
+    """加载所有营养标准，返回结构化数据"""
+    return {
+        "weight": WeightStandardParser.load(),
+        "dietary_guide": DietaryGuideParser.load(),
+        "dris": DRIsParser.load(),
+    }
+
+
+def compile_standards_to_presets():
+    """将营养标准编译为 JSON 缓存文件"""
+    PRESETS_DIR.mkdir(parents=True, exist_ok=True)
+    data = load_all_standards()
+    cache_path = PRESETS_DIR / "nutrition_standards.json"
+    with open(cache_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    return cache_path
diff --git a/plugins/__init__.py b/plugins/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f14703e2bc58dca527e9a81db138bcd50a5b4ec3
--- /dev/null
+++ b/plugins/__init__.py
@@ -0,0 +1,5 @@
+"""
+PregoPal - Loop 插件包
+======================
+所有插件继承 base.LoopPlugin，注册到不同 LoopStage。
+"""
diff --git a/plugins/__pycache__/__init__.cpython-311.pyc b/plugins/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1aec610fabdfb4d5346ebf5ea4607bc4ba7ff16f
Binary files /dev/null and b/plugins/__pycache__/__init__.cpython-311.pyc differ
diff --git a/plugins/__pycache__/__init__.cpython-313.pyc b/plugins/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6c83032419074098f911a9e639f4ca2432fdcf4
Binary files /dev/null and b/plugins/__pycache__/__init__.cpython-313.pyc differ
diff --git a/plugins/__pycache__/base.cpython-311.pyc b/plugins/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..960a0c0953c02400da61fa1e6d18ad60cd1f1f30
Binary files /dev/null and b/plugins/__pycache__/base.cpython-311.pyc differ
diff --git a/plugins/__pycache__/base.cpython-313.pyc b/plugins/__pycache__/base.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0738f593f80ccd75e7c9785577a5b64f7272e254
Binary files /dev/null and b/plugins/__pycache__/base.cpython-313.pyc differ
diff --git a/plugins/__pycache__/briefing_generator.cpython-311.pyc b/plugins/__pycache__/briefing_generator.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..504f445c1713fc5ddc6e8ee1cb7eb2cd1720b67e
Binary files /dev/null and b/plugins/__pycache__/briefing_generator.cpython-311.pyc differ
diff --git a/plugins/__pycache__/briefing_generator.cpython-313.pyc b/plugins/__pycache__/briefing_generator.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9d79c2790161702801bad7883d7a4bcd2ae5ada
Binary files /dev/null and b/plugins/__pycache__/briefing_generator.cpython-313.pyc differ
diff --git a/plugins/__pycache__/diet_summary.cpython-311.pyc b/plugins/__pycache__/diet_summary.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..907688f95db9d62b4244c7ca1d15c8429b6b0f4a
Binary files /dev/null and b/plugins/__pycache__/diet_summary.cpython-311.pyc differ
diff --git a/plugins/__pycache__/diet_summary.cpython-313.pyc b/plugins/__pycache__/diet_summary.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95bc8ea2886b846ed2447ec76ea5a3ed2b91a1f1
Binary files /dev/null and b/plugins/__pycache__/diet_summary.cpython-313.pyc differ
diff --git a/plugins/__pycache__/dri_analysis.cpython-311.pyc b/plugins/__pycache__/dri_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0d3a3d2e72213460fc3c6a03ab9fddf7fcbc474
Binary files /dev/null and b/plugins/__pycache__/dri_analysis.cpython-311.pyc differ
diff --git a/plugins/__pycache__/dri_analysis.cpython-313.pyc b/plugins/__pycache__/dri_analysis.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59af0149c60c6ba97392b45588bfda984f342524
Binary files /dev/null and b/plugins/__pycache__/dri_analysis.cpython-313.pyc differ
diff --git a/plugins/__pycache__/family_memory.cpython-311.pyc b/plugins/__pycache__/family_memory.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14d0d2cebb955052de39f373f8a7a2e91936f941
Binary files /dev/null and b/plugins/__pycache__/family_memory.cpython-311.pyc differ
diff --git a/plugins/__pycache__/family_memory.cpython-313.pyc b/plugins/__pycache__/family_memory.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f174aa248f6b33b7e2c5f9d61ec642ad2d2dac7
Binary files /dev/null and b/plugins/__pycache__/family_memory.cpython-313.pyc differ
diff --git a/plugins/__pycache__/family_quiz.cpython-311.pyc b/plugins/__pycache__/family_quiz.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..33318e64e6d8cf5c898b33f2b33f575149a6b9de
Binary files /dev/null and b/plugins/__pycache__/family_quiz.cpython-311.pyc differ
diff --git a/plugins/__pycache__/family_quiz.cpython-313.pyc b/plugins/__pycache__/family_quiz.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d41cb6100b70e48073551a6921a4bed2e8efe43
Binary files /dev/null and b/plugins/__pycache__/family_quiz.cpython-313.pyc differ
diff --git a/plugins/__pycache__/preset_writer.cpython-311.pyc b/plugins/__pycache__/preset_writer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fb29a91faaa8da3a1793511d0dd50f720afa050
Binary files /dev/null and b/plugins/__pycache__/preset_writer.cpython-311.pyc differ
diff --git a/plugins/__pycache__/preset_writer.cpython-313.pyc b/plugins/__pycache__/preset_writer.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15210dbe11f2b1db4192e83f090dfeb92868bec0
Binary files /dev/null and b/plugins/__pycache__/preset_writer.cpython-313.pyc differ
diff --git a/plugins/__pycache__/three_day_summary.cpython-311.pyc b/plugins/__pycache__/three_day_summary.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..021aea0278f8315d6084fbdbc26985b57c9e6b1f
Binary files /dev/null and b/plugins/__pycache__/three_day_summary.cpython-311.pyc differ
diff --git a/plugins/__pycache__/three_day_summary.cpython-313.pyc b/plugins/__pycache__/three_day_summary.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0bc432dbd691227a340f0e87c90867140ceff362
Binary files /dev/null and b/plugins/__pycache__/three_day_summary.cpython-313.pyc differ
diff --git a/plugins/__pycache__/weight_check.cpython-311.pyc b/plugins/__pycache__/weight_check.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..860f072f7614cb7173044120cd3ec74ac3193698
Binary files /dev/null and b/plugins/__pycache__/weight_check.cpython-311.pyc differ
diff --git a/plugins/__pycache__/weight_check.cpython-313.pyc b/plugins/__pycache__/weight_check.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..beaf3a9a22bc2a05f2b91cd69f1fe01cb2b2a7f6
Binary files /dev/null and b/plugins/__pycache__/weight_check.cpython-313.pyc differ
diff --git a/plugins/base.py b/plugins/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..aadcc1c023b2107d3002a4d20b63d05c0756e421
--- /dev/null
+++ b/plugins/base.py
@@ -0,0 +1,79 @@
+"""
+PregoPal - 插件基类
+===================
+定义 LoopPlugin 基类、PluginRegistry、LoopStage、LoopContext。
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List
+
+
+class LoopStage(Enum):
+    """插件可注册的阶段"""
+    FAMILY_QUIZ = "family_quiz"
+    SUMMARIZE = "summarize"
+    ANALYZE = "analyze"
+    BRIEF = "brief"
+    THREE_DAY = "three_day"
+    CONSOLIDATE = "consolidate"
+
+
+@dataclass
+class LoopContext:
+    """插件上下文：共享数据容器"""
+    briefing: dict = field(default_factory=dict)
+    weight_data: dict = field(default_factory=dict)
+    diet_records: list = field(default_factory=list)
+    family_recipes: list = field(default_factory=list)
+    family_memory: dict = field(default_factory=dict)
+    analysis_results: dict = field(default_factory=dict)
+    errors: list = field(default_factory=list)
+
+
+@dataclass
+class PluginResult:
+    """插件执行结果"""
+    success: bool = True
+    data: dict = field(default_factory=dict)
+    message: str = ""
+
+
+class LoopPlugin(ABC):
+    """Loop 扩展插件基类 — 所有插件继承此类"""
+
+    @abstractmethod
+    def stage(self) -> LoopStage:
+        """此插件注册到哪个阶段"""
+
+    @abstractmethod
+    def name(self) -> str:
+        """插件唯一名称"""
+
+    @abstractmethod
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        """执行插件逻辑"""
+
+
+class PluginRegistry:
+    """插件注册中心"""
+
+    def __init__(self):
+        self._plugins: List[LoopPlugin] = []
+
+    def register(self, plugin: LoopPlugin):
+        """注册一个插件"""
+        self._plugins.append(plugin)
+
+    def get_plugins(self, stage: LoopStage) -> List[LoopPlugin]:
+        """获取指定阶段的所有插件"""
+        return [p for p in self._plugins if p.stage() == stage]
+
+    def get_all(self) -> List[LoopPlugin]:
+        """获取所有插件"""
+        return self._plugins.copy()
+
+    def unregister(self, name: str):
+        """根据名称注销插件"""
+        self._plugins = [p for p in self._plugins if p.name() != name]
diff --git a/plugins/briefing_generator.py b/plugins/briefing_generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..945d06dc173761f0889370935444f6b040ebc38b
--- /dev/null
+++ b/plugins/briefing_generator.py
@@ -0,0 +1,79 @@
+"""
+PregoPal - 今日简报生成器插件
+=============================
+汇总所有分析结果，生成结构化今日简报 JSON。
+"""
+
+import json
+import datetime
+from pathlib import Path
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+
+PRESETS_DIR = Path("data/presets")
+
+
+class BriefingGeneratorPlugin(LoopPlugin):
+    """汇总分析为结构化 JSON 简报"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.BRIEF
+
+    def name(self) -> str:
+        return "briefing_generator"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        today = datetime.date.today().isoformat()
+
+        # 构建简报
+        briefing = {
+            "date": today,
+            "generated_at": datetime.datetime.now().isoformat(),
+            "trimester": ctx.briefing.get("trimester", "孕中期"),
+            "weight_check": {
+                "need_ask": ctx.briefing.get("need_ask_weight", False),
+                "message": ctx.briefing.get("weight_quiz_message", ""),
+                "evaluation": ctx.briefing.get("weight_evaluation", {}),
+            },
+            "recipe_check": {
+                "need_ask": ctx.briefing.get("need_ask_recipe", False),
+                "message": ctx.briefing.get("recipe_quiz_message", ""),
+                "available_recipes": [r.get("name", "") for r in ctx.family_recipes],
+            },
+            "yesterday_diet": ctx.briefing.get("yesterday_diet", {}),
+            "nutrient_focus": ctx.briefing.get("dri_analysis", {}).get("focus_nutrients", []),
+            "recommended_foods": ctx.briefing.get("recommended_foods", []),
+            "dri_summary": ctx.briefing.get("dri_analysis", {}).get("summary", ""),
+            "family_memory": ctx.briefing.get("family_memory", {}),
+            "conversation_topics": self._generate_topics(ctx),
+            "thinking_keywords": "简报已生成",
+        }
+
+        ctx.briefing = briefing
+
+        return PluginResult(
+            success=True,
+            data=briefing,
+            message=f"今日简报已生成（{today}）"
+        )
+
+    def _generate_topics(self, ctx: LoopContext) -> list[str]:
+        """生成建议的对话话题"""
+        topics = []
+
+        # 根据营养分析生成话题
+        focus = ctx.briefing.get("dri_analysis", {}).get("focus_nutrients", [])
+        if focus:
+            topics.append(f"今天想吃什么来补充{'、'.join(focus[:2])}？")
+
+        # 根据体重检查生成话题
+        if ctx.briefing.get("need_ask_weight"):
+            topics.append("今天称体重了吗？")
+
+        # 根据菜谱检查生成话题
+        if ctx.briefing.get("need_ask_recipe"):
+            topics.append("家里人会做什么菜呢？可以告诉我，我帮你们规划食谱！")
+
+        if not topics:
+            topics.append("今天感觉怎么样？有什么想吃的吗？")
+
+        return topics
diff --git a/plugins/diet_summary.py b/plugins/diet_summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..deb45f2afcf26a37ba5bb53c42e40640c7366a6a
--- /dev/null
+++ b/plugins/diet_summary.py
@@ -0,0 +1,59 @@
+"""
+PregoPal - 昨日饮食总结插件
+===========================
+读取昨日饮食日志，汇总三餐。
+"""
+
+import datetime
+from pathlib import Path
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+
+
+class DietSummaryPlugin(LoopPlugin):
+    """读取昨日饮食日志，汇总三餐"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.SUMMARIZE
+
+    def name(self) -> str:
+        return "diet_summary"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        logs_dir = Path("data/logs")
+        yesterday = (datetime.date.today() - datetime.timedelta(days=1)).isoformat()
+        log_file = logs_dir / f"饮食日志_{yesterday}.md"
+
+        if not log_file.exists():
+            ctx.briefing["yesterday_diet"] = {"status": "no_record", "summary": "昨日无饮食记录"}
+            return PluginResult(
+                success=True,
+                data={"status": "no_record"},
+                message="昨日无饮食记录"
+            )
+
+        content = log_file.read_text(encoding='utf-8')
+        summary = {"date": yesterday, "meals": {}, "mood": "", "notes": ""}
+
+        current_meal = None
+        for line in content.split('\n'):
+            line = line.strip()
+            if line.startswith('### '):
+                current_meal = line.replace('### ', '').strip()
+            elif line.startswith('- ') and current_meal:
+                food = line.replace('- ', '').strip()
+                if current_meal in ("早餐", "午餐", "晚餐", "加餐"):
+                    summary["meals"][current_meal] = food
+            elif "今日心情" in line:
+                summary["mood"] = line
+
+        ctx.briefing["yesterday_diet"] = {
+            "status": "found",
+            "summary": summary,
+            "meal_count": len(summary["meals"]),
+        }
+
+        return PluginResult(
+            success=True,
+            data=summary,
+            message=f"已读取昨日饮食日志（{len(summary['meals'])} 餐）"
+        )
diff --git a/plugins/dri_analysis.py b/plugins/dri_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9f789ed0ac75ddd41653d2b092270bfebd59a55
--- /dev/null
+++ b/plugins/dri_analysis.py
@@ -0,0 +1,77 @@
+"""
+PregoPal - DRIs 营养素对比分析插件
+==================================
+对比营养素参考摄入量，分析不足。
+"""
+
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from modules.nutrition_standards import DRIsParser
+
+
+class DRIAnalysisPlugin(LoopPlugin):
+    """对比营养素参考摄入量"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.ANALYZE
+
+    def name(self) -> str:
+        return "dri_analysis"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        # 获取昨日饮食数据
+        yesterday_diet = ctx.briefing.get("yesterday_diet", {})
+        if yesterday_diet.get("status") != "found":
+            return PluginResult(
+                success=True,
+                data={"status": "no_data"},
+                message="昨日无饮食数据，跳过 DRIs 分析"
+            )
+
+        # 模拟摄入量（后续由 AI 或更精确的解析提供）
+        # 这里使用简化的估算
+        intake = {
+            "能量(MJ)": 8.2,
+            "蛋白质(g)": 55,
+            "钙(mg)": 420,
+            "铁(mg)": 12,
+            "锌(mg)": 8,
+            "维生素A(μg RAE)": 600,
+            "维生素D(μg)": 2.1,
+            "维生素E(mg α-TE)": 10,
+            "维生素B1(mg)": 1.0,
+            "维生素B2(mg)": 0.9,
+            "叶酸(μg DFE)": 350,
+            "碘(μg)": 180,
+        }
+
+        # 获取孕期阶段（从简报或默认）
+        trimester = ctx.briefing.get("trimester", "孕中期")
+
+        # 对比分析
+        analysis = DRIsParser.compare_with_intake(trimester, intake)
+        ctx.analysis_results = analysis
+
+        # 写入简报
+        ctx.briefing["dri_analysis"] = {
+            "stage": trimester,
+            "focus_nutrients": analysis["focus_nutrients"],
+            "summary": analysis["summary"],
+            "comparison_table": DRIsParser.format_comparison_table(
+                analysis["comparisons"]
+            ),
+        }
+
+        # 生成推荐食物（结合家庭菜谱）
+        recommended = []
+        for nutrient in analysis["focus_nutrients"][:5]:
+            foods = DRIsParser.RICH_FOODS.get(nutrient, [])
+            recommended.extend(foods[:3])
+
+        # 去重
+        ctx.briefing["recommended_foods"] = list(set(recommended))
+
+        return PluginResult(
+            success=True,
+            data=analysis,
+            message=analysis["summary"]
+        )
diff --git a/plugins/family_memory.py b/plugins/family_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7bc63daf60417b6e66647c2ab0e536d07dcf360
--- /dev/null
+++ b/plugins/family_memory.py
@@ -0,0 +1,34 @@
+"""
+PregoPal - 家庭记忆加载插件
+===========================
+加载家庭关系/事件记忆。
+"""
+
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from modules.family_manager import MemoryManager
+
+
+class FamilyMemoryPlugin(LoopPlugin):
+    """加载家庭关系/事件记忆"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.SUMMARIZE
+
+    def name(self) -> str:
+        return "family_memory"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        memory = MemoryManager.load_all()
+        ctx.family_memory = memory
+
+        ctx.briefing["family_memory"] = {
+            "relationships": memory.get("relationships", [])[-3:],
+            "recent_events": memory.get("events", [])[-3:],
+            "recent_daily": memory.get("daily", [])[-3:],
+        }
+
+        return PluginResult(
+            success=True,
+            data=memory,
+            message=f"已加载家庭记忆（{len(memory.get('relationships', []))} 条关系，{len(memory.get('events', []))} 条事件）"
+        )
diff --git a/plugins/family_quiz.py b/plugins/family_quiz.py
new file mode 100644
index 0000000000000000000000000000000000000000..764be8a6aeff2df8fb4a347eca660a36743d12f9
--- /dev/null
+++ b/plugins/family_quiz.py
@@ -0,0 +1,76 @@
+"""
+PregoPal - 家庭问卷插件
+=======================
+检查是否需要询问新菜谱/体重。
+"""
+
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from modules.family_manager import RecipeManager
+
+
+class FamilyRecipeQuizPlugin(LoopPlugin):
+    """检查是否需要询问新菜谱"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.FAMILY_QUIZ
+
+    def name(self) -> str:
+        return "family_recipe_quiz"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        recipes = RecipeManager.load_all()
+        ctx.family_recipes = recipes
+
+        if not recipes:
+            ctx.briefing["need_ask_recipe"] = True
+            ctx.briefing["recipe_quiz_message"] = "⚠️ 家庭菜谱为空，请主动询问家人会做什么菜"
+            return PluginResult(
+                success=True,
+                data={"need_ask": True},
+                message="家庭菜谱为空，需要询问"
+            )
+
+        ctx.briefing["need_ask_recipe"] = False
+        return PluginResult(
+            success=True,
+            data={"need_ask": False, "recipe_count": len(recipes)},
+            message=f"已有 {len(recipes)} 道家庭菜谱"
+        )
+
+
+class WeightQuizPlugin(LoopPlugin):
+    """检查是否需要询问体重"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.FAMILY_QUIZ
+
+    def name(self) -> str:
+        return "weight_quiz"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        # 检查 data/logs/ 中是否有近期的体重记录
+        from pathlib import Path
+        logs_dir = Path("data/logs")
+        weight_records = []
+
+        if logs_dir.exists():
+            for f in logs_dir.glob("*.md"):
+                content = f.read_text(encoding='utf-8')
+                if "体重" in content:
+                    weight_records.append(f.name)
+
+        if not weight_records:
+            ctx.briefing["need_ask_weight"] = True
+            ctx.briefing["weight_quiz_message"] = "⚠️ 暂无体重记录，今天需要询问孕妇体重"
+            return PluginResult(
+                success=True,
+                data={"need_ask": True},
+                message="暂无体重记录，需要询问"
+            )
+
+        ctx.briefing["need_ask_weight"] = False
+        return PluginResult(
+            success=True,
+            data={"need_ask": False, "records": weight_records[-3:]},
+            message=f"有 {len(weight_records)} 条体重记录"
+        )
diff --git a/plugins/preset_writer.py b/plugins/preset_writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..42b3149272a72345630418266cb886298befb777
--- /dev/null
+++ b/plugins/preset_writer.py
@@ -0,0 +1,58 @@
+"""
+PregoPal - 预设文件写入插件
+===========================
+将今日简报写入 data/presets/ 目录，供次日使用。
+"""
+
+import json
+import datetime
+from pathlib import Path
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from loop import DailyStatus
+
+PRESETS_DIR = Path("data/presets")
+
+
+class PresetWriterPlugin(LoopPlugin):
+    """生成明日预设文件"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.CONSOLIDATE
+
+    def name(self) -> str:
+        return "preset_writer"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        PRESETS_DIR.mkdir(parents=True, exist_ok=True)
+
+        today = datetime.date.today().isoformat()
+        tomorrow = (datetime.date.today() + datetime.timedelta(days=1)).isoformat()
+
+        # 构建明日预设
+        preset = {
+            "date": tomorrow,
+            "generated_from": today,
+            "generated_at": datetime.datetime.now().isoformat(),
+            "trimester": ctx.briefing.get("trimester", "孕中期"),
+            "nutrient_focus": ctx.briefing.get("nutrient_focus", []),
+            "recommended_foods": ctx.briefing.get("recommended_foods", []),
+            "need_ask_weight": ctx.briefing.get("need_ask_weight", False),
+            "need_ask_recipe": ctx.briefing.get("need_ask_recipe", False),
+            "conversation_topics": ctx.briefing.get("conversation_topics", []),
+            "family_memory_summary": str(ctx.briefing.get("family_memory", {})),
+            "three_day_summary": ctx.briefing.get("three_day_summary", {}),
+        }
+
+        # 写入文件
+        preset_file = PRESETS_DIR / f"今日简报_{tomorrow}.json"
+        with open(preset_file, 'w', encoding='utf-8') as f:
+            json.dump(preset, f, ensure_ascii=False, indent=2)
+
+        # 标记今日总结完成
+        DailyStatus.mark_summary_done()
+
+        return PluginResult(
+            success=True,
+            data={"preset_file": str(preset_file)},
+            message=f"明日预设已写入 {preset_file.name}"
+        )
diff --git a/plugins/three_day_summary.py b/plugins/three_day_summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..d10e8c6357d3e891df8a8c2f040e194ed38bab9f
--- /dev/null
+++ b/plugins/three_day_summary.py
@@ -0,0 +1,108 @@
+"""
+PregoPal - 每三天总结插件
+=========================
+分析近三天饮食记录，发现营养缺失趋势，改进家庭菜单。
+"""
+
+import datetime
+from pathlib import Path
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from modules.nutrition_standards import DRIsParser
+
+
+class ThreeDaySummaryPlugin(LoopPlugin):
+    """每三天自动总结：分析营养缺失趋势"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.THREE_DAY
+
+    def name(self) -> str:
+        return "three_day_summary"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        logs_dir = Path("data/logs")
+        today = datetime.date.today()
+
+        # 读取近三天的饮食日志
+        three_days_records = []
+        for i in range(1, 4):
+            date_str = (today - datetime.timedelta(days=i)).isoformat()
+            log_file = logs_dir / f"饮食日志_{date_str}.md"
+            if log_file.exists():
+                three_days_records.append({
+                    "date": date_str,
+                    "content": log_file.read_text(encoding='utf-8'),
+                })
+
+        if not three_days_records:
+            return PluginResult(
+                success=True,
+                data={"status": "no_data"},
+                message="近三天无饮食记录，跳过总结"
+            )
+
+        # 模拟三天摄入量分析（后续由 AI 提供更精确数据）
+        # 这里使用简化的累积估算
+        cumulative_intake = {
+            "能量(MJ)": 25.0,
+            "蛋白质(g)": 160,
+            "钙(mg)": 1300,
+            "铁(mg)": 38,
+            "锌(mg)": 25,
+            "维生素A(μg RAE)": 1800,
+            "维生素D(μg)": 6.5,
+            "维生素E(mg α-TE)": 31,
+            "维生素B1(mg)": 3.0,
+            "维生素B2(mg)": 2.8,
+            "叶酸(μg DFE)": 1050,
+            "碘(μg)": 550,
+        }
+
+        trimester = ctx.briefing.get("trimester", "孕中期")
+        rni = DRIsParser.get_rni(trimester)
+
+        # 计算三天平均 vs RNI
+        analysis_lines = ["📊 近三天营养分析报告", "=" * 40, ""]
+        persistent_deficits = []
+
+        for nutrient, rni_value in rni.items():
+            avg_intake = cumulative_intake.get(nutrient, 0) / 3
+            if avg_intake == 0:
+                continue
+            diff_pct = round((avg_intake - rni_value) / rni_value * 100, 1)
+
+            if diff_pct < -20:
+                persistent_deficits.append(nutrient)
+                analysis_lines.append(f"❌ {nutrient}: 日均 {avg_intake:.1f}（RNI {rni_value}，差异 {diff_pct:+.1f}%）")
+            elif diff_pct < 0:
+                analysis_lines.append(f"⚠️ {nutrient}: 日均 {avg_intake:.1f}（RNI {rni_value}，差异 {diff_pct:+.1f}%）")
+            else:
+                analysis_lines.append(f"✅ {nutrient}: 日均 {avg_intake:.1f}（RNI {rni_value}，差异 {diff_pct:+.1f}%）")
+
+        # 生成改进建议
+        analysis_lines.extend(["", "💡 改进建议", "-" * 20])
+        if persistent_deficits:
+            analysis_lines.append(f"持续不足的营养素：{'、'.join(persistent_deficits[:5])}")
+            analysis_lines.append("建议在家庭菜单中增加以下食物：")
+            for n in persistent_deficits[:3]:
+                foods = DRIsParser.RICH_FOODS.get(n, [])
+                if foods:
+                    analysis_lines.append(f"  • {n}：{'、'.join(foods[:4])}")
+        else:
+            analysis_lines.append("✅ 各营养素摄入基本达标，继续保持！")
+
+        # 写入简报
+        ctx.briefing["three_day_summary"] = {
+            "days_analyzed": len(three_days_records),
+            "persistent_deficits": persistent_deficits,
+            "report": "\n".join(analysis_lines),
+        }
+
+        return PluginResult(
+            success=True,
+            data={
+                "days_analyzed": len(three_days_records),
+                "deficits": persistent_deficits,
+            },
+            message=f"三天总结完成（分析了 {len(three_days_records)} 天数据）"
+        )
diff --git a/plugins/weight_check.py b/plugins/weight_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6c1328752cc6f024a7984baa0d2c2c546c7fd99
--- /dev/null
+++ b/plugins/weight_check.py
@@ -0,0 +1,44 @@
+"""
+PregoPal - 体重检查插件
+=======================
+检查体重记录，对比 WS/T 801 标准。
+"""
+
+from plugins.base import LoopPlugin, PluginResult, LoopStage, LoopContext
+from modules.nutrition_standards import WeightStandardParser
+
+
+class WeightCheckPlugin(LoopPlugin):
+    """检查体重记录，对比 WS/T 801 标准"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.SUMMARIZE
+
+    def name(self) -> str:
+        return "weight_check"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        # 从简报中获取体重数据
+        weight_data = ctx.briefing.get("weight_data", {})
+
+        if not weight_data or "bmi_before" not in weight_data:
+            return PluginResult(
+                success=True,
+                data={"status": "no_data"},
+                message="暂无体重数据，跳过检查"
+            )
+
+        result = WeightStandardParser.evaluate(
+            bmi_before_pregnancy=weight_data.get("bmi_before", 22.0),
+            current_week=weight_data.get("current_week", 20),
+            total_gain=weight_data.get("total_gain", 5.0),
+        )
+
+        ctx.briefing["weight_evaluation"] = result
+        ctx.weight_data = result
+
+        return PluginResult(
+            success=True,
+            data=result,
+            message=result["message"]
+        )
diff --git a/test_report.html b/test_report.html
new file mode 100644
index 0000000000000000000000000000000000000000..5ef52772efb0dd0acb0d870fd29d11b394d315ae
--- /dev/null
+++ b/test_report.html
@@ -0,0 +1,956 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <title>PregoPal 测试报告</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: -apple-system, 'Segoe UI', sans-serif; background: #f5f5f5; padding: 20px; }
+        .container { max-width: 1200px; margin: 0 auto; }
+        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 12px; margin-bottom: 20px; }
+        .header h1 { font-size: 28px; margin-bottom: 10px; }
+        .header p { opacity: 0.9; }
+        .summary { display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-bottom: 20px; }
+        .summary-card { background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); text-align: center; }
+        .summary-card .number { font-size: 36px; font-weight: bold; }
+        .summary-card .label { color: #666; margin-top: 5px; }
+        .summary-card.total .number { color: #2196F3; }
+        .summary-card.passed .number { color: #4CAF50; }
+        .summary-card.failed .number { color: #f44336; }
+        .summary-card.rate .number { color: #FF9800; }
+        table { width: 100%; background: white; border-radius: 10px; overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,0.1); border-collapse: collapse; }
+        th { background: #f8f9fa; padding: 12px 15px; text-align: left; font-weight: 600; color: #333; border-bottom: 2px solid #dee2e6; }
+        td { padding: 10px 15px; border-bottom: 1px solid #eee; }
+        tr:hover { background: #f8f9fa; }
+        pre { background: #f5f5f5; padding: 8px; border-radius: 4px; font-size: 12px; max-height: 100px; overflow: auto; }
+        .footer { text-align: center; color: #999; margin-top: 20px; font-size: 14px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>PregoPal 测试报告</h1>
+            <p>生成时间: 2026-06-09 00:24:37 | 测试框架: 内置 TestRunner</p>
+        </div>
+
+        <div class="summary">
+            <div class="summary-card total">
+                <div class="number">110</div>
+                <div class="label">总用例数</div>
+            </div>
+            <div class="summary-card passed">
+                <div class="number">110</div>
+                <div class="label">通过</div>
+            </div>
+            <div class="summary-card failed">
+                <div class="number">0</div>
+                <div class="label">失败</div>
+            </div>
+            <div class="summary-card rate">
+                <div class="number">100.0%</div>
+                <div class="label">通过率</div>
+            </div>
+        </div>
+
+        <table>
+            <thead>
+                <tr>
+                    <th>状态</th>
+                    <th>测试类</th>
+                    <th>测试方法</th>
+                    <th>描述</th>
+                    <th>结果</th>
+                    <th>错误信息</th>
+                </tr>
+            </thead>
+            <tbody>
+                
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_compare_focus_nutrients</td>
+                <td>应返回重点关注营养素列表</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_compare_with_intake_deficit</td>
+                <td>摄入不足时应标记 deficit</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_compare_with_intake_missing</td>
+                <td>缺失数据应标记 missing</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_compare_with_intake_sufficient</td>
+                <td>摄入充足时应标记 sufficient</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_format_comparison_table</td>
+                <td>对比表应包含表头和分隔线</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_get_rni_early</td>
+                <td>孕早期 RNI 应包含关键营养素</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_get_rni_lactation</td>
+                <td>哺乳期 RNI 钙需求应最高</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_get_rni_late</td>
+                <td>孕晚期 RNI 蛋白质需求应最高</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_get_rni_mid</td>
+                <td>孕中期 RNI 铁需求应增加</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_get_stages</td>
+                <td>应返回所有阶段</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDRIsParser</td>
+                <td>test_load</td>
+                <td>load() 应返回完整结构</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_core_principles_count</td>
+                <td>应有 6 条核心建议</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_format_for_prompt</td>
+                <td>format_for_prompt 应返回非空字符串</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_get_recommendations_fallback</td>
+                <td>未知阶段应返回孕中期</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_get_recommendations_late</td>
+                <td>孕晚期推荐量应不同</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_get_recommendations_mid</td>
+                <td>孕中期应返回正确的推荐量</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietaryGuideParser</td>
+                <td>test_load</td>
+                <td>load() 应返回完整结构</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoadAllStandards</td>
+                <td>test_compile_to_presets</td>
+                <td>compile_standards_to_presets 应生成缓存文件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoadAllStandards</td>
+                <td>test_load_all</td>
+                <td>load_all_standards 应返回所有标准</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_evaluate_above_range</td>
+                <td>体重高于标准应返回 warning</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_evaluate_below_range</td>
+                <td>体重低于标准应返回 warning</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_evaluate_invalid_bmi</td>
+                <td>无效 BMI 应返回 error</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_evaluate_within_range</td>
+                <td>体重在标准范围内应返回 ok</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_get_standard_boundary</td>
+                <td>边界值测试</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_get_standard_low_bmi</td>
+                <td>低体重 BMI (<18.5) 应返回低体重标准</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_get_standard_normal_bmi</td>
+                <td>正常 BMI (18.5-24) 应返回正确标准</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_get_standard_obese</td>
+                <td>肥胖 BMI (>=28) 应返回肥胖标准</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_get_standard_overweight</td>
+                <td>超重 BMI (24-28) 应返回超重标准</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestWeightStandardParser</td>
+                <td>test_load_returns_standards</td>
+                <td>load() 应返回结构化数据</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoadAll</td>
+                <td>test_format_all_for_prompt</td>
+                <td>test_format_all_for_prompt</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoadAll</td>
+                <td>test_load_all_family_info</td>
+                <td>test_load_all_family_info</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_add_daily</td>
+                <td>test_add_daily</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_add_event</td>
+                <td>test_add_event</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_format_for_prompt_empty</td>
+                <td>test_format_for_prompt_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_load_all_empty</td>
+                <td>test_load_all_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestMemoryManager</td>
+                <td>test_load_all_with_data</td>
+                <td>test_load_all_with_data</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_add_member</td>
+                <td>test_add_member</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_add_member_update</td>
+                <td>test_add_member_update</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_format_for_prompt_empty</td>
+                <td>test_format_for_prompt_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_load_all_empty</td>
+                <td>test_load_all_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPreferenceManager</td>
+                <td>test_load_all_with_data</td>
+                <td>test_load_all_with_data</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_add_duplicate_recipe</td>
+                <td>test_add_duplicate_recipe</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_add_recipe</td>
+                <td>test_add_recipe</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_ensure_file_creates</td>
+                <td>test_ensure_file_creates</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_format_for_prompt_empty</td>
+                <td>test_format_for_prompt_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td>test_format_for_prompt_with_data</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_get_names</td>
+                <td>test_get_names</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_load_all_empty</td>
+                <td>test_load_all_empty</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestRecipeManager</td>
+                <td>test_load_all_with_recipes</td>
+                <td>test_load_all_with_recipes</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_all_types</td>
+                <td>综合提取所有类型</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_diet_basic</td>
+                <td>基本饮食记录提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_diet_empty</td>
+                <td>无饮食记录应返回空列表</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_diet_multiple</td>
+                <td>多条饮食记录提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_memory</td>
+                <td>家庭记忆提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_preference</td>
+                <td>偏好提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_recipe</td>
+                <td>菜谱提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_thinking</td>
+                <td>思考步骤提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_extract_weight</td>
+                <td>体重提取</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_fallback_extract_diet</td>
+                <td>fallback 关键词匹配</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_fallback_extract_thinking</td>
+                <td>fallback 思考步骤匹配</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_get_extract_prompt</td>
+                <td>提取提示词应包含日期</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_robust_extract_with_fallback</td>
+                <td>综合提取：正则失败时用 fallback</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDietExtractor</td>
+                <td>test_robust_extract_with_markup</td>
+                <td>综合提取：正则优先</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_days_since_last_summary</td>
+                <td>距离上次总结的天数</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_get_last_summary_date</td>
+                <td>获取最近总结日期</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_is_today_done</td>
+                <td>检查今日是否完成</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_load_empty</td>
+                <td>空文件应返回空字典</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_mark_day_ended</td>
+                <td>标记今日结束</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_mark_summary_done</td>
+                <td>标记总结完成</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestDailyStatus</td>
+                <td>test_should_three_day_summary_false</td>
+                <td>刚总结完不应触发三天总结</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoopState</td>
+                <td>test_all_states_defined</td>
+                <td>所有状态应被定义</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestLoopState</td>
+                <td>test_state_count</td>
+                <td>应有 9 个状态</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_default_plugins_registered</td>
+                <td>应注册所有默认插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_get_briefing_empty</td>
+                <td>初始简报应为空</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_get_errors_empty</td>
+                <td>初始错误列表为空</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_get_thinking_keywords</td>
+                <td>初始思考关键词</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_loop_initialization</td>
+                <td>初始化应处于 LAUNCH 状态</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPregoPalLoop</td>
+                <td>test_plugin_count</td>
+                <td>应有 9 个默认插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestTransitions</td>
+                <td>test_already_done_flow</td>
+                <td>今日已完成的流程</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestTransitions</td>
+                <td>test_full_flow</td>
+                <td>完整流程应能到达 DONE</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestTransitions</td>
+                <td>test_launch_transitions</td>
+                <td>LAUNCH 应有 2 个转移</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestTransitions</td>
+                <td>test_three_day_flow</td>
+                <td>触发三天总结的流程</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestAnalyzePlugins</td>
+                <td>test_dri_analysis_plugin</td>
+                <td>DRIs 分析插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestBriefPlugins</td>
+                <td>test_briefing_generator_plugin</td>
+                <td>简报生成插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestConsolidatePlugins</td>
+                <td>test_preset_writer_plugin</td>
+                <td>预设写入插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestFamilyQuizPlugins</td>
+                <td>test_family_recipe_quiz_plugin</td>
+                <td>家庭菜谱检查插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestFamilyQuizPlugins</td>
+                <td>test_weight_quiz_plugin</td>
+                <td>体重询问检查插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_get_plugins_by_stage</td>
+                <td>按阶段获取插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_loop_context_defaults</td>
+                <td>LoopContext 默认值</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_plugin_registry_init</td>
+                <td>注册中心初始化应为空</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_plugin_result_custom</td>
+                <td>PluginResult 自定义值</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_plugin_result_defaults</td>
+                <td>PluginResult 默认值</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_register_plugin</td>
+                <td>注册插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginBase</td>
+                <td>test_unregister_plugin</td>
+                <td>注销插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_briefing_generator_execution</td>
+                <td>简报生成执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_diet_summary_execution</td>
+                <td>饮食总结执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_dri_analysis_execution</td>
+                <td>DRIs 分析执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_dummy_plugin_execution</td>
+                <td>虚拟插件执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_family_memory_execution</td>
+                <td>家庭记忆执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_family_recipe_quiz_execution</td>
+                <td>家庭菜谱检查执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_preset_writer_execution</td>
+                <td>预设写入执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_three_day_summary_execution</td>
+                <td>三天总结执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_weight_check_execution</td>
+                <td>体重检查执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestPluginExecution</td>
+                <td>test_weight_quiz_execution</td>
+                <td>体重询问检查执行</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestSummarizePlugins</td>
+                <td>test_diet_summary_plugin</td>
+                <td>饮食总结插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestSummarizePlugins</td>
+                <td>test_family_memory_plugin</td>
+                <td>家庭记忆插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestSummarizePlugins</td>
+                <td>test_weight_check_plugin</td>
+                <td>体重检查插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            <tr>
+                <td>PASS</td>
+                <td>TestThreeDayPlugins</td>
+                <td>test_three_day_summary_plugin</td>
+                <td>三天总结插件</td>
+                <td style="color:#4CAF50;font-weight:bold">通过</td>
+                <td></td>
+            </tr>
+            </tbody>
+        </table>
+
+        <div class="footer">
+            <p>PregoPal v5 | 测试耗时: 0.01秒 | 110/110 通过</p>
+        </div>
+    </div>
+</body>
+</html>
\ No newline at end of file
diff --git a/test_report.json b/test_report.json
new file mode 100644
index 0000000000000000000000000000000000000000..de9e82f5b326b60c0ba12e9d3575019c0a8f4418
--- /dev/null
+++ b/test_report.json
@@ -0,0 +1,780 @@
+{
+  "total": 110,
+  "passed": 110,
+  "failed": 0,
+  "pass_rate": 100.0,
+  "duration": 0.01,
+  "timestamp": "2026-06-09T00:24:37.617014",
+  "results": [
+    {
+      "class": "TestDRIsParser",
+      "method": "test_compare_focus_nutrients",
+      "doc": "应返回重点关注营养素列表",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_compare_with_intake_deficit",
+      "doc": "摄入不足时应标记 deficit",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_compare_with_intake_missing",
+      "doc": "缺失数据应标记 missing",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_compare_with_intake_sufficient",
+      "doc": "摄入充足时应标记 sufficient",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_format_comparison_table",
+      "doc": "对比表应包含表头和分隔线",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_get_rni_early",
+      "doc": "孕早期 RNI 应包含关键营养素",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_get_rni_lactation",
+      "doc": "哺乳期 RNI 钙需求应最高",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_get_rni_late",
+      "doc": "孕晚期 RNI 蛋白质需求应最高",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_get_rni_mid",
+      "doc": "孕中期 RNI 铁需求应增加",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_get_stages",
+      "doc": "应返回所有阶段",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDRIsParser",
+      "method": "test_load",
+      "doc": "load() 应返回完整结构",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_core_principles_count",
+      "doc": "应有 6 条核心建议",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_format_for_prompt",
+      "doc": "format_for_prompt 应返回非空字符串",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_get_recommendations_fallback",
+      "doc": "未知阶段应返回孕中期",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_get_recommendations_late",
+      "doc": "孕晚期推荐量应不同",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_get_recommendations_mid",
+      "doc": "孕中期应返回正确的推荐量",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietaryGuideParser",
+      "method": "test_load",
+      "doc": "load() 应返回完整结构",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoadAllStandards",
+      "method": "test_compile_to_presets",
+      "doc": "compile_standards_to_presets 应生成缓存文件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoadAllStandards",
+      "method": "test_load_all",
+      "doc": "load_all_standards 应返回所有标准",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_evaluate_above_range",
+      "doc": "体重高于标准应返回 warning",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_evaluate_below_range",
+      "doc": "体重低于标准应返回 warning",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_evaluate_invalid_bmi",
+      "doc": "无效 BMI 应返回 error",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_evaluate_within_range",
+      "doc": "体重在标准范围内应返回 ok",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_get_standard_boundary",
+      "doc": "边界值测试",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_get_standard_low_bmi",
+      "doc": "低体重 BMI (<18.5) 应返回低体重标准",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_get_standard_normal_bmi",
+      "doc": "正常 BMI (18.5-24) 应返回正确标准",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_get_standard_obese",
+      "doc": "肥胖 BMI (>=28) 应返回肥胖标准",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_get_standard_overweight",
+      "doc": "超重 BMI (24-28) 应返回超重标准",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestWeightStandardParser",
+      "method": "test_load_returns_standards",
+      "doc": "load() 应返回结构化数据",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoadAll",
+      "method": "test_format_all_for_prompt",
+      "doc": "test_format_all_for_prompt",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoadAll",
+      "method": "test_load_all_family_info",
+      "doc": "test_load_all_family_info",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_add_daily",
+      "doc": "test_add_daily",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_add_event",
+      "doc": "test_add_event",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_format_for_prompt_empty",
+      "doc": "test_format_for_prompt_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_format_for_prompt_with_data",
+      "doc": "test_format_for_prompt_with_data",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_load_all_empty",
+      "doc": "test_load_all_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestMemoryManager",
+      "method": "test_load_all_with_data",
+      "doc": "test_load_all_with_data",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_add_member",
+      "doc": "test_add_member",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_add_member_update",
+      "doc": "test_add_member_update",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_format_for_prompt_empty",
+      "doc": "test_format_for_prompt_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_format_for_prompt_with_data",
+      "doc": "test_format_for_prompt_with_data",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_load_all_empty",
+      "doc": "test_load_all_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPreferenceManager",
+      "method": "test_load_all_with_data",
+      "doc": "test_load_all_with_data",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_add_duplicate_recipe",
+      "doc": "test_add_duplicate_recipe",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_add_recipe",
+      "doc": "test_add_recipe",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_ensure_file_creates",
+      "doc": "test_ensure_file_creates",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_format_for_prompt_empty",
+      "doc": "test_format_for_prompt_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_format_for_prompt_with_data",
+      "doc": "test_format_for_prompt_with_data",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_get_names",
+      "doc": "test_get_names",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_load_all_empty",
+      "doc": "test_load_all_empty",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestRecipeManager",
+      "method": "test_load_all_with_recipes",
+      "doc": "test_load_all_with_recipes",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_all_types",
+      "doc": "综合提取所有类型",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_diet_basic",
+      "doc": "基本饮食记录提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_diet_empty",
+      "doc": "无饮食记录应返回空列表",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_diet_multiple",
+      "doc": "多条饮食记录提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_memory",
+      "doc": "家庭记忆提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_preference",
+      "doc": "偏好提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_recipe",
+      "doc": "菜谱提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_thinking",
+      "doc": "思考步骤提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_extract_weight",
+      "doc": "体重提取",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_fallback_extract_diet",
+      "doc": "fallback 关键词匹配",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_fallback_extract_thinking",
+      "doc": "fallback 思考步骤匹配",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_get_extract_prompt",
+      "doc": "提取提示词应包含日期",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_robust_extract_with_fallback",
+      "doc": "综合提取：正则失败时用 fallback",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDietExtractor",
+      "method": "test_robust_extract_with_markup",
+      "doc": "综合提取：正则优先",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_days_since_last_summary",
+      "doc": "距离上次总结的天数",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_get_last_summary_date",
+      "doc": "获取最近总结日期",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_is_today_done",
+      "doc": "检查今日是否完成",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_load_empty",
+      "doc": "空文件应返回空字典",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_mark_day_ended",
+      "doc": "标记今日结束",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_mark_summary_done",
+      "doc": "标记总结完成",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestDailyStatus",
+      "method": "test_should_three_day_summary_false",
+      "doc": "刚总结完不应触发三天总结",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoopState",
+      "method": "test_all_states_defined",
+      "doc": "所有状态应被定义",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestLoopState",
+      "method": "test_state_count",
+      "doc": "应有 9 个状态",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_default_plugins_registered",
+      "doc": "应注册所有默认插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_get_briefing_empty",
+      "doc": "初始简报应为空",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_get_errors_empty",
+      "doc": "初始错误列表为空",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_get_thinking_keywords",
+      "doc": "初始思考关键词",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_loop_initialization",
+      "doc": "初始化应处于 LAUNCH 状态",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPregoPalLoop",
+      "method": "test_plugin_count",
+      "doc": "应有 9 个默认插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestTransitions",
+      "method": "test_already_done_flow",
+      "doc": "今日已完成的流程",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestTransitions",
+      "method": "test_full_flow",
+      "doc": "完整流程应能到达 DONE",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestTransitions",
+      "method": "test_launch_transitions",
+      "doc": "LAUNCH 应有 2 个转移",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestTransitions",
+      "method": "test_three_day_flow",
+      "doc": "触发三天总结的流程",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestAnalyzePlugins",
+      "method": "test_dri_analysis_plugin",
+      "doc": "DRIs 分析插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestBriefPlugins",
+      "method": "test_briefing_generator_plugin",
+      "doc": "简报生成插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestConsolidatePlugins",
+      "method": "test_preset_writer_plugin",
+      "doc": "预设写入插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestFamilyQuizPlugins",
+      "method": "test_family_recipe_quiz_plugin",
+      "doc": "家庭菜谱检查插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestFamilyQuizPlugins",
+      "method": "test_weight_quiz_plugin",
+      "doc": "体重询问检查插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_get_plugins_by_stage",
+      "doc": "按阶段获取插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_loop_context_defaults",
+      "doc": "LoopContext 默认值",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_plugin_registry_init",
+      "doc": "注册中心初始化应为空",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_plugin_result_custom",
+      "doc": "PluginResult 自定义值",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_plugin_result_defaults",
+      "doc": "PluginResult 默认值",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_register_plugin",
+      "doc": "注册插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginBase",
+      "method": "test_unregister_plugin",
+      "doc": "注销插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_briefing_generator_execution",
+      "doc": "简报生成执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_diet_summary_execution",
+      "doc": "饮食总结执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_dri_analysis_execution",
+      "doc": "DRIs 分析执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_dummy_plugin_execution",
+      "doc": "虚拟插件执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_family_memory_execution",
+      "doc": "家庭记忆执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_family_recipe_quiz_execution",
+      "doc": "家庭菜谱检查执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_preset_writer_execution",
+      "doc": "预设写入执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_three_day_summary_execution",
+      "doc": "三天总结执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_weight_check_execution",
+      "doc": "体重检查执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestPluginExecution",
+      "method": "test_weight_quiz_execution",
+      "doc": "体重询问检查执行",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestSummarizePlugins",
+      "method": "test_diet_summary_plugin",
+      "doc": "饮食总结插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestSummarizePlugins",
+      "method": "test_family_memory_plugin",
+      "doc": "家庭记忆插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestSummarizePlugins",
+      "method": "test_weight_check_plugin",
+      "doc": "体重检查插件",
+      "passed": true,
+      "message": ""
+    },
+    {
+      "class": "TestThreeDayPlugins",
+      "method": "test_three_day_summary_plugin",
+      "doc": "三天总结插件",
+      "passed": true,
+      "message": ""
+    }
+  ]
+}
\ No newline at end of file
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..85176ae715b97d065fdf3d1c43200079f11f097d
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1,5 @@
+"""
+PregoPal - 测试套件
+===================
+所有核心功能的单元测试。
+"""
diff --git a/tests/__pycache__/__init__.cpython-313.pyc b/tests/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e05c763a779b99e7ef88c1d670eb44d404bc714
Binary files /dev/null and b/tests/__pycache__/__init__.cpython-313.pyc differ
diff --git a/tests/__pycache__/test_diet_extractor.cpython-313.pyc b/tests/__pycache__/test_diet_extractor.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1684144a4db04a92b7b47f54bbbed5d0d45eb810
Binary files /dev/null and b/tests/__pycache__/test_diet_extractor.cpython-313.pyc differ
diff --git a/tests/__pycache__/test_family_manager.cpython-313.pyc b/tests/__pycache__/test_family_manager.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..394a067a25856d10510e8721d74a36ec6767ee7b
Binary files /dev/null and b/tests/__pycache__/test_family_manager.cpython-313.pyc differ
diff --git a/tests/__pycache__/test_loop.cpython-313.pyc b/tests/__pycache__/test_loop.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5d582155a61d37d02d61bde4a6aafdf73c05409
Binary files /dev/null and b/tests/__pycache__/test_loop.cpython-313.pyc differ
diff --git a/tests/__pycache__/test_nutrition_standards.cpython-313.pyc b/tests/__pycache__/test_nutrition_standards.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6e1a6f8c3630a9335fec54aaed8f0e971941352
Binary files /dev/null and b/tests/__pycache__/test_nutrition_standards.cpython-313.pyc differ
diff --git a/tests/__pycache__/test_plugins.cpython-313.pyc b/tests/__pycache__/test_plugins.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..126bf81feda3fb6e5359e538dff3072e76ad5e38
Binary files /dev/null and b/tests/__pycache__/test_plugins.cpython-313.pyc differ
diff --git a/tests/run_tests.py b/tests/run_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfe1314d08a443ebe842ccda401003825941e287
--- /dev/null
+++ b/tests/run_tests.py
@@ -0,0 +1,284 @@
+"""
+PregoPal - 测试运行器
+=====================
+无需 pytest，直接运行所有测试并生成 HTML 测试报告。
+"""
+
+import sys
+import os
+import time
+import traceback
+import json
+from datetime import datetime
+from pathlib import Path
+
+# 确保项目根目录在路径中
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# ============================================================
+# 测试框架（极简版）
+# ============================================================
+
+class TestResult:
+    def __init__(self, class_name, method_name, doc, passed, message=""):
+        self.class_name = class_name
+        self.method_name = method_name
+        self.doc = doc
+        self.passed = passed
+        self.message = message
+
+    @property
+    def full_name(self):
+        return f"{self.class_name}.{self.method_name}"
+
+
+class TestRunner:
+    def __init__(self):
+        self.results = []
+        self.start_time = None
+        self.end_time = None
+
+    def run(self, test_module):
+        """运行一个测试模块中的所有测试类"""
+        self.start_time = time.time()
+        for name in dir(test_module):
+            obj = getattr(test_module, name)
+            if isinstance(obj, type) and name.startswith("Test"):
+                self._run_test_class(obj)
+        self.end_time = time.time()
+
+    def _run_test_class(self, cls):
+        """运行一个测试类中的所有测试方法"""
+        for name in dir(cls):
+            if not name.startswith("test_"):
+                continue
+            method = getattr(cls, name)
+            doc = method.__doc__ or name
+
+            # 每个测试方法创建独立实例，确保 setup/teardown 隔离
+            instance = cls()
+            # setup
+            if hasattr(instance, "setup_method"):
+                try:
+                    instance.setup_method()
+                except Exception as e:
+                    print(f"  [WARN] setup_method failed for {cls.__name__}.{name}: {e}")
+
+            try:
+                method(instance)
+                self.results.append(TestResult(cls.__name__, name, doc, True))
+            except Exception as e:
+                tb = traceback.format_exc()
+                # 安全获取错误消息（避免 GBK UnicodeEncodeError）
+                try:
+                    msg = str(e) if str(e) else tb[:500]
+                except UnicodeEncodeError:
+                    msg = tb[:500]
+                self.results.append(TestResult(cls.__name__, name, doc, False, msg))
+
+            # teardown
+            if hasattr(instance, "teardown_method"):
+                try:
+                    instance.teardown_method()
+                except Exception as e:
+                    print(f"  [WARN] teardown_method failed for {cls.__name__}.{name}: {e}")
+
+    @property
+    def total(self):
+        return len(self.results)
+
+    @property
+    def passed(self):
+        return sum(1 for r in self.results if r.passed)
+
+    @property
+    def failed(self):
+        return sum(1 for r in self.results if not r.passed)
+
+    @property
+    def duration(self):
+        if self.start_time and self.end_time:
+            return round(self.end_time - self.start_time, 2)
+        return 0
+
+    def generate_html_report(self, output_path="test_report.html"):
+        """生成 HTML 测试报告"""
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        rows = ""
+        for r in self.results:
+            status = "PASS" if r.passed else "FAIL"
+            color = "#4CAF50" if r.passed else "#f44336"
+            message = f"<pre>{r.message}</pre>" if not r.passed else ""
+            rows += f"""
+            <tr>
+                <td>{status}</td>
+                <td>{r.class_name}</td>
+                <td>{r.method_name}</td>
+                <td>{r.doc}</td>
+                <td style="color:{color};font-weight:bold">{'通过' if r.passed else '失败'}</td>
+                <td>{message}</td>
+            </tr>"""
+
+        html = f"""<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <title>PregoPal 测试报告</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{ font-family: -apple-system, 'Segoe UI', sans-serif; background: #f5f5f5; padding: 20px; }}
+        .container {{ max-width: 1200px; margin: 0 auto; }}
+        .header {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 12px; margin-bottom: 20px; }}
+        .header h1 {{ font-size: 28px; margin-bottom: 10px; }}
+        .header p {{ opacity: 0.9; }}
+        .summary {{ display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-bottom: 20px; }}
+        .summary-card {{ background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); text-align: center; }}
+        .summary-card .number {{ font-size: 36px; font-weight: bold; }}
+        .summary-card .label {{ color: #666; margin-top: 5px; }}
+        .summary-card.total .number {{ color: #2196F3; }}
+        .summary-card.passed .number {{ color: #4CAF50; }}
+        .summary-card.failed .number {{ color: #f44336; }}
+        .summary-card.rate .number {{ color: #FF9800; }}
+        table {{ width: 100%; background: white; border-radius: 10px; overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,0.1); border-collapse: collapse; }}
+        th {{ background: #f8f9fa; padding: 12px 15px; text-align: left; font-weight: 600; color: #333; border-bottom: 2px solid #dee2e6; }}
+        td {{ padding: 10px 15px; border-bottom: 1px solid #eee; }}
+        tr:hover {{ background: #f8f9fa; }}
+        pre {{ background: #f5f5f5; padding: 8px; border-radius: 4px; font-size: 12px; max-height: 100px; overflow: auto; }}
+        .footer {{ text-align: center; color: #999; margin-top: 20px; font-size: 14px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>PregoPal 测试报告</h1>
+            <p>生成时间: {now} | 测试框架: 内置 TestRunner</p>
+        </div>
+
+        <div class="summary">
+            <div class="summary-card total">
+                <div class="number">{self.total}</div>
+                <div class="label">总用例数</div>
+            </div>
+            <div class="summary-card passed">
+                <div class="number">{self.passed}</div>
+                <div class="label">通过</div>
+            </div>
+            <div class="summary-card failed">
+                <div class="number">{self.failed}</div>
+                <div class="label">失败</div>
+            </div>
+            <div class="summary-card rate">
+                <div class="number">{self.pass_rate:.1f}%</div>
+                <div class="label">通过率</div>
+            </div>
+        </div>
+
+        <table>
+            <thead>
+                <tr>
+                    <th>状态</th>
+                    <th>测试类</th>
+                    <th>测试方法</th>
+                    <th>描述</th>
+                    <th>结果</th>
+                    <th>错误信息</th>
+                </tr>
+            </thead>
+            <tbody>
+                {rows}
+            </tbody>
+        </table>
+
+        <div class="footer">
+            <p>PregoPal v5 | 测试耗时: {self.duration}秒 | {self.passed}/{self.total} 通过</p>
+        </div>
+    </div>
+</body>
+</html>"""
+
+        output_path = Path(output_path)
+        output_path.write_text(html, encoding='utf-8')
+        return output_path
+
+    @property
+    def pass_rate(self):
+        return (self.passed / self.total * 100) if self.total > 0 else 0
+
+    def print_summary(self):
+        """打印控制台摘要"""
+        print("=" * 60)
+        print("  PregoPal 测试报告")
+        print("  " + "=" * 56)
+        print(f"  总用例: {self.total}  |  通过: {self.passed}  |  失败: {self.failed}  |  通过率: {self.pass_rate:.1f}%")
+        print(f"  耗时: {self.duration}秒")
+        print("=" * 60)
+
+        if self.failed > 0:
+            print("\n  失败的测试:")
+            for r in self.results:
+                if not r.passed:
+                    print(f"    - {r.full_name}: {r.message}")
+        print()
+
+
+# ============================================================
+# 主入口
+# ============================================================
+
+def main():
+    """运行所有测试并生成报告"""
+    import importlib
+
+    test_modules = [
+        "tests.test_nutrition_standards",
+        "tests.test_family_manager",
+        "tests.test_diet_extractor",
+        "tests.test_loop",
+        "tests.test_plugins",
+    ]
+
+    runner = TestRunner()
+
+    for module_name in test_modules:
+        try:
+            mod = importlib.import_module(module_name)
+            print(f"[TEST] 正在测试: {module_name}")
+            runner.run(mod)
+        except Exception as e:
+            print(f"[ERROR] 导入模块失败 {module_name}: {e}")
+
+    runner.print_summary()
+
+    # 生成 HTML 报告
+    report_path = runner.generate_html_report("test_report.html")
+    print(f"[DONE] HTML 报告已生成: {report_path.resolve()}")
+
+    # 生成 JSON 报告
+    json_path = Path("test_report.json")
+    json_data = {
+        "total": runner.total,
+        "passed": runner.passed,
+        "failed": runner.failed,
+        "pass_rate": runner.pass_rate,
+        "duration": runner.duration,
+        "timestamp": datetime.now().isoformat(),
+        "results": [
+            {
+                "class": r.class_name,
+                "method": r.method_name,
+                "doc": r.doc,
+                "passed": r.passed,
+                "message": r.message
+            }
+            for r in runner.results
+        ]
+    }
+    json_path.write_text(json.dumps(json_data, ensure_ascii=False, indent=2), encoding='utf-8')
+    print(f"[DONE] JSON 报告已生成: {json_path.resolve()}")
+
+    return 0 if runner.failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_diet_extractor.py b/tests/test_diet_extractor.py
new file mode 100644
index 0000000000000000000000000000000000000000..e84cf54d35917037d2ad06e514296655017de313
--- /dev/null
+++ b/tests/test_diet_extractor.py
@@ -0,0 +1,186 @@
+"""
+测试：对话内容提取器
+====================
+测试 DietExtractor 的正则提取和 fallback 机制
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+from modules.diet_extractor import DietExtractor, get_extract_prompt
+
+
+class TestDietExtractor:
+    """测试饮食提取器"""
+
+    def test_extract_diet_basic(self):
+        """基本饮食记录提取"""
+        text = """
+[EXTRACT_DIET]
+日期: 2026-06-08
+早餐: 全麦面包, 牛奶
+午餐: 番茄牛腩, 米饭
+记录人: 丈夫
+备注: 孕妇说想吃
+[/EXTRACT_DIET]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["diets"]) == 1
+        diet = result["diets"][0]
+        assert diet["日期"] == "2026-06-08"
+        assert "午餐" in diet["meals"]
+        assert "番茄牛腩" in diet["meals"]["午餐"]
+
+    def test_extract_diet_multiple(self):
+        """多条饮食记录提取"""
+        text = """
+[EXTRACT_DIET]
+日期: 2026-06-08
+早餐: 全麦面包, 牛奶
+[/EXTRACT_DIET]
+[EXTRACT_DIET]
+日期: 2026-06-08
+午餐: 清蒸鱼
+[/EXTRACT_DIET]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["diets"]) == 2
+
+    def test_extract_diet_empty(self):
+        """无饮食记录应返回空列表"""
+        text = "今天天气真好"
+        result = DietExtractor.extract_all(text)
+        assert result["diets"] == []
+
+    def test_extract_recipe(self):
+        """菜谱提取"""
+        text = """
+[EXTRACT_RECIPE]
+菜名: 清蒸鲈鱼
+制作人: 丈夫
+难度: 中等
+食材: 鲈鱼, 葱, 姜
+备注: 孕妇爱吃
+[/EXTRACT_RECIPE]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["recipes"]) == 1
+        recipe = result["recipes"][0]
+        assert recipe["菜名"] == "清蒸鲈鱼"
+        assert recipe["制作人"] == "丈夫"
+
+    def test_extract_preference(self):
+        """偏好提取"""
+        text = """
+[EXTRACT_PREFERENCE]
+人员: 小明
+类型: 忌口
+内容: 不吃香菜
+[/EXTRACT_PREFERENCE]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["preferences"]) == 1
+        pref = result["preferences"][0]
+        assert pref["人员"] == "小明"
+        assert pref["类型"] == "忌口"
+
+    def test_extract_weight(self):
+        """体重提取"""
+        text = """
+[EXTRACT_WEIGHT]
+日期: 2026-06-08
+体重: 62.5
+记录人: 孕妇
+[/EXTRACT_WEIGHT]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["weights"]) == 1
+        w = result["weights"][0]
+        assert w["体重"] == "62.5"
+
+    def test_extract_memory(self):
+        """家庭记忆提取"""
+        text = """
+[EXTRACT_MEMORY]
+类型: 事件
+内容: 丈夫今天做了番茄牛腩
+[/EXTRACT_MEMORY]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["memories"]) == 1
+        m = result["memories"][0]
+        assert m["类型"] == "事件"
+
+    def test_extract_thinking(self):
+        """思考步骤提取"""
+        text = """
+[THINKING]
+当前步骤: 分析昨日钙摄入
+下一步: 对比DRIs标准
+[/THINKING]
+"""
+        result = DietExtractor.extract_all(text)
+        assert result["thinking"] is not None
+        assert result["thinking"]["当前步骤"] == "分析昨日钙摄入"
+        assert result["thinking"]["下一步"] == "对比DRIs标准"
+
+    def test_extract_all_types(self):
+        """综合提取所有类型"""
+        text = """
+[EXTRACT_DIET]
+日期: 2026-06-08
+午餐: 番茄牛腩
+[/EXTRACT_DIET]
+[EXTRACT_RECIPE]
+菜名: 番茄牛腩
+制作人: 丈夫
+[/EXTRACT_RECIPE]
+[THINKING]
+当前步骤: 分析
+下一步: 推荐
+[/THINKING]
+"""
+        result = DietExtractor.extract_all(text)
+        assert len(result["diets"]) == 1
+        assert len(result["recipes"]) == 1
+        assert result["thinking"] is not None
+
+    def test_fallback_extract_diet(self):
+        """fallback 关键词匹配"""
+        text = "我今天午餐吃了番茄牛腩和米饭"
+        result = DietExtractor.fallback_extract_diet(text)
+        assert result is not None
+        assert "午餐" in result["meals"]
+
+    def test_fallback_extract_thinking(self):
+        """fallback 思考步骤匹配"""
+        text = "当前步骤是分析钙摄入，下一步是推荐食物"
+        result = DietExtractor.fallback_extract_thinking(text)
+        assert result is not None
+
+    def test_robust_extract_with_fallback(self):
+        """综合提取：正则失败时用 fallback"""
+        text = "我早餐吃了全麦面包和牛奶"
+        result = DietExtractor.robust_extract(text)
+        assert len(result["diets"]) > 0
+
+    def test_robust_extract_with_markup(self):
+        """综合提取：正则优先"""
+        text = """
+我吃了番茄牛腩
+[EXTRACT_DIET]
+日期: 2026-06-08
+午餐: 番茄牛腩
+[/EXTRACT_DIET]
+"""
+        result = DietExtractor.robust_extract(text)
+        assert len(result["diets"]) == 1
+        assert result["diets"][0].get("日期") == "2026-06-08"
+
+    def test_get_extract_prompt(self):
+        """提取提示词应包含日期"""
+        prompt = get_extract_prompt("2026-06-08")
+        assert "2026-06-08" in prompt
+        assert "EXTRACT_DIET" in prompt
+        assert "EXTRACT_RECIPE" in prompt
+        assert "THINKING" in prompt
diff --git a/tests/test_family_manager.py b/tests/test_family_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..b734f71ee3363b1ed96e61a0378a2ee1384b093d
--- /dev/null
+++ b/tests/test_family_manager.py
@@ -0,0 +1,190 @@
+"""
+测试：家庭信息管理
+==================
+测试 RecipeManager, PreferenceManager, MemoryManager
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+import os
+from pathlib import Path
+from modules.family_manager import (
+    RecipeManager,
+    PreferenceManager,
+    MemoryManager,
+    load_all_family_info,
+    format_all_for_prompt,
+    FAMILY_DIR,
+)
+
+
+class TestRecipeManager:
+    """测试家庭菜谱管理"""
+
+    def setup_method(self):
+        self._backup = None
+        if RecipeManager.RECIPES_FILE.exists():
+            self._backup = RecipeManager.RECIPES_FILE.read_text(encoding='utf-8')
+            RecipeManager.RECIPES_FILE.unlink()
+
+    def teardown_method(self):
+        if self._backup:
+            RecipeManager.RECIPES_FILE.parent.mkdir(parents=True, exist_ok=True)
+            RecipeManager.RECIPES_FILE.write_text(self._backup, encoding='utf-8')
+
+    def test_ensure_file_creates(self):
+        if RecipeManager.RECIPES_FILE.exists():
+            RecipeManager.RECIPES_FILE.unlink()
+        RecipeManager.ensure_file()
+        assert RecipeManager.RECIPES_FILE.exists()
+
+    def test_add_recipe(self):
+        result = RecipeManager.add_recipe("番茄牛腩", "丈夫", "中等", "番茄, 牛腩", "孕妇爱吃")
+        assert "已添加" in result
+
+    def test_add_duplicate_recipe(self):
+        RecipeManager.add_recipe("番茄牛腩", "丈夫")
+        result = RecipeManager.add_recipe("番茄牛腩", "丈夫")
+        assert "已存在" in result
+
+    def test_load_all_empty(self):
+        RecipeManager.ensure_file()
+        recipes = RecipeManager.load_all()
+        assert recipes == []
+
+    def test_load_all_with_recipes(self):
+        RecipeManager.add_recipe("清蒸鲈鱼", "丈夫", "简单", "鲈鱼, 葱姜")
+        recipes = RecipeManager.load_all()
+        assert len(recipes) == 1
+        assert recipes[0]["name"] == "清蒸鲈鱼"
+        assert recipes[0]["cook"] == "丈夫"
+
+    def test_get_names(self):
+        RecipeManager.add_recipe("菜A", "丈夫")
+        RecipeManager.add_recipe("菜B", "妻子")
+        names = RecipeManager.get_names()
+        assert "菜A" in names
+        assert "菜B" in names
+
+    def test_format_for_prompt_empty(self):
+        RecipeManager.ensure_file()
+        text = RecipeManager.format_for_prompt()
+        assert "暂无记录" in text
+
+    def test_format_for_prompt_with_data(self):
+        RecipeManager.add_recipe("番茄牛腩", "丈夫")
+        text = RecipeManager.format_for_prompt()
+        assert "番茄牛腩" in text
+        assert "丈夫" in text
+
+
+class TestPreferenceManager:
+    """测试饮食偏好管理"""
+
+    def setup_method(self):
+        self._backup = None
+        if PreferenceManager.PREFERENCES_FILE.exists():
+            self._backup = PreferenceManager.PREFERENCES_FILE.read_text(encoding='utf-8')
+            PreferenceManager.PREFERENCES_FILE.unlink()
+
+    def teardown_method(self):
+        if self._backup:
+            PreferenceManager.PREFERENCES_FILE.parent.mkdir(parents=True, exist_ok=True)
+            PreferenceManager.PREFERENCES_FILE.write_text(self._backup, encoding='utf-8')
+
+    def test_add_member(self):
+        result = PreferenceManager.add_member("小明", "丈夫", "爱吃肉", "不吃香菜", "")
+        assert "已保存" in result
+
+    def test_add_member_update(self):
+        PreferenceManager.add_member("小明", "丈夫", "爱吃肉")
+        PreferenceManager.add_member("小明", "丈夫", "爱吃鱼")
+        members = PreferenceManager.load_all()
+        assert len(members) == 1
+        assert members[0]["preferences"] == "爱吃鱼"
+
+    def test_load_all_empty(self):
+        PreferenceManager.ensure_file()
+        members = PreferenceManager.load_all()
+        assert members == []
+
+    def test_load_all_with_data(self):
+        PreferenceManager.add_member("小红", "孕妇", "爱吃水果", "不吃辣", "芒果")
+        members = PreferenceManager.load_all()
+        assert len(members) >= 1
+        found = [m for m in members if m["name"] == "小红"]
+        assert len(found) > 0
+        assert found[0]["allergies"] == "芒果"
+
+    def test_format_for_prompt_empty(self):
+        PreferenceManager.ensure_file()
+        text = PreferenceManager.format_for_prompt()
+        assert "暂无记录" in text
+
+    def test_format_for_prompt_with_data(self):
+        PreferenceManager.add_member("小明", "丈夫", "爱吃肉", "不吃香菜")
+        text = PreferenceManager.format_for_prompt()
+        assert "小明" in text
+        assert "爱吃肉" in text
+
+
+class TestMemoryManager:
+    """测试家庭记忆管理"""
+
+    def setup_method(self):
+        self._backup = None
+        if MemoryManager.MEMORY_FILE.exists():
+            self._backup = MemoryManager.MEMORY_FILE.read_text(encoding='utf-8')
+            MemoryManager.MEMORY_FILE.unlink()
+
+    def teardown_method(self):
+        if self._backup:
+            MemoryManager.MEMORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+            MemoryManager.MEMORY_FILE.write_text(self._backup, encoding='utf-8')
+
+    def test_add_event(self):
+        result = MemoryManager.add_event("今天丈夫做了番茄牛腩")
+        assert "已记录" in result
+
+    def test_add_daily(self):
+        result = MemoryManager.add_daily("孕妇说想吃鱼")
+        assert "已记录" in result
+
+    def test_load_all_empty(self):
+        MemoryManager.ensure_file()
+        data = MemoryManager.load_all()
+        assert "relationships" in data
+        assert "events" in data
+        assert "daily" in data
+
+    def test_load_all_with_data(self):
+        MemoryManager.add_event("重要事件测试")
+        MemoryManager.add_daily("日常记录测试")
+        data = MemoryManager.load_all()
+        assert len(data["events"]) > 0
+        assert len(data["daily"]) > 0
+
+    def test_format_for_prompt_empty(self):
+        MemoryManager.ensure_file()
+        text = MemoryManager.format_for_prompt()
+        assert "暂无记录" in text
+
+    def test_format_for_prompt_with_data(self):
+        MemoryManager.add_event("测试事件")
+        text = MemoryManager.format_for_prompt()
+        assert "测试事件" in text
+
+
+class TestLoadAll:
+    """测试统一加载接口"""
+
+    def test_load_all_family_info(self):
+        data = load_all_family_info()
+        assert "recipes" in data
+        assert "preferences" in data
+        assert "memory" in data
+
+    def test_format_all_for_prompt(self):
+        text = format_all_for_prompt()
+        assert len(text) > 0
diff --git a/tests/test_loop.py b/tests/test_loop.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4e315e428a1c668f139dc88d9cc41f60f569eee
--- /dev/null
+++ b/tests/test_loop.py
@@ -0,0 +1,170 @@
+"""
+测试：核心循环引擎
+==================
+测试 LoopState, DailyStatus, PregoPalLoop
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+import json
+import datetime
+from pathlib import Path
+from loop import LoopState, DailyStatus, PregoPalLoop, _TRANSITIONS, PRESETS_DIR, STATUS_FILE
+
+
+class TestLoopState:
+    """测试状态枚举"""
+
+    def test_all_states_defined(self):
+        """所有状态应被定义"""
+        assert LoopState.LAUNCH.value == "launch"
+        assert LoopState.FAMILY_QUIZ.value == "family_quiz"
+        assert LoopState.SUMMARIZE.value == "summarize"
+        assert LoopState.ANALYZE.value == "analyze"
+        assert LoopState.BRIEF.value == "brief"
+        assert LoopState.INTERACT.value == "interact"
+        assert LoopState.THREE_DAY.value == "three_day"
+        assert LoopState.CONSOLIDATE.value == "consolidate"
+        assert LoopState.DONE.value == "done"
+
+    def test_state_count(self):
+        """应有 9 个状态"""
+        assert len(LoopState) == 9
+
+
+class TestTransitions:
+    """测试状态转移表"""
+
+    def test_launch_transitions(self):
+        """LAUNCH 应有 2 个转移"""
+        assert (LoopState.LAUNCH, "need_summary") in _TRANSITIONS
+        assert (LoopState.LAUNCH, "already_done") in _TRANSITIONS
+
+    def test_full_flow(self):
+        """完整流程应能到达 DONE"""
+        state = LoopState.LAUNCH
+        events = ["need_summary", "ok", "ok", "ok", "ok", "day_ended", "ok"]
+        for event in events:
+            next_state = _TRANSITIONS.get((state, event))
+            assert next_state is not None, f"No transition from {state} on '{event}'"
+            state = next_state
+        assert state == LoopState.DONE
+
+    def test_three_day_flow(self):
+        """触发三天总结的流程"""
+        state = LoopState.LAUNCH
+        events = ["need_summary", "ok", "ok", "ok", "ok", "day_ended", "need_3day", "ok"]
+        for event in events:
+            next_state = _TRANSITIONS.get((state, event))
+            assert next_state is not None
+            state = next_state
+        assert state == LoopState.DONE
+
+    def test_already_done_flow(self):
+        """今日已完成的流程"""
+        state = LoopState.LAUNCH
+        next_state = _TRANSITIONS.get((state, "already_done"))
+        assert next_state == LoopState.INTERACT
+
+
+class TestDailyStatus:
+    """测试状态位管理"""
+
+    def setup_method(self):
+        self._backup = None
+        if STATUS_FILE.exists():
+            self._backup = STATUS_FILE.read_text(encoding='utf-8')
+
+    def teardown_method(self):
+        if self._backup:
+            STATUS_FILE.write_text(self._backup, encoding='utf-8')
+        elif STATUS_FILE.exists():
+            STATUS_FILE.unlink()
+
+    def test_load_empty(self):
+        """空文件应返回空字典"""
+        if STATUS_FILE.exists():
+            STATUS_FILE.unlink()
+        status = DailyStatus.load()
+        assert status == {}
+
+    def test_mark_summary_done(self):
+        """标记总结完成"""
+        DailyStatus.mark_summary_done()
+        today = datetime.date.today().isoformat()
+        status = DailyStatus.load()
+        assert status[today]["summary_done"] is True
+
+    def test_is_today_done(self):
+        """检查今日是否完成"""
+        DailyStatus.mark_summary_done()
+        assert DailyStatus.is_today_done() is True
+
+    def test_mark_day_ended(self):
+        """标记今日结束"""
+        DailyStatus.mark_day_ended()
+        today = datetime.date.today().isoformat()
+        status = DailyStatus.load()
+        assert status[today]["day_ended"] is True
+
+    def test_get_last_summary_date(self):
+        """获取最近总结日期"""
+        DailyStatus.mark_summary_done()
+        last = DailyStatus.get_last_summary_date()
+        assert last == datetime.date.today().isoformat()
+
+    def test_days_since_last_summary(self):
+        """距离上次总结的天数"""
+        DailyStatus.mark_summary_done()
+        days = DailyStatus.days_since_last_summary()
+        assert days == 0
+
+    def test_should_three_day_summary_false(self):
+        """刚总结完不应触发三天总结"""
+        DailyStatus.mark_summary_done()
+        assert DailyStatus.should_three_day_summary() is False
+
+
+class TestPregoPalLoop:
+    """测试循环引擎"""
+
+    def test_loop_initialization(self):
+        """初始化应处于 LAUNCH 状态"""
+        loop = PregoPalLoop()
+        assert loop.state == LoopState.LAUNCH
+
+    def test_default_plugins_registered(self):
+        """应注册所有默认插件"""
+        loop = PregoPalLoop()
+        plugins = loop.plugins.get_all()
+        plugin_names = [p.name() for p in plugins]
+        assert "family_recipe_quiz" in plugin_names
+        assert "weight_quiz" in plugin_names
+        assert "diet_summary" in plugin_names
+        assert "weight_check" in plugin_names
+        assert "family_memory" in plugin_names
+        assert "dri_analysis" in plugin_names
+        assert "briefing_generator" in plugin_names
+        assert "three_day_summary" in plugin_names
+        assert "preset_writer" in plugin_names
+
+    def test_plugin_count(self):
+        """应有 9 个默认插件"""
+        loop = PregoPalLoop()
+        assert len(loop.plugins.get_all()) == 9
+
+    def test_get_briefing_empty(self):
+        """初始简报应为空"""
+        loop = PregoPalLoop()
+        assert loop.get_briefing() == {}
+
+    def test_get_thinking_keywords(self):
+        """初始思考关键词"""
+        loop = PregoPalLoop()
+        assert loop.get_thinking_keywords() == ""
+
+    def test_get_errors_empty(self):
+        """初始错误列表为空"""
+        loop = PregoPalLoop()
+        assert loop.get_errors() == []
diff --git a/tests/test_nutrition_standards.py b/tests/test_nutrition_standards.py
new file mode 100644
index 0000000000000000000000000000000000000000..3eb23477414bfd92adf7679450510520c04bdc17
--- /dev/null
+++ b/tests/test_nutrition_standards.py
@@ -0,0 +1,219 @@
+"""
+测试：营养标准解析器
+====================
+测试 WeightStandardParser, DietaryGuideParser, DRIsParser
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+from modules.nutrition_standards import (
+    WeightStandardParser,
+    DietaryGuideParser,
+    DRIsParser,
+    load_all_standards,
+    compile_standards_to_presets,
+)
+
+
+class TestWeightStandardParser:
+    """测试体重增长标准"""
+
+    def test_get_standard_normal_bmi(self):
+        """正常 BMI (18.5-24) 应返回正确标准"""
+        std = WeightStandardParser.get_standard(22.0)
+        assert std is not None, "正常 BMI 应返回标准"
+        assert std["category"] == "正常"
+        assert std["total_gain"] == (8.0, 14.0)
+        assert std["weekly_gain"] == 0.37
+
+    def test_get_standard_low_bmi(self):
+        """低体重 BMI (<18.5) 应返回低体重标准"""
+        std = WeightStandardParser.get_standard(17.0)
+        assert std is not None
+        assert std["category"] == "低体重"
+        assert std["total_gain"] == (11.0, 16.0)
+
+    def test_get_standard_overweight(self):
+        """超重 BMI (24-28) 应返回超重标准"""
+        std = WeightStandardParser.get_standard(26.0)
+        assert std is not None
+        assert std["category"] == "超重"
+
+    def test_get_standard_obese(self):
+        """肥胖 BMI (>=28) 应返回肥胖标准"""
+        std = WeightStandardParser.get_standard(30.0)
+        assert std is not None
+        assert std["category"] == "肥胖"
+
+    def test_get_standard_boundary(self):
+        """边界值测试"""
+        std = WeightStandardParser.get_standard(18.5)
+        assert std is not None
+        assert std["category"] == "正常"
+
+    def test_evaluate_within_range(self):
+        """体重在标准范围内应返回 ok"""
+        result = WeightStandardParser.evaluate(22.0, 20, 10.0)
+        assert result["status"] == "ok"
+        assert "标准范围内" in result["message"]
+
+    def test_evaluate_below_range(self):
+        """体重低于标准应返回 warning"""
+        result = WeightStandardParser.evaluate(22.0, 20, 3.0)
+        assert result["status"] == "warning"
+        assert "偏慢" in result["message"]
+
+    def test_evaluate_above_range(self):
+        """体重高于标准应返回 warning"""
+        result = WeightStandardParser.evaluate(22.0, 20, 18.0)
+        assert result["status"] == "warning"
+        assert "偏快" in result["message"]
+
+    def test_evaluate_invalid_bmi(self):
+        """无效 BMI 应返回 error"""
+        result = WeightStandardParser.evaluate(-1, 20, 10.0)
+        assert result["status"] == "error"
+
+    def test_load_returns_standards(self):
+        """load() 应返回结构化数据"""
+        data = WeightStandardParser.load()
+        assert "bmi_standards" in data
+        assert len(data["bmi_standards"]) == 4
+
+
+class TestDietaryGuideParser:
+    """测试膳食指南解析器"""
+
+    def test_get_recommendations_mid(self):
+        """孕中期应返回正确的推荐量"""
+        recs = DietaryGuideParser.get_recommendations("孕中期")
+        assert recs["奶类"] == "300-500g"
+        assert recs["鱼禽蛋肉类"] == "150-200g"
+        assert "谷类" in recs
+
+    def test_get_recommendations_late(self):
+        """孕晚期推荐量应不同"""
+        recs = DietaryGuideParser.get_recommendations("孕晚期")
+        assert recs["鱼禽蛋肉类"] == "175-225g"
+
+    def test_get_recommendations_fallback(self):
+        """未知阶段应返回孕中期"""
+        recs = DietaryGuideParser.get_recommendations("未知阶段")
+        assert recs["奶类"] == "300-500g"
+
+    def test_core_principles_count(self):
+        """应有 6 条核心建议"""
+        principles = DietaryGuideParser.get_core_principles()
+        assert len(principles) == 6
+
+    def test_format_for_prompt(self):
+        """format_for_prompt 应返回非空字符串"""
+        text = DietaryGuideParser.format_for_prompt("孕中期")
+        assert len(text) > 50
+        assert "平衡膳食宝塔" in text
+        assert "六条核心建议" in text
+
+    def test_load(self):
+        """load() 应返回完整结构"""
+        data = DietaryGuideParser.load()
+        assert "food_pagoda" in data
+        assert "core_principles" in data
+        assert len(data["food_pagoda"]) >= 4
+
+
+class TestDRIsParser:
+    """测试 DRIs 解析器"""
+
+    def test_get_rni_early(self):
+        """孕早期 RNI 应包含关键营养素"""
+        rni = DRIsParser.get_rni("孕早期")
+        assert rni["叶酸(μg DFE)"] == 600
+        assert rni["铁(mg)"] == 20
+        assert rni["钙(mg)"] == 800
+
+    def test_get_rni_mid(self):
+        """孕中期 RNI 铁需求应增加"""
+        rni = DRIsParser.get_rni("孕中期")
+        assert rni["铁(mg)"] == 25
+
+    def test_get_rni_late(self):
+        """孕晚期 RNI 蛋白质需求应最高"""
+        rni = DRIsParser.get_rni("孕晚期")
+        assert rni["蛋白质(g)"] == 85
+
+    def test_get_rni_lactation(self):
+        """哺乳期 RNI 钙需求应最高"""
+        rni = DRIsParser.get_rni("哺乳期")
+        assert rni["钙(mg)"] == 1000
+
+    def test_get_stages(self):
+        """应返回所有阶段"""
+        stages = DRIsParser.get_stages()
+        assert "孕早期" in stages
+        assert "孕中期" in stages
+        assert "孕晚期" in stages
+        assert "哺乳期" in stages
+
+    def test_compare_with_intake_sufficient(self):
+        """摄入充足时应标记 sufficient"""
+        intake = {"钙(mg)": 900, "铁(mg)": 30, "蛋白质(g)": 80}
+        result = DRIsParser.compare_with_intake("孕中期", intake)
+        for c in result["comparisons"]:
+            if c["nutrient"] == "钙(mg)":
+                assert c["status"] == "sufficient"
+
+    def test_compare_with_intake_deficit(self):
+        """摄入不足时应标记 deficit"""
+        intake = {"钙(mg)": 200, "铁(mg)": 5}
+        result = DRIsParser.compare_with_intake("孕中期", intake)
+        for c in result["comparisons"]:
+            if c["nutrient"] == "钙(mg)":
+                assert c["status"] == "deficit"
+
+    def test_compare_with_intake_missing(self):
+        """缺失数据应标记 missing"""
+        intake = {}
+        result = DRIsParser.compare_with_intake("孕中期", intake)
+        for c in result["comparisons"]:
+            assert c["status"] == "missing"
+
+    def test_compare_focus_nutrients(self):
+        """应返回重点关注营养素列表"""
+        intake = {"钙(mg)": 100}
+        result = DRIsParser.compare_with_intake("孕中期", intake)
+        assert len(result["focus_nutrients"]) > 0
+        assert "钙(mg)" in result["focus_nutrients"]
+
+    def test_format_comparison_table(self):
+        """对比表应包含表头和分隔线"""
+        intake = {"钙(mg)": 400, "铁(mg)": 15}
+        result = DRIsParser.compare_with_intake("孕中期", intake)
+        table = DRIsParser.format_comparison_table(result["comparisons"])
+        assert "RNI" in table
+        assert "差异" in table
+
+    def test_load(self):
+        """load() 应返回完整结构"""
+        data = DRIsParser.load()
+        assert "rni_data" in data
+
+
+class TestLoadAllStandards:
+    """测试统一加载接口"""
+
+    def test_load_all(self):
+        """load_all_standards 应返回所有标准"""
+        data = load_all_standards()
+        assert "weight" in data
+        assert "dietary_guide" in data
+        assert "dris" in data
+
+    def test_compile_to_presets(self):
+        """compile_standards_to_presets 应生成缓存文件"""
+        import os
+        path = compile_standards_to_presets()
+        assert path.exists()
+        # 清理
+        if path.exists():
+            os.remove(path)
diff --git a/tests/test_plugins.py b/tests/test_plugins.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b00b6123d52679bf05ae800ba6f1fb1e7337c2b
--- /dev/null
+++ b/tests/test_plugins.py
@@ -0,0 +1,245 @@
+"""
+测试：Loop 插件
+===============
+测试所有内置插件的注册和执行
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+import asyncio
+from plugins.base import LoopPlugin, PluginRegistry, LoopStage, LoopContext, PluginResult
+
+
+class DummyPlugin(LoopPlugin):
+    """用于测试的虚拟插件"""
+
+    def stage(self) -> LoopStage:
+        return LoopStage.SUMMARIZE
+
+    def name(self) -> str:
+        return "dummy"
+
+    async def run(self, ctx: LoopContext) -> PluginResult:
+        return PluginResult(success=True, data={"dummy": True}, message="dummy ok")
+
+
+class TestPluginBase:
+    """测试插件基类"""
+
+    def test_plugin_registry_init(self):
+        """注册中心初始化应为空"""
+        registry = PluginRegistry()
+        assert registry.get_all() == []
+
+    def test_register_plugin(self):
+        """注册插件"""
+        registry = PluginRegistry()
+        plugin = DummyPlugin()
+        registry.register(plugin)
+        assert len(registry.get_all()) == 1
+
+    def test_get_plugins_by_stage(self):
+        """按阶段获取插件"""
+        registry = PluginRegistry()
+        registry.register(DummyPlugin())
+        plugins = registry.get_plugins(LoopStage.SUMMARIZE)
+        assert len(plugins) == 1
+
+    def test_unregister_plugin(self):
+        """注销插件"""
+        registry = PluginRegistry()
+        registry.register(DummyPlugin())
+        registry.unregister("dummy")
+        assert len(registry.get_all()) == 0
+
+    def test_plugin_result_defaults(self):
+        """PluginResult 默认值"""
+        result = PluginResult()
+        assert result.success is True
+        assert result.data == {}
+        assert result.message == ""
+
+    def test_plugin_result_custom(self):
+        """PluginResult 自定义值"""
+        result = PluginResult(success=False, data={"key": "val"}, message="error")
+        assert result.success is False
+        assert result.data["key"] == "val"
+        assert result.message == "error"
+
+    def test_loop_context_defaults(self):
+        """LoopContext 默认值"""
+        ctx = LoopContext()
+        assert ctx.briefing == {}
+        assert ctx.diet_records == []
+        assert ctx.errors == []
+
+
+class TestFamilyQuizPlugins:
+    """测试家庭问卷插件"""
+
+    def test_family_recipe_quiz_plugin(self):
+        """家庭菜谱检查插件"""
+        from plugins.family_quiz import FamilyRecipeQuizPlugin
+        plugin = FamilyRecipeQuizPlugin()
+        assert plugin.stage() == LoopStage.FAMILY_QUIZ
+        assert plugin.name() == "family_recipe_quiz"
+
+    def test_weight_quiz_plugin(self):
+        """体重询问检查插件"""
+        from plugins.family_quiz import WeightQuizPlugin
+        plugin = WeightQuizPlugin()
+        assert plugin.stage() == LoopStage.FAMILY_QUIZ
+        assert plugin.name() == "weight_quiz"
+
+
+class TestSummarizePlugins:
+    """测试总结阶段插件"""
+
+    def test_diet_summary_plugin(self):
+        """饮食总结插件"""
+        from plugins.diet_summary import DietSummaryPlugin
+        plugin = DietSummaryPlugin()
+        assert plugin.stage() == LoopStage.SUMMARIZE
+        assert plugin.name() == "diet_summary"
+
+    def test_weight_check_plugin(self):
+        """体重检查插件"""
+        from plugins.weight_check import WeightCheckPlugin
+        plugin = WeightCheckPlugin()
+        assert plugin.stage() == LoopStage.SUMMARIZE
+        assert plugin.name() == "weight_check"
+
+    def test_family_memory_plugin(self):
+        """家庭记忆插件"""
+        from plugins.family_memory import FamilyMemoryPlugin
+        plugin = FamilyMemoryPlugin()
+        assert plugin.stage() == LoopStage.SUMMARIZE
+        assert plugin.name() == "family_memory"
+
+
+class TestAnalyzePlugins:
+    """测试分析阶段插件"""
+
+    def test_dri_analysis_plugin(self):
+        """DRIs 分析插件"""
+        from plugins.dri_analysis import DRIAnalysisPlugin
+        plugin = DRIAnalysisPlugin()
+        assert plugin.stage() == LoopStage.ANALYZE
+        assert plugin.name() == "dri_analysis"
+
+
+class TestBriefPlugins:
+    """测试简报阶段插件"""
+
+    def test_briefing_generator_plugin(self):
+        """简报生成插件"""
+        from plugins.briefing_generator import BriefingGeneratorPlugin
+        plugin = BriefingGeneratorPlugin()
+        assert plugin.stage() == LoopStage.BRIEF
+        assert plugin.name() == "briefing_generator"
+
+
+class TestThreeDayPlugins:
+    """测试三天总结插件"""
+
+    def test_three_day_summary_plugin(self):
+        """三天总结插件"""
+        from plugins.three_day_summary import ThreeDaySummaryPlugin
+        plugin = ThreeDaySummaryPlugin()
+        assert plugin.stage() == LoopStage.THREE_DAY
+        assert plugin.name() == "three_day_summary"
+
+
+class TestConsolidatePlugins:
+    """测试整理阶段插件"""
+
+    def test_preset_writer_plugin(self):
+        """预设写入插件"""
+        from plugins.preset_writer import PresetWriterPlugin
+        plugin = PresetWriterPlugin()
+        assert plugin.stage() == LoopStage.CONSOLIDATE
+        assert plugin.name() == "preset_writer"
+
+
+class TestPluginExecution:
+    """测试插件执行"""
+
+    def test_dummy_plugin_execution(self):
+        """虚拟插件执行"""
+        plugin = DummyPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_family_recipe_quiz_execution(self):
+        """家庭菜谱检查执行"""
+        from plugins.family_quiz import FamilyRecipeQuizPlugin
+        plugin = FamilyRecipeQuizPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_weight_quiz_execution(self):
+        """体重询问检查执行"""
+        from plugins.family_quiz import WeightQuizPlugin
+        plugin = WeightQuizPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_diet_summary_execution(self):
+        """饮食总结执行"""
+        from plugins.diet_summary import DietSummaryPlugin
+        plugin = DietSummaryPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_weight_check_execution(self):
+        """体重检查执行"""
+        from plugins.weight_check import WeightCheckPlugin
+        plugin = WeightCheckPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_family_memory_execution(self):
+        """家庭记忆执行"""
+        from plugins.family_memory import FamilyMemoryPlugin
+        plugin = FamilyMemoryPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_dri_analysis_execution(self):
+        """DRIs 分析执行"""
+        from plugins.dri_analysis import DRIAnalysisPlugin
+        plugin = DRIAnalysisPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_briefing_generator_execution(self):
+        """简报生成执行"""
+        from plugins.briefing_generator import BriefingGeneratorPlugin
+        plugin = BriefingGeneratorPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_three_day_summary_execution(self):
+        """三天总结执行"""
+        from plugins.three_day_summary import ThreeDaySummaryPlugin
+        plugin = ThreeDaySummaryPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
+
+    def test_preset_writer_execution(self):
+        """预设写入执行"""
+        from plugins.preset_writer import PresetWriterPlugin
+        plugin = PresetWriterPlugin()
+        ctx = LoopContext()
+        result = asyncio.run(plugin.run(ctx))
+        assert result.success is True
diff --git a/ui/__pycache__/app_builder.cpython-311.pyc b/ui/__pycache__/app_builder.cpython-311.pyc
index beb509d94a40815732f6915428d9c737d9fb160b..1d538f5fecc175814005d7b83127356701d9a007 100644
Binary files a/ui/__pycache__/app_builder.cpython-311.pyc and b/ui/__pycache__/app_builder.cpython-311.pyc differ
diff --git a/ui/app_builder.py b/ui/app_builder.py
index 617f0fb98dde69e726ad1be21c40679f580bbc32..0af70b6030799ad63821ffad40c68327f7dacede 100644
--- a/ui/app_builder.py
+++ b/ui/app_builder.py
@@ -1,7 +1,11 @@
 """
 PregoPal - Gradio 界面构建
-============================
-所有 UI 组件和事件绑定集中在此文件。
+===========================
+4 个子页面：
+  1. 🎙️ 语音交互（主界面）
+  2. 👨‍👩‍👧‍👦 家庭饮食习惯
+  3. 📊 三天总结
+  4. 📈 营养报告
 """
 
 import datetime
@@ -11,6 +15,9 @@ from modules.voiceprint import VoiceprintManager
 from modules.meal_recommender import MealRecommender
 from modules.diet_logger import DietLogger
 from modules.nutrition_analyzer import NutritionAnalyzer
+from modules.family_manager import RecipeManager, PreferenceManager, MemoryManager
+from modules.diet_extractor import DietExtractor
+from modules.nutrition_standards import DRIsParser
 
 # ============================================================
 # 全局实例（单例）
@@ -21,12 +28,11 @@ diet_logger = DietLogger()
 nutrition_analyzer = NutritionAnalyzer()
 
 
-def create_app():
+def create_app(loop=None):
     """创建主应用"""
 
     with gr.Blocks(title="PregoPal - 孕期陪护AI助手") as demo:
 
-        # ==================== 顶部导航 ====================
         gr.Markdown(
             """
             # 🌸 PregoPal - 孕期陪护AI助手
@@ -34,182 +40,262 @@ def create_app():
             """
         )
 
-        # ==================== Tab 1: 声纹识别 ====================
-        with gr.Tab("🔊 声纹识别"):
-            gr.Markdown("### 识别家庭成员，记录谁在说话")
+        briefing = loop.get_briefing() if loop else {}
 
+        # ==================== 页面 1: 语音交互 ====================
+        with gr.Tab("🎙️ 语音交互"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("#### 🆕 注册新成员")
-                    member_name = gr.Textbox(label="姓名", placeholder="例如：小明")
-                    member_relation = gr.Dropdown(
-                        label="身份",
-                        choices=["孕妇", "丈夫", "婆婆", "妈妈", "爸爸", "其他家人"],
-                        value="孕妇"
-                    )
-                    audio_register = gr.Audio(label="录制语音", type="filepath")
-                    register_btn = gr.Button("📝 注册声纹", variant="primary")
-                    register_result = gr.Textbox(label="注册结果", interactive=False)
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(label="💬 对话", height=400)
+                    with gr.Row():
+                        msg = gr.Textbox(
+                            label="输入消息",
+                            placeholder="例如：我今天中午吃了番茄牛腩",
+                            scale=4
+                        )
+                        send_btn = gr.Button("发送", variant="primary", scale=1)
+                    with gr.Row():
+                        audio_input = gr.Audio(label="🎤 语音输入", type="filepath")
+                        clear_btn = gr.Button("🗑️ 清空对话", size="sm")
 
                 with gr.Column(scale=1):
-                    gr.Markdown("#### 🔍 识别说话人")
-                    audio_identify = gr.Audio(label="录制语音进行识别", type="filepath")
-                    identify_btn = gr.Button("🔊 识别身份", variant="primary")
-                    identify_result = gr.Textbox(label="识别结果", interactive=False)
+                    gr.Markdown("#### 🔊 声纹识别")
+                    with gr.Group():
+                        audio_register = gr.Audio(label="注册", type="filepath")
+                        member_name = gr.Textbox(label="姓名", placeholder="小明")
+                        member_relation = gr.Dropdown(
+                            label="身份",
+                            choices=["孕妇", "丈夫", "婆婆", "妈妈", "爸爸", "其他家人"],
+                            value="孕妇"
+                        )
+                        register_btn = gr.Button("📝 注册", variant="primary", size="sm")
+                        register_result = gr.Textbox(label="", interactive=False, lines=1)
+
+                    with gr.Group():
+                        audio_identify = gr.Audio(label="识别", type="filepath")
+                        identify_btn = gr.Button("🔊 识别", variant="primary", size="sm")
+                        identify_result = gr.Textbox(label="", interactive=False, lines=1)
+
+                    gr.Markdown("#### 📋 今日简报")
+                    briefing_display = gr.JSON(value=briefing, label="")
+
+            # 对话事件
+            def respond(message, chat_history):
+                if not message:
+                    return "", chat_history
+
+                extracted = DietExtractor.robust_extract(message)
+                response_parts = ["👋 收到！"]
+
+                if extracted["diets"]:
+                    for diet in extracted["diets"]:
+                        meals_str = "、".join(
+                            f"{k}: {v}" for k, v in diet.get("meals", {}).items()
+                        )
+                        response_parts.append(f"✅ 已记录饮食：{meals_str}")
+                        date_str = diet.get("日期", datetime.date.today().isoformat())
+                        diet_logger.add_record(
+                            member_name=diet.get("记录人", "用户"),
+                            member_relation="家人",
+                            date=date_str,
+                            meals=diet.get("meals", {}),
+                            notes=diet.get("备注", "")
+                        )
+
+                if extracted["recipes"]:
+                    for recipe in extracted["recipes"]:
+                        name = recipe.get("菜名", "")
+                        if name:
+                            result = RecipeManager.add_recipe(
+                                name=name,
+                                cook=recipe.get("制作人", ""),
+                                difficulty=recipe.get("难度", ""),
+                                ingredients=recipe.get("食材", ""),
+                                notes=recipe.get("备注", "")
+                            )
+                            response_parts.append(f"✅ {result}")
+
+                if extracted["preferences"]:
+                    for pref in extracted["preferences"]:
+                        PreferenceManager.add_member(
+                            name=pref.get("人员", ""),
+                            role="家人",
+                            preferences=pref.get("内容", "") if pref.get("类型") == "偏好" else "",
+                            avoid=pref.get("内容", "") if pref.get("类型") == "忌口" else "",
+                            allergies=pref.get("内容", "") if pref.get("类型") == "过敏" else "",
+                        )
+                    response_parts.append("✅ 已记录饮食偏好")
+
+                if extracted["weights"]:
+                    for w in extracted["weights"]:
+                        response_parts.append(f"✅ 已记录体重：{w.get('体重', '')}kg")
+
+                if extracted["thinking"]:
+                    step = extracted["thinking"].get("当前步骤", "")
+                    next_step = extracted["thinking"].get("下一步", "")
+                    response_parts.append(f"🤔 当前：{step} → 下一步：{next_step}")
+
+                if len(response_parts) == 1:
+                    if any(kw in message for kw in ["吃了", "想吃", "午餐", "晚餐", "早餐"]):
+                        response_parts.append("我来帮你记录！下次可以直接说「我吃了...」我会自动记录。")
+                    elif any(kw in message for kw in ["菜谱", "会做", "做饭"]):
+                        response_parts.append("好的，我来记录家庭菜谱！")
+                    else:
+                        response_parts.append("有什么我可以帮你的吗？比如记录饮食、推荐食谱、或者聊聊今天的感受。")
+
+                response = "\n\n".join(response_parts)
+                chat_history.append((message, response))
+                return "", chat_history
+
+            send_btn.click(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])
+            msg.submit(respond, inputs=[msg, chatbot], outputs=[msg, chatbot])
+            clear_btn.click(lambda: None, outputs=chatbot)
 
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### 📋 家庭成员列表")
-                    refresh_members_btn = gr.Button("🔄 刷新列表")
-                    members_display = gr.Textbox(label="已注册成员", interactive=False)
-
-            # 事件绑定
             register_btn.click(
                 fn=lambda name, rel, audio: voiceprint_mgr.register_member(name, rel, audio),
                 inputs=[member_name, member_relation, audio_register],
                 outputs=[gr.State(), register_result]
-            ).then(
-                fn=lambda: voiceprint_mgr.get_members_list(),
-                outputs=members_display
             )
-
             identify_btn.click(
                 fn=lambda audio: voiceprint_mgr.identify_speaker(audio),
                 inputs=[audio_identify],
                 outputs=[gr.State(), identify_result]
             )
 
-            refresh_members_btn.click(
-                fn=lambda: voiceprint_mgr.get_members_list(),
-                outputs=members_display
-            )
-
-        # ==================== Tab 2: 今日菜品推荐 ====================
-        with gr.Tab("🍳 今日菜品推荐"):
-            gr.Markdown("### 根据孕妇的需求推荐今日菜品")
-
+        # ==================== 页面 2: 家庭饮食习惯 ====================
+        with gr.Tab("👨‍👩‍👧‍👦 家庭饮食习惯"):
+            with gr.Tabs():
+                with gr.Tab("🥗 饮食偏好"):
+                    with gr.Row():
+                        with gr.Column():
+                            pref_name = gr.Textbox(label="姓名", placeholder="小明")
+                            pref_role = gr.Dropdown(
+                                label="身份",
+                                choices=["孕妇", "丈夫", "婆婆", "妈妈", "爸爸", "其他家人"],
+                                value="孕妇"
+                            )
+                            pref_likes = gr.Textbox(label="偏好", placeholder="喜欢吃什么？", lines=1)
+                            pref_avoid = gr.Textbox(label="忌口", placeholder="不吃什么？", lines=1)
+                            pref_allergy = gr.Textbox(label="过敏", placeholder="对什么过敏？", lines=1)
+                            save_pref_btn = gr.Button("💾 保存", variant="primary", size="sm")
+
+                        with gr.Column():
+                            refresh_pref_btn = gr.Button("🔄 刷新", size="sm")
+                            pref_display = gr.Textbox(label="", interactive=False, lines=12)
+
+                    save_pref_btn.click(
+                        fn=lambda n, r, p, a, al: PreferenceManager.add_member(n, r, p, a, al, ""),
+                        inputs=[pref_name, pref_role, pref_likes, pref_avoid, pref_allergy],
+                        outputs=[gr.Textbox()]
+                    ).then(fn=lambda: PreferenceManager.format_for_prompt(), outputs=pref_display)
+
+                    refresh_pref_btn.click(fn=lambda: PreferenceManager.format_for_prompt(), outputs=pref_display)
+
+                with gr.Tab("🍳 家庭菜谱"):
+                    with gr.Row():
+                        with gr.Column():
+                            recipe_name = gr.Textbox(label="菜名", placeholder="番茄牛腩")
+                            recipe_cook = gr.Textbox(label="制作人", placeholder="谁会做？")
+                            recipe_diff = gr.Dropdown(label="难度", choices=["简单", "中等", "困难"], value="中等")
+                            recipe_ingredients = gr.Textbox(label="食材", placeholder="主要食材", lines=1)
+                            save_recipe_btn = gr.Button("💾 添加", variant="primary", size="sm")
+
+                        with gr.Column():
+                            refresh_recipe_btn = gr.Button("🔄 刷新", size="sm")
+                            recipe_display = gr.Textbox(label="", interactive=False, lines=12)
+
+                    save_recipe_btn.click(
+                        fn=lambda n, c, d, i: RecipeManager.add_recipe(n, c, d, i, ""),
+                        inputs=[recipe_name, recipe_cook, recipe_diff, recipe_ingredients],
+                        outputs=[gr.Textbox()]
+                    ).then(fn=lambda: RecipeManager.format_for_prompt(), outputs=recipe_display)
+
+                    refresh_recipe_btn.click(fn=lambda: RecipeManager.format_for_prompt(), outputs=recipe_display)
+
+                with gr.Tab("📖 家庭记忆"):
+                    with gr.Row():
+                        with gr.Column():
+                            memory_type = gr.Dropdown(label="类型", choices=["关系", "事件", "日常"], value="日常")
+                            memory_content = gr.Textbox(label="内容", placeholder="记录家庭关系、重要事件或日常点滴", lines=2)
+                            save_memory_btn = gr.Button("💾 保存", variant="primary", size="sm")
+
+                        with gr.Column():
+                            refresh_memory_btn = gr.Button("🔄 刷新", size="sm")
+                            memory_display = gr.Textbox(label="", interactive=False, lines=12)
+
+                    def save_memory(m_type, content):
+                        if m_type == "事件":
+                            return MemoryManager.add_event(content)
+                        return MemoryManager.add_daily(f"[{m_type}] {content}")
+
+                    save_memory_btn.click(
+                        fn=save_memory, inputs=[memory_type, memory_content], outputs=[gr.Textbox()]
+                    ).then(fn=lambda: MemoryManager.format_for_prompt(), outputs=memory_display)
+
+                    refresh_memory_btn.click(fn=lambda: MemoryManager.format_for_prompt(), outputs=memory_display)
+
+        # ==================== 页面 3: 三天总结 ====================
+        with gr.Tab("📊 三天总结"):
             with gr.Row():
-                with gr.Column():
-                    trimester = gr.Radio(
+                with gr.Column(scale=1):
+                    trimester_select = gr.Radio(
                         label="孕期阶段",
                         choices=["孕早期", "孕中期", "孕晚期"],
                         value="孕中期"
                     )
-                    preference = gr.Textbox(
-                        label="今天想吃什么？",
-                        placeholder="例如：想吃清淡的、想吃鱼、不想吃油腻的...",
-                        lines=2
-                    )
-                    restrictions = gr.Textbox(
-                        label="饮食禁忌（可选）",
-                        placeholder="例如：不能吃海鲜、不能吃辣...",
-                        lines=1
-                    )
-                    recommend_btn = gr.Button("🎯 生成今日推荐", variant="primary", size="lg")
-
-                with gr.Column():
-                    meal_result = gr.Textbox(label="📋 今日食谱推荐", lines=15)
-
-            # 事件绑定
-            recommend_btn.click(
-                fn=lambda tri, pref, rest: meal_recommender.format_meal_plan(
-                    meal_recommender.get_recommendation(pref, tri, rest)
-                ),
-                inputs=[trimester, preference, restrictions],
-                outputs=meal_result
+                    run_3day_btn = gr.Button("📊 运行分析", variant="primary")
+
+                with gr.Column(scale=2):
+                    three_day_result = gr.Textbox(label="📋 分析结果", interactive=False, lines=15)
+                    menu_suggestion = gr.Textbox(label="💡 菜单改进建议", interactive=False, lines=4)
+
+            def run_three_day_summary(trimester):
+                from plugins.three_day_summary import ThreeDaySummaryPlugin
+                from plugins.base import LoopContext
+                import asyncio
+
+                ctx = LoopContext()
+                ctx.briefing["trimester"] = trimester
+                asyncio.run(ThreeDaySummaryPlugin().run(ctx))
+
+                report = ctx.briefing.get("three_day_summary", {}).get("report", "暂无数据")
+                deficits = ctx.briefing.get("three_day_summary", {}).get("persistent_deficits", [])
+
+                suggestions = []
+                if deficits:
+                    suggestions.append("📋 建议增加以下食材到家庭菜单：")
+                    for n in deficits[:3]:
+                        foods = DRIsParser.RICH_FOODS.get(n, [])
+                        if foods:
+                            suggestions.append(f"  • {n} → {'、'.join(foods[:4])}")
+                else:
+                    suggestions.append("✅ 近三天营养状况良好！")
+
+                return report, "\n".join(suggestions)
+
+            run_3day_btn.click(
+                fn=run_three_day_summary,
+                inputs=[trimester_select],
+                outputs=[three_day_result, menu_suggestion]
             )
 
-        # ==================== Tab 3: 饮食记录 ====================
-        with gr.Tab("📝 饮食记录"):
-            gr.Markdown("### 记录孕妇的每日饮食，自动保存为Markdown日志")
-
+        # ==================== 页面 4: 营养报告 ====================
+        with gr.Tab("📈 营养报告"):
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### 🍽️ 记录今日饮食")
-                    log_date = gr.Textbox(label="日期", value=datetime.date.today().isoformat())
-                    log_member_name = gr.Textbox(label="记录人姓名", placeholder="例如：小明")
-                    log_member_relation = gr.Dropdown(
-                        label="记录人身份",
-                        choices=["孕妇", "丈夫", "婆婆", "妈妈", "爸爸", "其他家人"],
-                        value="孕妇"
-                    )
-                    log_breakfast = gr.Textbox(label="早餐", placeholder="吃了什么？")
-                    log_lunch = gr.Textbox(label="午餐", placeholder="吃了什么？")
-                    log_dinner = gr.Textbox(label="晚餐", placeholder="吃了什么？")
-                    log_snack = gr.Textbox(label="加餐", placeholder="吃了什么？")
-                    log_mood = gr.Textbox(label="今日心情", placeholder="今天感觉怎么样？")
-                    log_notes = gr.Textbox(label="备注", placeholder="其他想记录的内容...", lines=2)
-                    save_log_btn = gr.Button("💾 保存饮食记录", variant="primary", size="lg")
-
-                with gr.Column():
-                    gr.Markdown("#### 📂 已保存的日志")
-                    refresh_logs_btn = gr.Button("🔄 刷新日志列表")
-                    log_result = gr.Textbox(label="保存结果", interactive=False)
-                    log_files_display = gr.Textbox(label="Markdown日志文件", interactive=False, lines=10)
-
-            # 事件绑定
-            def save_diet_log(name, relation, date, breakfast, lunch, dinner, snack, mood, notes):
-                meals = {}
-                if breakfast: meals["早餐"] = breakfast
-                if lunch: meals["午餐"] = lunch
-                if dinner: meals["晚餐"] = dinner
-                if snack: meals["加餐"] = snack
-
-                if not meals:
-                    return "⚠️ 请至少填写一餐的内容"
-
-                record, md_path = diet_logger.add_record(name, relation, date, meals, mood, notes)
-                return f"✅ 记录已保存！\n📄 Markdown文件: {md_path.name}"
-
-            def list_log_files():
-                files = diet_logger.get_all_markdown_files()
-                if not files:
-                    return "暂无日志文件"
-                return "\n".join(f"📄 {f.name}" for f in files[:20])
-
-            save_log_btn.click(
-                fn=save_diet_log,
-                inputs=[log_member_name, log_member_relation, log_date,
-                        log_breakfast, log_lunch, log_dinner, log_snack,
-                        log_mood, log_notes],
-                outputs=log_result
-            ).then(
-                fn=list_log_files,
-                outputs=log_files_display
-            )
-
-            refresh_logs_btn.click(
-                fn=list_log_files,
-                outputs=log_files_display
-            )
-
-        # ==================== Tab 4: 营养报告 ====================
-        with gr.Tab("📊 营养报告"):
-            gr.Markdown("### 分析饮食习惯，生成可视化营养报告")
-
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### ⚙️ 分析设置")
-                    analysis_days = gr.Slider(
-                        label="分析天数",
-                        minimum=1, maximum=30, value=7, step=1
-                    )
-                    generate_btn = gr.Button("📊 生成营养报告", variant="primary", size="lg")
+                with gr.Column(scale=1):
+                    analysis_days = gr.Slider(label="分析天数", minimum=1, maximum=30, value=7, step=1)
+                    generate_btn = gr.Button("📊 生成报告", variant="primary")
 
-                with gr.Column():
-                    gr.Markdown("#### 📋 报告预览")
-                    report_text = gr.Textbox(label="文本报告", lines=15, interactive=False)
+                with gr.Column(scale=2):
+                    report_text = gr.Textbox(label="📋 文本报告", interactive=False, lines=12)
 
             with gr.Row():
-                with gr.Column():
-                    report_plot = gr.Plot(label="可视化报告图表")
+                report_plot = gr.Plot(label="📊 可视化图表")
 
             with gr.Row():
-                with gr.Column():
-                    export_md_btn = gr.Button("📥 导出Markdown报告")
-                    export_result = gr.Textbox(label="导出结果", interactive=False)
+                export_md_btn = gr.Button("📥 导出 Markdown", size="sm")
+                export_result = gr.Textbox(label="", interactive=False, lines=1)
 
-            # 事件绑定
             def generate_report(days):
                 records = diet_logger.get_recent_records(days=int(days))
                 analysis = nutrition_analyzer.analyze_diet(records)
@@ -221,54 +307,9 @@ def create_app():
                 records = diet_logger.get_recent_records(days=int(days))
                 analysis = nutrition_analyzer.analyze_diet(records)
                 md_path = nutrition_analyzer.export_report_markdown(analysis)
-                return f"✅ 报告已导出: {md_path.name}"
-
-            generate_btn.click(
-                fn=generate_report,
-                inputs=[analysis_days],
-                outputs=[report_text, report_plot]
-            )
-
-            export_md_btn.click(
-                fn=export_report,
-                inputs=[analysis_days],
-                outputs=export_result
-            )
-
-        # ==================== Tab 5: 关于 ====================
-        with gr.Tab("💝 关于"):
-            gr.Markdown(
-                """
-                ## 🌸 PregoPal - 孕期陪护AI助手
-
-                ### 功能介绍
+                return f"✅ 已导出: {md_path.name}"
 
-                | 功能 | 说明 |
-                |------|------|
-                | 🔊 **声纹识别** | 识别家庭成员身份，自动区分谁在说话 |
-                | 🍳 **菜品推荐** | 根据孕期阶段和口味偏好推荐今日食谱 |
-                | 📝 **饮食记录** | 记录每日饮食，自动保存为Markdown日志 |
-                | 📊 **营养报告** | 分析饮食数据，生成可视化营养报告 |
-
-                ### 技术栈
-
-                - **前端框架**: Gradio
-                - **数据分析**: NumPy, Pandas, Matplotlib
-                - **音频处理**: SoundFile, Librosa
-                - **数据存储**: JSON + Markdown
-
-                ### 团队
-
-                - 项目参与: build-small-hackathon
-                - 开源协议: MIT
-
-                ### ⚠️ 免责声明
-
-                本应用仅供参考，不构成医疗建议。如有特殊饮食需求或健康问题，请咨询专业医生或营养师。
-
-                ---
-                *用AI温暖每一个孕期家庭 ❤️*
-                """
-            )
+            generate_btn.click(fn=generate_report, inputs=[analysis_days], outputs=[report_text, report_plot])
+            export_md_btn.click(fn=export_report, inputs=[analysis_days], outputs=export_result)
 
     return demo