feat: AI 提示词模块化 + AI 同意门控 + AI 草稿存储 + 意图路由 + 医疗引用知识库 + 多页面 UI 优化

- AI 提示词拆分为 markdown 模块（Prompts/global + modules + rag + router）
- 新增 AI 同意门控（用户需同意后才能使用 AI 功能）
- 新增 AI 录入草稿存储（AiEntryDraftContracts/EfAiEntryDraftStore/AiEntryDraftRecord）
- 新增 AI 意图路由（ai_intent_router）
- 新增医疗引用知识库（MedicalCitationKnowledge）
- 重构 prompt_manager 和 ai_chat_endpoints
- 优化聊天/趋势/档案/抽屉/医生端等多个页面 UI
- 新增 agent 插画和趋势指标图标资源
- 删除 HANDOFF-2026-07-17.md

.gitignore

@@ -4,10 +4,17 @@
 *.key
 *.pfx
 
+# Android release keystore
+health_app/android/**/*.jks
+health_app/android/key.properties
+
 # .NET build outputs
 backend/**/bin/
 backend/**/obj/
 
+# PostgreSQL local data
+backend/pgdata/
+
 # Flutter build outputs
 health_app/build/
 health_app/.dart_tool/
@@ -32,6 +39,21 @@ health_app/ios/.symlinks/
 .vs/
 .vscode/
 
+# Uploads & logs
+backend/src/Health.WebApi/uploads/
+backend/src/Health.WebApi/data-protection-keys/
+*.log
+*.txt
+*.jpg
+*.png
+!backend/src/Health.WebApi/wwwroot/app-icon.png
+!health_app/assets/branding/*.png
+!health_app/android/app/src/main/res/drawable/launch_brand.png
+!health_app/android/app/src/main/res/drawable-v21/launch_brand.png
+
+# Claude
+.claude/
+
 # OS
 .DS_Store
 Thumbs.db

AGENTS.md

@@ -0,0 +1,57 @@
+# 项目协作准则
+
+本文件适用于整个 `health_project` 仓库。处理任务时按改动风险分级，验证强度与风险匹配，避免小改动套用重型流程。
+
+## 默认规则
+
+- 默认不执行 `git add`、`git commit`、`git push`、合并、回滚或创建分支；只有用户明确要求时才进行。
+- 保留工作区中用户已有的未提交改动，不覆盖、不清理、不顺带重构。
+- 数据库、上传文件、密钥、生产配置和用户数据不视为普通文件；任何写入、迁移、删除或恢复操作必须先获得用户明确确认。
+- 只修改用户指定的端和功能范围。发现相邻问题可以说明，但不要擅自扩大修改范围。
+
+## 小改动：快速处理
+
+适用于颜色、字号、间距、圆角、文案、图标、单个组件简单布局等不涉及状态、接口和数据的调整。
+
+1. 确认具体文件和修改范围。
+2. 直接完成修改。
+3. 执行格式化。
+4. 进行一次快速编译或静态检查，二者按实际需要选择。
+5. 简要说明改动结果。
+
+不运行完整测试套件，不额外编写计划文档，不提交 Git。
+
+## 中等改动：针对性验证
+
+适用于页面交互、Provider、路由、表单逻辑、接口调用、跨端数据展示、启动脚本和配置修改。
+
+1. 检查相关代码和现有改动。
+2. 修改前简要说明方案。
+3. 完成代码修改和格式化。
+4. 运行静态检查或编译。
+5. 只运行与本次改动直接相关的测试。
+6. 必要时启动对应页面或接口验证一次。
+
+默认不提交 Git。
+
+## 大改动：完整验证
+
+适用于完整新功能、多页面联动、登录、聊天、蓝牙、AI 核心流程、后端结构调整和大范围重构。
+
+1. 阅读相关代码、文档和交接资料。
+2. 与用户确认范围、交互和成功标准。
+3. 分步骤实施，并在关键阶段做针对性检查。
+4. 完成后运行 Flutter 和后端相关完整测试。
+5. 汇总改动、验证结果和遗留问题。
+
+## 高风险改动：确认后执行
+
+适用于数据库迁移或数据修复、大量删除、用户数据、上传文件、签名、生产配置、部署，以及 Git 提交、推送、合并和回滚。
+
+1. 先进行只读检查，确认精确目标和影响。
+2. 向用户说明风险、影响范围和恢复方式。
+3. 必要时先制作可验证的备份。
+4. 获得用户明确确认后再执行。
+5. 执行后进行完整验证并报告结果。
+
+用户在具体任务中的直接指令始终优先于本文件。

CLAUDE.md

@@ -19,6 +19,7 @@
 
 -前端用sqlite存储信息，不用shared_preferences
 - 用 Riverpod 管理所有状态和页面跳转
+- com.datalumina.YYA  applicationId用这个，这个是有要求的
 ## 运行与测试
 
 - 测试时自行启动后端，通过浏览器 DevTools 发送请求验证

PC

@@ -0,0 +1 @@
+  Phone - forwarding OK

audit/2026-07-14/08-followups.xml

@@ -0,0 +1 @@
+<?xml version='1.0' encoding='UTF-8' standalone='yes' ?><hierarchy rotation="0"><node index="0" text="" resource-id="" class="android.widget.FrameLayout" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.widget.LinearLayout" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="android:id/content" class="android.widget.FrameLayout" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.widget.FrameLayout" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="true" focused="true" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="true" enabled="true" focusable="true" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,3200]"><node index="0" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="false" enabled="true" focusable="false" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[0,0][1440,302]"><node NAF="true" index="0" text="" resource-id="" class="android.widget.Button" package="com.datalumina.YYA" content-desc="" checkable="false" checked="false" clickable="true" enabled="true" focusable="true" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[14,127][182,295]" /><node index="1" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="复查随访" checkable="false" checked="false" clickable="false" enabled="true" focusable="true" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[600,173][840,250]" /></node><node index="1" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="暂无随访安排" checkable="false" checked="false" clickable="false" enabled="true" focusable="true" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[600,1816][840,1872]" /><node index="2" text="" resource-id="" class="android.view.View" package="com.datalumina.YYA" content-desc="医生创建随访后将显示在这里" checkable="false" checked="false" clickable="false" enabled="true" focusable="true" focused="false" scrollable="false" long-clickable="false" password="false" selected="false" bounds="[401,1886][1039,1952]" /></node></node></node></node></node></node></node></node></hierarchy>

audit/2026-07-14/project-audit-report.md

@@ -0,0 +1,261 @@
+# 小脉健康项目全面检查报告
+
+检查日期：2026-07-14  
+检查范围：Flutter Android 真机主要用户路径、Flutter 静态检查与测试、.NET 后端测试、前后端接口对应关系、用户/医生/管理员业务逻辑、权限安全、合规页面与 Android/iOS 发布准备。  
+本轮只检查，没有修改业务代码，也没有使用 Docker。
+
+## 一、总体结论
+
+项目主体功能已经比较完整，普通用户主路径能进入，当前 Flutter 静态检查通过，Flutter 47 项测试和后端 44 项测试全部通过。但测试通过不等于已经稳定：本次仍确认了多项自动测试没有覆盖的真实断点。
+
+当前不适合进入正式环境或商店审核。最优先的不是继续统一小间距，而是先处理问诊鉴权、管理员验证码、上传文件访问、蓝牙上传、账号注销清理和正式包权限。这些问题会影响真实数据、安全或用户是否能完成任务。
+
+## 二、必须先修的问题
+
+### 1. AI 流式聊天的 token 只被“读出来”，没有验证真伪
+
+- 用户表现：正常用户不一定马上发现，但攻击者可以自己伪造一个 token，冒充任意用户进入 AI 对话、读取该用户上下文，并可能触发健康数据写入。
+- 原因：SSE 接口没有强制登录；备用 token 处理只解析 JWT 内容，没有校验签名、过期时间、签发方和接收方。
+- 位置：`backend/src/Health.WebApi/Endpoints/ai_chat_endpoints.cs` 的 `GetUserIdFromToken`。
+- 优先级：最高。
+
+### 2. 医生问诊实时通道没有登录和问诊归属校验
+
+- 用户表现：知道问诊编号的人可以加入房间，甚至把自己声明成“用户”或“医生”发送消息；消息还会真实写入数据库。
+- 原因：SignalR Hub 没有鉴权，加入房间和发送消息时也没有核对当前账号是否属于该患者或医生。
+- 位置：`backend/src/Health.WebApi/Hubs/ConsultationHub.cs`。
+- 优先级：最高。
+
+### 3. 管理员存在固定手机号和固定验证码
+
+- 用户表现：正式环境若沿用当前代码，知道固定号码的人可用 `000000` 登录管理员端。
+- 原因：管理员手机号和验证码直接写在认证服务中，而且不只在开发环境生效。
+- 位置：`backend/src/Health.Infrastructure/Auth/AuthService.cs`。
+- 优先级：最高。
+
+### 4. 上传的报告、聊天图片和 PDF 可被未登录访问
+
+- 用户表现：文件链接一旦泄露，不登录也能打开健康报告或聊天附件。
+- 原因：整个 `/uploads` 目录作为公开静态目录提供，没有按用户、医生关系或临时授权校验。
+- 位置：`backend/src/Health.WebApi/Program.cs` 的上传目录静态映射。
+- 优先级：最高。
+
+### 5. 蓝牙血压计能读到数据，但自动上传会失败
+
+- 用户表现：设备连接成功、血压已经读取，最后却提示上传失败；血压和心率不会真正保存到后端。
+- 原因：前端提交到 `/api/health-records/batch`，当前后端没有这个接口。
+- 位置：`health_app/lib/pages/device/device_management_page.dart` 与 `backend/src/Health.WebApi/Endpoints/health_endpoints.cs`。
+- 优先级：高。
+
+### 6. 每次打开医生问诊页都会创建一条新问诊并消耗次数
+
+- 用户表现：只是进入页面看一下、没有发送任何内容，也会新增问诊；反复进出会快速消耗每月次数。显示剩余 0 次时仍可能继续创建，甚至出现负数。
+- 原因：前端初始化先查次数，然后无条件创建；后端创建接口没有真正执行三次上限，也没有验证医生仍然有效。
+- 位置：`health_app/lib/providers/consultation_provider.dart`、`backend/src/Health.WebApi/Endpoints/consultation_endpoints.cs`。
+- 优先级：高。
+
+### 7. 问诊消息发送失败时仍显示为已发送
+
+- 用户表现：网络断开或服务器失败后，消息仍留在聊天里，没有失败标记和重试入口，用户会误以为医生已经收到。
+- 原因：发送异常被静默忽略，本地消息没有回滚或转成失败状态。
+- 位置：`health_app/lib/providers/consultation_provider.dart` 的 `sendMessage`。
+- 优先级：高，且不符合“不能假成功”的项目要求。
+
+### 8. Android 正式包没有网络权限
+
+- 用户表现：Debug 真机可联网，但以后构建 release 包后，所有登录、数据、AI 和报告请求都无法联网。
+- 原因：`INTERNET` 只在 debug/profile Manifest 中，main Manifest 没有；release 不会合并 debug 配置。
+- 位置：`health_app/android/app/src/main/AndroidManifest.xml`。
+- 优先级：正式包前必须修。
+
+### 9. 账号注销只删数据库记录，不会清理服务器上传文件
+
+- 用户表现：App 显示账号已删除，但报告原图、聊天图片、PDF 等仍可能留在服务器目录；公开链接仍可能继续访问。
+- 原因：账号注销批量删除数据库数据时没有收集并删除物理文件。单独删除报告有删文件，注销账号没有走同一流程。
+- 位置：`backend/src/Health.Infrastructure/Users/EfUserRepository.cs`。
+- 优先级：高，涉及合规承诺和真实删除。
+
+### 10. iOS 相机和相册权限说明缺失
+
+- 用户表现：以后在 iPhone 上拍饮食、拍报告或选相册时，系统可能直接终止 App，而不是正常弹出权限框。
+- 原因：Info.plist 有蓝牙说明，但没有 `NSCameraUsageDescription` 和 `NSPhotoLibraryUsageDescription`。
+- 位置：`health_app/ios/Runner/Info.plist`。
+- 优先级：iOS 调试前必须修。
+
+## 三、重要功能和稳定性问题
+
+### 11. 多个请求同时遇到登录过期时，可能刚刷新成功又被强制退出
+
+多个 401 会同时拿同一个刷新 token。第一个请求刷新并保存新 token 后，第二个请求可能因旧 token 已失效而失败，随后把刚保存的新 token 一并清掉。用户会偶发跳回登录页。
+
+位置：`health_app/lib/core/api_client.dart` 的 401 刷新逻辑。
+
+### 12. 启动时只要服务器暂时连不上，就把用户当成未登录
+
+刷新 token 的请求遇到断网或本地后端未启动时，认证状态直接变为未登录，但本地 token 又没有清除。用户会看到登录页，网络恢复后也不会自动重试，只能重启或重新操作。
+
+位置：`health_app/lib/providers/auth_provider.dart` 的 `_checkAuth`。
+
+### 13. 问诊轮询用随机 GUID 判断“之后的消息”，可能漏消息
+
+SignalR 失败后会回退轮询。后端把随机消息 ID 与上一条随机 ID 做大小比较，这不等于消息时间顺序，可能漏掉医生新回复。正确游标应基于服务器时间或稳定递增字段。
+
+位置：`backend/src/Health.WebApi/Endpoints/consultation_endpoints.cs`。
+
+### 14. 问诊 AI 开场白只存在前端，没有保存
+
+用户看到的“AI 分身问候”不是数据库消息，医生端看不到；重新进入又会新建问诊并生成另一条本地问候，历史不连续。
+
+位置：`health_app/lib/providers/consultation_provider.dart`。
+
+### 15. 短信验证码没有频率、次数和防刷限制
+
+发送接口可反复调用，验证码校验也没有失败次数限制。正式短信接入后会产生短信轰炸、费用和验证码暴力尝试风险。
+
+位置：认证端点和 `AuthService`。
+
+### 16. 管理员新增、停用、修改、删除医生时，几套医生数据可能不同步
+
+- 手机号已属于普通用户时，仍可创建医生实体，但不会把已有用户升级并绑定医生档案。
+- 修改医生手机号/姓名时，没有同步医生登录账号与医生档案。
+- 停用医生只改一处状态，医生档案的状态可能仍是启用。
+- 删除医生后，医生登录用户仍可能保留 Doctor 角色，但档案已失去关联，登录后只能看到“档案未关联”。
+- 医生手机号没有唯一约束，可能出现重复医生。
+
+位置：`backend/src/Health.Infrastructure/Admin/AdminService.cs`。
+
+### 17. 附件本地路径没有限制在 uploads 目录内
+
+附件 URL 中的相对路径直接拼到服务器路径，没有做规范化后再确认最终路径仍位于 uploads 内，也没有核对文件是否属于当前用户。这会带来跨用户读取或路径越界风险。
+
+位置：`backend/src/Health.Infrastructure/AI/AttachmentContextBuilder.cs`。
+
+### 18. 通知点击先联网标记已读，失败时目的页面也打不开
+
+用户点一条未读通知时，先请求后端标记已读；如果这一步失败，后续报告/用药/健康页面不会打开，也没有明确提示。
+
+位置：`health_app/lib/pages/notifications/notification_center_page.dart`。
+
+### 19. 用户端与医生端部分“今天/本月”按 UTC 计算
+
+中国时区的凌晨时段可能被算到上一天或上个月，影响问诊次数、今日随访和提醒归类。正式环境应统一明确业务时区。
+
+位置：问诊和医生工作台中使用 `DateTime.UtcNow.Date` 或 UTC 月份的逻辑。
+
+## 四、UI 与交互问题
+
+### 20. 用药和运动列表默认露出整片红色删除背景
+
+真机截图中，用药行和运动行在没有滑动时已经整行变红；运动行还出现“打卡”和“删除”重叠。用户会误以为数据异常或正处于危险删除状态。
+
+原因是通用滑动删除组件始终铺红色底层，而这些列表行本身透明。测试只验证滑动动作，没有验证未滑动时的最终视觉。
+
+证据：`05-medications.png`、`09-exercise.png`。  
+位置：`health_app/lib/widgets/common_widgets.dart`。
+
+### 21. 首页多个纯图标按钮缺少无障碍名称
+
+真机可访问性结构中，菜单、附件、输入框和发送按钮等多个可点击区域没有名称。普通用户能凭图标猜，读屏用户无法知道用途。
+
+证据：`01-current.xml`。
+
+### 22. 删除动作风格不统一
+
+报告、用药、运动使用滑动删除，通知使用整行侧滑，蓝牙设备直接显示红色垃圾桶，设置页则用大按钮。交互成本和误触风险不同。建议统一为“列表行滑动后显示删除 + 二次确认用于高价值数据”。
+
+### 23. 设置页的红色占比过重
+
+“删除账号”和“退出登录”两个大面积危险操作占据页面最强视觉层级，反而压过消息、隐私和服务协议。删除账号保持红色是合理的，但退出登录不必使用整块高饱和红色。
+
+证据：`12-settings.png`。
+
+### 24. 侧边栏健康仪表盘过于抢眼
+
+大面积蓝紫粉渐变和四个小框成为最强区域，与项目“克制、专业、模块色只做识别”的偏好有偏差；指标小字和透明边框的对比度也偏弱。
+
+证据：`02-drawer.png`。
+
+### 25. 空状态表达不统一
+
+复查随访使用居中图标和说明；饮食使用一条白色容器；其他页面可能只留空白。建议统一空状态的标题、原因和下一步操作，但不需要每页再套一张大卡片。
+
+证据：`06-diet-records.png`、`08-followups.png`。
+
+### 26. 部分图标按钮只有约 40dp
+
+例如蓝牙页顶部新增按钮使用固定 40×40，低于常见的 48dp 触控建议；对手部不便或视力较弱的健康类用户不够友好。
+
+### 27. 大字体、横屏、小屏和读屏尚无验证证据
+
+许多页面使用固定高度、固定行布局和多个并排信息块。当前只在一台 1440×3200 Android 真机、默认字体比例下检查，不能据此确认大字体和 iOS 横屏不会溢出。
+
+## 五、合规与发布准备问题
+
+### 28. 合规文档仍有主体和联系方式占位符
+
+隐私政策、服务协议、个人信息清单和 SDK 清单里仍有 `xxx`、待定短信服务商等内容，不能用于正式审核。
+
+### 29. App 内文档与 H5 文档存在多套日期和内容
+
+App 内隐私/协议日期为 6 月 29 日，个人信息与 SDK 清单为 7 月 9 日；H5 清单日期为 7 月 7 日。以后修改一处很容易漏另一处。建议确定单一内容源或至少增加一致性测试。
+
+### 30. “关于我们”写了并不存在的意见反馈入口
+
+文档提示“设置 → 意见反馈”，实际设置页没有该入口；版本还写成 `Build 20260101`，与当前 `1.0.0+1` 不一致。
+
+### 31. 用户同意协议没有服务端记录
+
+当前“同意”只是登录页内存中的一个布尔值，未保存同意时间、协议版本或政策更新后的重新同意记录。服务端接口也不要求同意状态，无法证明用户同意了哪一版条款。
+
+### 32. Android 权限声明偏多且缺少版本限制
+
+当前声明了蓝牙广播权限，但 App 主要是扫描/连接；旧版存储和蓝牙权限也没有按 Android 版本加 `maxSdkVersion`。正式个人信息清单应与实际最小权限保持一致。
+
+### 33. 本地 token 使用普通 SQLite 明文保存
+
+符合项目“不用 shared_preferences”的约定，但 access token 和 refresh token 没有系统级加密保护；同时 Android 也未显式关闭备份。正式版本需要决定是否改用系统安全存储或加密数据库，并限制备份。
+
+### 34. iOS 名称和方向仍是模板状态
+
+Info.plist 的显示名称还是 `Health App`，并允许 iPhone 横屏；当前页面主要按竖屏设计，尚未验证横屏。Bundle ID、签名和证书则仍按项目计划待配置。
+
+### 35. CORS 当前允许任意来源并携带凭据
+
+本地调试方便，但正式环境应只允许确定的 H5/管理端域名，不能继续接受任意 Origin。
+
+## 六、已确认正常或已有保护的部分
+
+- 当前 Flutter `analyze` 无错误。
+- Flutter 47 项测试全部通过。
+- 后端 44 项测试全部通过。
+- 报告、用药、饮食、运动、健康数据等主要删除接口都按当前用户筛选，不是只删前端显示。
+- 单独删除报告时会同时删除报告原文件。
+- AI 历史对话恢复后仍保留原 conversationId，可以继续发送新消息；历史确认卡只读是合理保护。
+- 管理员和医生普通 HTTP 端点已有角色过滤，问题主要集中在固定管理员验证码、医生数据同步和未鉴权 SignalR Hub。
+- 设置、通知、报告列表已经较接近“一行一行、文字区分隔线”的目标风格。
+- 隐私政策、服务协议、个人信息清单、SDK 清单和关于我们均已有 App 内入口与 H5 文件。
+
+## 七、真机流程健康度
+
+1. 首页与 AI 对话：可进入；视觉基本完整，但纯图标无障碍名称不足，AI SSE 鉴权有严重后端风险。
+2. 侧边栏：可打开；功能入口齐全，仪表盘色彩和层级偏重。
+3. 健康档案：可加载和编辑；固定保存区需要继续验证大字体遮挡。
+4. 报告管理：列表正常；文件公开访问是严重隐私风险。
+5. 用药管理：数据能加载；列表红底显示错误明显。
+6. 饮食记录：日期、空状态和趋势能显示；空状态样式与其他页不统一。
+7. 健康日历：日期和计划能显示；业务时区需要后端统一。
+8. 复查随访：空状态清楚；本次账号没有数据，未实测详情。
+9. 运动计划：数据能加载；红底和操作文字重叠明显。
+10. 蓝牙设备：绑定设备能显示；自动读取后的批量上传链路断开。
+11. 通知中心：历史和未读数能显示；未读通知在网络失败时可能打不开目的页。
+12. 设置与合规入口：入口齐全；危险操作权重过高，文档仍有占位和不一致。
+13. 个人信息：真机运行版本可进入；检查期间源代码刚加入新的基本资料编辑入口，当前运行包尚未热更新到这一版。
+14. 医生端：已完成代码与接口核对；没有医生测试账号，本次未做完整真机流程。
+15. 管理员端：已完成代码与接口核对；没有实际执行新增/停用/删除，避免改变真实数据。
+16. iOS：仅做配置与代码检查；没有证书、Mac 构建和 iPhone 实测，不能确认界面与权限流程。
+
+## 八、证据限制
+
+- 真机截图来自本次检查时设备上正在运行的调试包。检查过程中项目源代码仍在被更新，后加入的个人资料编辑和设备错误文案没有重新构建到该运行包，因此相关结论以当前代码为准、旧界面截图只用于对应未变化页面。
+- 没有执行真实删除、账号注销、医生管理、短信发送或蓝牙测量，避免改变现有数据；这些部分通过前后端代码和接口对应关系确认。
+- 没有正式域名、HTTPS、短信服务商、对象存储、iOS 签名和商店账号，因此只检查了当前准备缺口。

backend/.env.example

@@ -16,6 +16,14 @@ QWEN_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
 QWEN_API_KEY=sk-your-key-here
 QWEN_VISION_MODEL=qwen-vl-max
 
+# 阿里云百炼实时语音输入（Fun-ASR）
+DASHSCOPE_ASR_API_KEY=sk-your-dashscope-key-here
+DASHSCOPE_ASR_WORKSPACE_ID=your-workspace-id
+DASHSCOPE_ASR_MODEL=fun-asr-realtime
+DASHSCOPE_ASR_MAX_DURATION_SECONDS=60
+# 可选；不填时按 Workspace ID 自动生成北京地域专属地址
+# DASHSCOPE_ASR_WEBSOCKET_URL=wss://your-workspace-id.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference
+
 # MinIO
 MINIO_ENDPOINT=localhost:9000
 MINIO_ACCESS_KEY=minioadmin

backend/dotnet-tools.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "dotnet-ef": {
+      "version": "10.0.8",
+      "commands": [
+        "dotnet-ef"
+      ],
+      "rollForward": false
+    }
+  }
+}

backend/src/Health.Application/AI/AiConversationContracts.cs

@@ -0,0 +1,67 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.AI;
+
+public sealed record AiConversationDto(
+    Guid Id,
+    string AgentType,
+    string? Title,
+    string? Summary,
+    int MessageCount,
+    DateTime CreatedAt,
+    DateTime UpdatedAt);
+
+public sealed record AiConversationMessageDto(
+    Guid Id,
+    string Role,
+    string Content,
+    string? Intent,
+    string? MetadataJson,
+    DateTime CreatedAt);
+
+public sealed record OpenConversationResult(
+    bool Found,
+    bool Created,
+    Guid ConversationId);
+
+public interface IAiConversationService
+{
+    Task<OpenConversationResult> OpenAsync(Guid userId, Guid? conversationId, AgentType agentType, string firstMessage, CancellationToken ct);
+    Task AddUserMessageAsync(Guid conversationId, string content, string? metadataJson, CancellationToken ct);
+    Task AddAssistantMessageAsync(Guid conversationId, string content, CancellationToken ct);
+    Task AddAssistantMessageAsync(Guid conversationId, string content, string? metadataJson, CancellationToken ct);
+    Task<IReadOnlyList<AiConversationMessageDto>> GetRecentMessagesAsync(Guid conversationId, int limit, CancellationToken ct);
+    Task<IReadOnlyList<AiConversationDto>> ListAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<AiConversationMessageDto>> GetMessagesAsync(Guid userId, Guid conversationId, CancellationToken ct);
+    Task UpdateSummaryAsync(Guid conversationId, string summary, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid conversationId, CancellationToken ct);
+    Task<int> DeleteAllAsync(Guid userId, CancellationToken ct);
+}
+
+public interface IAiConversationRepository
+{
+    Task<Conversation?> GetOwnedAsync(Guid userId, Guid conversationId, CancellationToken ct);
+    Task<Conversation?> GetAsync(Guid conversationId, CancellationToken ct);
+    Task<IReadOnlyList<Conversation>> ListAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<ConversationMessage>> GetMessagesAsync(Guid conversationId, CancellationToken ct);
+    Task<IReadOnlyList<ConversationMessage>> GetRecentMessagesAsync(Guid conversationId, int limit, CancellationToken ct);
+    Task AddConversationAsync(Conversation conversation, CancellationToken ct);
+    Task AddMessageAsync(ConversationMessage message, CancellationToken ct);
+    Task<int> DeleteLegacyDietCommentaryArtifactsAsync(Guid userId, string promptPrefix, CancellationToken ct);
+    void Delete(Conversation conversation);
+    Task SaveChangesAsync(CancellationToken ct);
+}
+
+public interface IPatientContextService
+{
+    Task<string> BuildAsync(Guid userId, CancellationToken ct);
+}
+
+public sealed record AiConfirmedWriteResult(int Code, object? Data, string? Message);
+
+public interface IAiToolExecutionService
+{
+    Task<object> ExecuteAsync(string toolName, string arguments, Guid userId, CancellationToken ct);
+    Task<AiConfirmedWriteResult> ConfirmAsync(Guid commandId, Guid userId, CancellationToken ct);
+}

backend/src/Health.Application/AI/AiConversationService.cs

@@ -0,0 +1,157 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.AI;
+
+public sealed class AiConversationService(IAiConversationRepository conversations) : IAiConversationService
+{
+    private const int HistoryConversationLimit = 30;
+    private readonly IAiConversationRepository _conversations = conversations;
+
+    public async Task<OpenConversationResult> OpenAsync(
+        Guid userId,
+        Guid? conversationId,
+        AgentType agentType,
+        string firstMessage,
+        CancellationToken ct)
+    {
+        if (conversationId.HasValue)
+        {
+            var existing = await _conversations.GetOwnedAsync(userId, conversationId.Value, ct);
+            return existing == null
+                ? new OpenConversationResult(false, false, conversationId.Value)
+                : new OpenConversationResult(true, false, existing.Id);
+        }
+
+        var conversation = new Conversation
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            AgentType = agentType,
+            Title = firstMessage.Length > 30 ? firstMessage[..30] : firstMessage,
+            CreatedAt = DateTime.UtcNow,
+            UpdatedAt = DateTime.UtcNow,
+        };
+        await _conversations.AddConversationAsync(conversation, ct);
+        await _conversations.SaveChangesAsync(ct);
+        await PruneHistoryAsync(userId, ct);
+        return new OpenConversationResult(true, true, conversation.Id);
+    }
+
+    public async Task AddUserMessageAsync(Guid conversationId, string content, string? metadataJson, CancellationToken ct) =>
+        await AddMessageAsync(conversationId, MessageRole.User, content, updateSummary: false, metadataJson, ct);
+
+    public async Task AddAssistantMessageAsync(Guid conversationId, string content, CancellationToken ct) =>
+        await AddMessageAsync(conversationId, MessageRole.Assistant, content, updateSummary: true, metadataJson: null, ct);
+
+    public async Task AddAssistantMessageAsync(Guid conversationId, string content, string? metadataJson, CancellationToken ct) =>
+        await AddMessageAsync(conversationId, MessageRole.Assistant, content, updateSummary: true, metadataJson, ct);
+
+    public async Task<IReadOnlyList<AiConversationMessageDto>> GetRecentMessagesAsync(Guid conversationId, int limit, CancellationToken ct)
+    {
+        var messages = await _conversations.GetRecentMessagesAsync(conversationId, limit, ct);
+        return messages.OrderBy(m => m.CreatedAt).Select(ToMessageDto).ToList();
+    }
+
+    public async Task<IReadOnlyList<AiConversationDto>> ListAsync(Guid userId, CancellationToken ct)
+    {
+        await _conversations.DeleteLegacyDietCommentaryArtifactsAsync(
+            userId,
+            DietCommentaryPolicy.LegacyPromptPrefix,
+            ct);
+        var conversations = await _conversations.ListAsync(userId, ct);
+        return conversations.Take(HistoryConversationLimit).Select(ToDto).ToList();
+    }
+
+    public async Task<IReadOnlyList<AiConversationMessageDto>> GetMessagesAsync(Guid userId, Guid conversationId, CancellationToken ct)
+    {
+        var conversation = await _conversations.GetOwnedAsync(userId, conversationId, ct);
+        if (conversation == null) return [];
+
+        var messages = await _conversations.GetMessagesAsync(conversationId, ct);
+        return messages.Select(ToMessageDto).ToList();
+    }
+
+    public async Task UpdateSummaryAsync(Guid conversationId, string summary, CancellationToken ct)
+    {
+        var conversation = await _conversations.GetAsync(conversationId, ct)
+            ?? throw new InvalidOperationException("会话不存在");
+        var normalized = summary.Trim();
+        if (string.IsNullOrWhiteSpace(normalized)) return;
+
+        conversation.Summary = normalized.Length > 24 ? normalized[..24] : normalized;
+        await _conversations.SaveChangesAsync(ct);
+    }
+
+    public async Task<bool> DeleteAsync(Guid userId, Guid conversationId, CancellationToken ct)
+    {
+        var conversation = await _conversations.GetOwnedAsync(userId, conversationId, ct);
+        if (conversation == null) return false;
+
+        _conversations.Delete(conversation);
+        await _conversations.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<int> DeleteAllAsync(Guid userId, CancellationToken ct)
+    {
+        var list = await _conversations.ListAsync(userId, ct);
+        foreach (var conv in list)
+        {
+            _conversations.Delete(conv);
+        }
+        if (list.Count > 0)
+            await _conversations.SaveChangesAsync(ct);
+        return list.Count;
+    }
+
+    private async Task AddMessageAsync(Guid conversationId, MessageRole role, string content, bool updateSummary, string? metadataJson, CancellationToken ct)
+    {
+        var conversation = await _conversations.GetAsync(conversationId, ct)
+            ?? throw new InvalidOperationException("会话不存在");
+        await _conversations.AddMessageAsync(new ConversationMessage
+        {
+            Id = Guid.NewGuid(),
+            ConversationId = conversationId,
+            Role = role,
+            Content = content,
+            MetadataJson = metadataJson,
+            CreatedAt = DateTime.UtcNow,
+        }, ct);
+
+        conversation.MessageCount++;
+        conversation.UpdatedAt = DateTime.UtcNow;
+        if (updateSummary)
+            conversation.Summary = content.Length > 100 ? content[..100] : content;
+        await _conversations.SaveChangesAsync(ct);
+        await PruneHistoryAsync(conversation.UserId, ct);
+    }
+
+    private async Task PruneHistoryAsync(Guid userId, CancellationToken ct)
+    {
+        var list = await _conversations.ListAsync(userId, ct);
+        var expired = list.Skip(HistoryConversationLimit).ToList();
+        if (expired.Count == 0) return;
+
+        foreach (var conversation in expired)
+            _conversations.Delete(conversation);
+        await _conversations.SaveChangesAsync(ct);
+    }
+
+    private static AiConversationDto ToDto(Conversation conversation) => new(
+        conversation.Id,
+        conversation.AgentType.ToString(),
+        conversation.Title,
+        conversation.Summary,
+        conversation.MessageCount,
+        conversation.CreatedAt,
+        conversation.UpdatedAt);
+
+    private static AiConversationMessageDto ToMessageDto(ConversationMessage message) => new(
+        message.Id,
+        message.Role.ToString(),
+        message.Content,
+        message.Intent,
+        message.MetadataJson,
+        message.CreatedAt);
+}

backend/src/Health.Application/AI/AiEntryDraftContracts.cs

@@ -0,0 +1,24 @@
+namespace Health.Application.AI;
+
+public sealed record AiEntryDraft(
+    Guid Id,
+    Guid UserId,
+    Guid ConversationId,
+    string EntryType,
+    string Payload,
+    string MissingFields,
+    DateTime ExpiresAt);
+
+public interface IAiEntryDraftStore
+{
+    Task<AiEntryDraft?> GetActiveAsync(Guid userId, Guid conversationId, string entryType, CancellationToken ct);
+    Task<AiEntryDraft> UpsertAsync(
+        Guid userId,
+        Guid conversationId,
+        string entryType,
+        string payload,
+        string missingFields,
+        TimeSpan lifetime,
+        CancellationToken ct);
+    Task CompleteAsync(Guid draftId, Guid userId, CancellationToken ct);
+}

backend/src/Health.Application/AI/AiWriteConfirmationContracts.cs

@@ -0,0 +1,15 @@
+namespace Health.Application.AI;
+
+public sealed record PendingAiWriteCommand(
+    Guid Id,
+    Guid UserId,
+    string ToolName,
+    string Arguments,
+    DateTime ExpiresAt);
+
+public interface IAiWriteConfirmationStore
+{
+    Task<PendingAiWriteCommand> CreateAsync(Guid userId, string toolName, string arguments, TimeSpan lifetime, CancellationToken ct);
+    Task<PendingAiWriteCommand?> TakeAsync(Guid commandId, Guid userId, CancellationToken ct);
+    Task CompleteAsync(PendingAiWriteCommand command, CancellationToken ct);
+}

backend/src/Health.Application/AI/AttachmentContextContracts.cs

@@ -0,0 +1,20 @@
+namespace Health.Application.AI;
+
+/// <summary>
+/// 用户消息附带的图片/PDF 解析结果。
+/// 既用作 LLM 上下文拼装，也持久化到 ConversationMessage.MetadataJson。
+/// </summary>
+public sealed record AttachmentContext(
+    string Kind,            // "image" 或 "pdf"
+    string? Category,       // 仅图片：food / report / wound / drug / chart / other
+    string? FileName,       // PDF 文件原名
+    string Summary,         // 简短摘要，用于持久化和历史回顾
+    string LlmContent);     // 完整文本，拼到当前轮 LLM user content 前
+
+public interface IAttachmentContextBuilder
+{
+    /// <summary>
+    /// 根据 imageUrl 或 pdfUrl 构建附件上下文。两个都为空返回 null。
+    /// </summary>
+    Task<AttachmentContext?> BuildAsync(Guid userId, string? imageUrl, string? pdfUrl, CancellationToken ct);
+}

backend/src/Health.Application/AI/DietCommentaryPolicy.cs

@@ -0,0 +1,36 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.AI;
+
+public sealed record DietCommentaryFood(string Name, string Portion, int Calories);
+
+public static class DietCommentaryPolicy
+{
+    public const string LegacyPromptPrefix = "饮食记录页需要展示本餐建议。";
+
+    public const string SystemPrompt = """
+        你是健康管理 App 中的饮食整理助手。根据用户本餐食物和健康档案，直接输出2到3条简短事实描述。
+        每条12到22个汉字，不要问候，不要说“好的”“当然”“建议如下”，不要编号，不要使用 Markdown。
+        优先围绕控盐控油、蔬菜和蛋白质搭配及份量控制描述客观事实（如“本餐盐分约5克”“蔬菜偏少”）。
+        不作诊断，不提供治疗、处方、停药或调药结论，不给饮食建议，不基于疾病推断。语言简洁、专业、面向普通用户。
+        如果输出了营养事实或饮食相关健康信息，末尾必须附上“参考来源”，使用固定医学来源目录中的 S-DIET-01 或 S-DIET-02。
+        """;
+
+    public static string BuildFoodDescription(IEnumerable<DietCommentaryFood> foods) =>
+        string.Join("、", foods.Select(food =>
+            $"{Normalize(food.Name, 40)}（{Normalize(food.Portion, 30)}，{Math.Clamp(food.Calories, 0, 10000)}千卡）"));
+
+    public static bool IsLegacyArtifact(IEnumerable<ConversationMessage> messages)
+    {
+        var userMessages = messages.Where(message => message.Role == MessageRole.User).ToList();
+        return userMessages.Count > 0 &&
+               userMessages.All(message => message.Content.TrimStart().StartsWith(LegacyPromptPrefix, StringComparison.Ordinal));
+    }
+
+    private static string Normalize(string value, int maxLength)
+    {
+        var normalized = string.Join(' ', value.Trim().Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
+        return normalized.Length > maxLength ? normalized[..maxLength] : normalized;
+    }
+}

backend/src/Health.Application/AI/MedicalCitationKnowledge.cs

@@ -0,0 +1,91 @@
+namespace Health.Application.AI;
+
+/// <summary>
+/// iOS 审核版内置医学来源目录。
+/// 这是固定提示词资料，不依赖在线 RAG 检索。
+/// </summary>
+public static class MedicalCitationKnowledge
+{
+    public const string Prompt = """
+        固定医学参考来源目录（仅可引用下列来源，不得编造 PMID、DOI 或 URL）：
+
+        [S-BP-01] 2024 ESC Guidelines for the management of elevated blood pressure and hypertension
+        适用：血压记录、血压趋势、单次血压不能单独诊断、复测和就医提醒。
+        https://pubmed.ncbi.nlm.nih.gov/39210715/
+
+        [S-GLU-01] Glycemic Goals and Hypoglycemia: Standards of Care in Diabetes—2025
+        适用：血糖记录、空腹或餐后状态、低血糖风险和血糖结果说明。
+        https://pubmed.ncbi.nlm.nih.gov/39651981/
+
+        [S-HR-01] All About Heart Rate, American Heart Association
+        适用：静息心率的客观说明和心率记录趋势。
+        https://www.heart.org/en/health-topics/high-blood-pressure/the-facts-about-high-blood-pressure/all-about-heart-rate-pulse
+
+        [S-OXY-01] Pulse Oximeter Basics, U.S. Food and Drug Administration
+        适用：血氧读数局限、复测、症状和血氧记录说明。
+        https://www.fda.gov/consumers/consumer-updates/pulse-oximeter-basics
+
+        [S-DIET-01] Popular Dietary Patterns: Alignment With American Heart Association 2021 Dietary Guidance
+        适用：一般饮食模式、食物营养特征、饮食图片估算局限。
+        https://pubmed.ncbi.nlm.nih.gov/37128940/
+
+        [S-DIET-02] Diet and nutrition in cardiovascular disease prevention
+        适用：一般心血管健康饮食信息，不用于个体化疾病饮食处方。
+        https://pubmed.ncbi.nlm.nih.gov/40504596/
+
+        [S-EX-01] Resistance Exercise Training in Individuals With and Without Cardiovascular Disease: 2023 Update
+        适用：一般运动计划记录和运动安全提醒，不用于疾病运动处方。
+        https://pubmed.ncbi.nlm.nih.gov/38059362/
+
+        [S-EX-02] Core Components of Cardiac Rehabilitation Programs: 2024 Update
+        适用：心脏康复相关安全边界，只能建议咨询专业人员，不能生成康复处方。
+        https://pubmed.ncbi.nlm.nih.gov/39315436/
+
+        [S-MED-01] Medicines adherence: involving patients in decisions about prescribed medicines and supporting adherence
+        适用：用药计划记录、服药提醒和建议咨询医生或药师。
+        https://pubmed.ncbi.nlm.nih.gov/39480983/
+
+        [S-REPORT-01] Interpreting Normal Values and Reference Ranges for Laboratory Tests
+        适用：报告指标、参考范围和异常标记的客观说明。
+        https://pubmed.ncbi.nlm.nih.gov/40268322/
+
+        [S-REPORT-02] Verification of reference intervals in routine clinical laboratories: practical challenges and recommendations
+        适用：不同实验室参考范围差异和优先使用原报告参考范围。
+        https://pubmed.ncbi.nlm.nih.gov/29729142/
+
+        [S-EM-01] 2024 American Heart Association and American Red Cross Guidelines for First Aid
+        适用：危险症状安全提醒、及时联系当地急救服务和不要等待 AI 判断。
+        https://cpr.heart.org/en/resuscitation-science/2024-first-aid-guidelines
+
+        来源使用边界：
+        - 血压：单次记录不能单独诊断高血压；应结合多次记录、测量条件、症状和医生评估；不得建议自行加药、减药或停药。
+        - 血糖：必须关注空腹/餐后等测量时段和既往用药；不能把一个统一目标套用给所有人；不得据此诊断糖尿病或指导自行调药。
+        - 心率：静息心率的客观范围不能替代诊断；应结合是否安静、是否有不适和变化趋势说明。
+        - 血氧：读数是估计值，可能受手部温度、活动、循环、皮肤因素和设备影响；应结合症状和复测结果，不得仅凭单个数值诊断或指导吸氧/调药。
+        - 饮食：图片不能精确确定重量、份量、烹调油和调味料；盐、糖、脂肪和热量只能作一般估算；不得根据疾病档案生成个体化饮食处方。
+        - 运动：只能提供一般运动计划记录和安全提醒；不得针对心血管疾病制定运动处方；有胸痛、晕厥或明显呼吸困难时应先就医评估。
+        - 用药：只能记录计划、查询任务和提醒；开始、停止、更换或调整药物应由医生或药师决定。
+        - 报告：优先使用报告本身提供的参考范围；标记高/低不等于诊断；不同实验室参考范围不能直接互换；应由医生结合症状和病史解释。
+        - 危险症状：胸部不适、呼吸困难、单侧无力、语言障碍、意识异常等应立即联系当地急救服务，不要等待 AI 继续判断。
+        """;
+
+    public const string FixedDietCitation = """
+        参考来源：
+        [S-DIET-01] Popular Dietary Patterns: Alignment With American Heart Association 2021 Dietary Guidance
+        https://pubmed.ncbi.nlm.nih.gov/37128940/
+        """;
+
+    public const string FixedReportCitation = """
+        参考来源：
+        [S-REPORT-01] Interpreting Normal Values and Reference Ranges for Laboratory Tests
+        https://pubmed.ncbi.nlm.nih.gov/40268322/
+        [S-REPORT-02] Verification of reference intervals in routine clinical laboratories: practical challenges and recommendations
+        https://pubmed.ncbi.nlm.nih.gov/29729142/
+        """;
+
+    public const string EmergencyCitation = """
+        参考来源：
+        [S-EM-01] 2024 American Heart Association and American Red Cross Guidelines for First Aid
+        https://cpr.heart.org/en/resuscitation-science/2024-first-aid-guidelines
+        """;
+}

backend/src/Health.Application/AI/PatientContextService.cs

@@ -0,0 +1,65 @@
+using System.Text;
+using Health.Application.HealthArchives;
+using Health.Application.HealthRecords;
+
+namespace Health.Application.AI;
+
+public sealed class PatientContextService(
+    IHealthArchiveService archives,
+    IHealthRecordService healthRecords) : IPatientContextService
+{
+    private readonly IHealthArchiveService _archives = archives;
+    private readonly IHealthRecordService _healthRecords = healthRecords;
+
+    public async Task<string> BuildAsync(Guid userId, CancellationToken ct)
+    {
+        var archive = await _archives.GetAsync(userId, ct);
+        var recentRecords = (await _healthRecords.GetRecordsAsync(userId, null, 30, ct)).Take(10).ToList();
+
+        var sb = new StringBuilder();
+        if (archive != null)
+        {
+            if (!string.IsNullOrEmpty(archive.Diagnosis)) sb.AppendLine($"诊断: {archive.Diagnosis}");
+            if (archive.SurgeryHistoryStatus == "无")
+                sb.AppendLine("手术史: 无");
+            else if (archive.Surgeries.Count > 0)
+                sb.AppendLine($"手术: {string.Join("；", archive.Surgeries.Select(s => $"{s.Type} ({s.Date})"))}");
+            else if (!string.IsNullOrEmpty(archive.SurgeryType))
+                sb.AppendLine($"手术: {archive.SurgeryType} ({archive.SurgeryDate})");
+            if (archive.ChronicDiseases.Count > 0) sb.AppendLine($"慢病史: {string.Join(", ", archive.ChronicDiseases)}");
+            if (!string.IsNullOrEmpty(archive.FamilyHistory)) sb.AppendLine($"家族病史: {archive.FamilyHistory}");
+            if (archive.Allergies.Count > 0) sb.AppendLine($"过敏: {string.Join(", ", archive.Allergies)}");
+            if (archive.DietRestrictions.Count > 0) sb.AppendLine($"饮食限制: {string.Join(", ", archive.DietRestrictions)}");
+        }
+
+        if (recentRecords.Count > 0)
+        {
+            sb.AppendLine("近期健康数据:");
+            foreach (var record in recentRecords)
+                sb.AppendLine($"  {record.Type}: {RecordValue(record)} ({ToBeijing(record.RecordedAt):MM-dd HH:mm} 北京时间)");
+        }
+
+        return sb.ToString();
+    }
+
+    private static string RecordValue(HealthRecordDto record) => record.Type switch
+    {
+        "BloodPressure" => $"{record.Systolic}/{record.Diastolic}",
+        "HeartRate" => $"{record.Value}次/分",
+        "Glucose" => $"{record.Value}",
+        "SpO2" => $"{record.Value}%",
+        "Weight" => $"{record.Value}kg",
+        _ => "—"
+    };
+
+    private static DateTime ToBeijing(DateTime value)
+    {
+        var utc = value.Kind switch
+        {
+            DateTimeKind.Utc => value,
+            DateTimeKind.Local => value.ToUniversalTime(),
+            _ => DateTime.SpecifyKind(value, DateTimeKind.Utc),
+        };
+        return utc.AddHours(8);
+    }
+}

backend/src/Health.Application/Admin/AdminContracts.cs

@@ -0,0 +1,15 @@
+namespace Health.Application.Admin;
+
+public sealed record AdminResult(int Code, object? Data, string? Message = null);
+public sealed record AddDoctorCommand(string Phone, string Name, string? Title, string? Department, string? ProfessionalDirection);
+public sealed record UpdateDoctorCommand(string? Phone, string? Name, string? Title, string? Department, string? ProfessionalDirection);
+
+public interface IAdminService
+{
+    Task<AdminResult> ListDoctorsAsync(CancellationToken ct);
+    Task<AdminResult> AddDoctorAsync(AddDoctorCommand command, CancellationToken ct);
+    Task<AdminResult> UpdateDoctorAsync(Guid id, UpdateDoctorCommand command, CancellationToken ct);
+    Task<AdminResult> ToggleDoctorAsync(Guid id, CancellationToken ct);
+    Task<AdminResult> DeleteDoctorAsync(Guid id, CancellationToken ct);
+    Task<AdminResult> ListPatientsAsync(string? search, int page, int pageSize, CancellationToken ct);
+}

backend/src/Health.Application/Auth/AuthContracts.cs

@@ -0,0 +1,15 @@
+namespace Health.Application.Auth;
+
+public sealed record AuthResult(int Code, object? Data, string? Message = null);
+public sealed record RegisterCommand(string Phone, string SmsCode, string Name, Guid DoctorId);
+public sealed record AppleLoginCommand(string IdentityToken, string? AuthorizationCode, string? Name);
+
+public interface IAuthService
+{
+    Task<AuthResult> SendCodeAsync(string phone, bool revealDevelopmentCode, CancellationToken ct);
+    Task<AuthResult> RegisterAsync(RegisterCommand command, CancellationToken ct);
+    Task<AuthResult> LoginAsync(string phone, string smsCode, CancellationToken ct);
+    Task<AuthResult> AppleLoginAsync(AppleLoginCommand command, CancellationToken ct);
+    Task<AuthResult> RefreshAsync(string refreshToken, CancellationToken ct);
+    Task LogoutAsync(string refreshToken, CancellationToken ct);
+}

backend/src/Health.Application/Calendars/CalendarContracts.cs

@@ -0,0 +1,19 @@
+using Health.Domain.Entities;
+
+namespace Health.Application.Calendars;
+
+public sealed record CalendarDataSnapshot(
+    IReadOnlyList<Medication> Medications,
+    IReadOnlyList<ExercisePlan> ExercisePlans,
+    IReadOnlyList<FollowUp> FollowUps);
+
+public interface ICalendarService
+{
+    Task<IReadOnlyList<object>> GetMonthAsync(Guid userId, int year, int month, CancellationToken ct);
+    Task<object> GetDayAsync(Guid userId, DateOnly date, CancellationToken ct);
+}
+
+public interface ICalendarRepository
+{
+    Task<CalendarDataSnapshot> GetSnapshotAsync(Guid userId, DateOnly start, DateOnly end, CancellationToken ct);
+}

backend/src/Health.Application/Calendars/CalendarService.cs

@@ -0,0 +1,101 @@
+namespace Health.Application.Calendars;
+
+public sealed class CalendarService(ICalendarRepository calendar) : ICalendarService
+{
+    private readonly ICalendarRepository _calendar = calendar;
+
+    public async Task<IReadOnlyList<object>> GetMonthAsync(Guid userId, int year, int month, CancellationToken ct)
+    {
+        var start = new DateOnly(year, month, 1);
+        var end = start.AddMonths(1);
+        var snapshot = await _calendar.GetSnapshotAsync(userId, start, end, ct);
+        var result = new List<object>();
+
+        for (var date = start; date < end; date = date.AddDays(1))
+        {
+            var entries = BuildEntries(snapshot, date);
+            if (entries.Count == 0) continue;
+
+            result.Add(new
+            {
+                date = date.ToString("yyyy-MM-dd"),
+                events = entries.Select(entry => entry.Type).Distinct().ToList(),
+                details = entries.Select(entry => entry.Value).ToList()
+            });
+        }
+
+        return result;
+    }
+
+    public async Task<object> GetDayAsync(Guid userId, DateOnly date, CancellationToken ct)
+    {
+        var snapshot = await _calendar.GetSnapshotAsync(userId, date, date.AddDays(1), ct);
+        var medications = snapshot.Medications
+            .Where(m => IsMedicationActiveOn(m, date))
+            .Select(m => new { m.Name, m.Dosage, timeOfDay = m.TimeOfDay.Select(t => t.ToString(@"hh\:mm")).ToList() })
+            .ToList();
+        var exercises = snapshot.ExercisePlans
+            .SelectMany(p => p.Items)
+            .Where(i => i.ScheduledDate == date && !i.IsRestDay)
+            .Select(i => new { type = i.ExerciseType, duration = i.DurationMinutes, isCompleted = i.IsCompleted, scheduledDate = i.ScheduledDate })
+            .ToList();
+        var followUps = snapshot.FollowUps
+            .Where(f => BeijingDate(f.ScheduledAt) == date)
+            .Select(f => new { f.Title, f.DoctorName, f.Department, status = f.Status.ToString() })
+            .ToList();
+
+        return new { medications, exercises, followUps };
+    }
+
+    private static List<CalendarEntry> BuildEntries(CalendarDataSnapshot snapshot, DateOnly date)
+    {
+        var entries = new List<CalendarEntry>();
+        foreach (var medication in snapshot.Medications.Where(m => IsMedicationActiveOn(m, date)))
+        {
+            entries.Add(new CalendarEntry("medication", new
+            {
+                type = "medication",
+                name = medication.Name,
+                dosage = medication.Dosage,
+                timeOfDay = medication.TimeOfDay.Select(t => t.ToString(@"hh\:mm")).ToList()
+            }));
+        }
+
+        foreach (var plan in snapshot.ExercisePlans)
+        {
+            foreach (var item in plan.Items.Where(i => i.ScheduledDate == date && !i.IsRestDay))
+                entries.Add(new CalendarEntry("exercise", new { type = "exercise", name = item.ExerciseType, duration = item.DurationMinutes, isCompleted = item.IsCompleted, scheduledDate = item.ScheduledDate }));
+        }
+
+        foreach (var followUp in snapshot.FollowUps.Where(f => BeijingDate(f.ScheduledAt) == date))
+        {
+            entries.Add(new CalendarEntry("followup", new
+            {
+                type = "followup",
+                title = followUp.Title,
+                doctorName = followUp.DoctorName,
+                department = followUp.Department,
+                status = followUp.Status.ToString()
+            }));
+        }
+
+        return entries;
+    }
+
+    private static bool IsMedicationActiveOn(Health.Domain.Entities.Medication medication, DateOnly date) =>
+        medication.IsActive
+        && medication.TimeOfDay.Count > 0
+        && (medication.StartDate == null || medication.StartDate <= date)
+        && (medication.EndDate == null || medication.EndDate >= date);
+
+    private static DateOnly BeijingDate(DateTime value)
+    {
+        // EF 从 timestamptz 读取的是 UTC；单元测试及旧内存对象可能是 Unspecified。
+        var beijing = value.Kind == DateTimeKind.Unspecified
+            ? value
+            : value.ToUniversalTime().AddHours(8);
+        return DateOnly.FromDateTime(beijing);
+    }
+
+    private sealed record CalendarEntry(string Type, object Value);
+}

backend/src/Health.Application/Diets/DietContracts.cs

@@ -0,0 +1,51 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Diets;
+
+public sealed record DietFoodItemInput(
+    string Name,
+    string? Portion,
+    int? Calories,
+    int SortOrder);
+
+public sealed record DietRecordCreateRequest(
+    MealType MealType,
+    int? TotalCalories,
+    int? HealthScore,
+    DateOnly RecordedAt,
+    IReadOnlyList<DietFoodItemInput> FoodItems);
+
+public sealed record DietRecordPatchRequest(
+    int? TotalCalories,
+    int? HealthScore);
+
+public sealed record DietFoodItemDto(
+    string Name,
+    string? Portion,
+    int? Calories);
+
+public sealed record DietRecordDto(
+    Guid Id,
+    string MealType,
+    int? TotalCalories,
+    int? HealthScore,
+    DateOnly RecordedAt,
+    IReadOnlyList<DietFoodItemDto> FoodItems);
+
+public interface IDietService
+{
+    Task<IReadOnlyList<DietRecordDto>> ListAsync(Guid userId, string? date, string? mealType, CancellationToken ct);
+    Task<Guid> CreateAsync(Guid userId, DietRecordCreateRequest request, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid recordId, CancellationToken ct);
+    Task<bool> UpdateAsync(Guid userId, Guid recordId, DietRecordPatchRequest request, CancellationToken ct);
+}
+
+public interface IDietRepository
+{
+    Task<IReadOnlyList<DietRecord>> ListAsync(Guid userId, DateOnly? recordedAt, MealType? mealType, CancellationToken ct);
+    Task<DietRecord?> GetOwnedAsync(Guid userId, Guid recordId, CancellationToken ct);
+    Task AddAsync(DietRecord record, CancellationToken ct);
+    void Delete(DietRecord record);
+    Task SaveChangesAsync(CancellationToken ct);
+}

backend/src/Health.Application/Diets/DietImageAnalysisContracts.cs

@@ -0,0 +1,27 @@
+namespace Health.Application.Diets;
+
+public sealed record DietImageUploadFile(string FileName, long Length, Stream Content);
+
+public sealed record DietImageAnalysisJob(Guid Id, IReadOnlyList<string> FilePaths);
+
+public sealed record DietImageAnalysisResult(bool Success, int Code, string? Data, string? Message);
+
+public interface IDietImageAnalysisCoordinator
+{
+    Task<DietImageAnalysisResult> AnalyzeAsync(IReadOnlyList<DietImageUploadFile> files, CancellationToken ct);
+}
+
+public interface IDietImageAnalysisQueue
+{
+    Task<Guid> EnqueueAsync(IReadOnlyList<string> filePaths, CancellationToken ct);
+    Task RecoverStaleAsync(CancellationToken ct);
+    Task<DietImageAnalysisJob?> TryTakeAsync(CancellationToken ct);
+    Task<DietImageAnalysisResult> WaitForResultAsync(Guid jobId, CancellationToken ct);
+    Task CompleteAsync(Guid jobId, DietImageAnalysisResult result, CancellationToken ct);
+    Task<bool> RetryAsync(Guid jobId, string error, CancellationToken ct);
+}
+
+public interface IDietImageAnalyzer
+{
+    Task<DietImageAnalysisResult> AnalyzeAsync(DietImageAnalysisJob job, CancellationToken ct);
+}

backend/src/Health.Application/Diets/DietService.cs

@@ -0,0 +1,103 @@
+using Health.Domain;
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Diets;
+
+public sealed class DietService(IDietRepository diets) : IDietService
+{
+    private const int MaxCalories = 20000;   // 单条记录/单项热量上限（kcal）
+    private readonly IDietRepository _diets = diets;
+
+    public async Task<IReadOnlyList<DietRecordDto>> ListAsync(Guid userId, string? date, string? mealType, CancellationToken ct)
+    {
+        var recordedAt = DateOnly.TryParse(date, out var d) ? d : (DateOnly?)null;
+        var parsedMealType = Enum.TryParse<MealType>(mealType, ignoreCase: true, out var mt) ? mt : (MealType?)null;
+
+        var records = await _diets.ListAsync(userId, recordedAt, parsedMealType, ct);
+        return records.Select(ToDto).ToList();
+    }
+
+    public async Task<Guid> CreateAsync(Guid userId, DietRecordCreateRequest request, CancellationToken ct)
+    {
+        ValidateCalories(request.TotalCalories, "总热量");
+        ValidateScore(request.HealthScore);
+        foreach (var item in request.FoodItems)
+        {
+            if (string.IsNullOrWhiteSpace(item.Name))
+                throw new ValidationException("食物名称不能为空");
+            ValidateCalories(item.Calories, $"食物「{item.Name.Trim()}」热量");
+        }
+
+        var record = new DietRecord
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            MealType = request.MealType,
+            TotalCalories = request.TotalCalories,
+            HealthScore = request.HealthScore,
+            RecordedAt = request.RecordedAt,
+            CreatedAt = DateTime.UtcNow,
+        };
+
+        foreach (var item in request.FoodItems)
+        {
+            record.FoodItems.Add(new DietFoodItem
+            {
+                Id = Guid.NewGuid(),
+                Name = item.Name.Trim(),
+                Portion = item.Portion,
+                Calories = item.Calories,
+                SortOrder = item.SortOrder,
+            });
+        }
+
+        await _diets.AddAsync(record, ct);
+        await _diets.SaveChangesAsync(ct);
+        return record.Id;
+    }
+
+    public async Task<bool> DeleteAsync(Guid userId, Guid recordId, CancellationToken ct)
+    {
+        var record = await _diets.GetOwnedAsync(userId, recordId, ct);
+        if (record == null) return false;
+
+        _diets.Delete(record);
+        await _diets.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<bool> UpdateAsync(Guid userId, Guid recordId, DietRecordPatchRequest request, CancellationToken ct)
+    {
+        var record = await _diets.GetOwnedAsync(userId, recordId, ct);
+        if (record == null) return false;
+
+        ValidateCalories(request.TotalCalories, "总热量");
+        ValidateScore(request.HealthScore);
+
+        if (request.TotalCalories.HasValue) record.TotalCalories = request.TotalCalories.Value;
+        if (request.HealthScore.HasValue) record.HealthScore = request.HealthScore.Value;
+        await _diets.SaveChangesAsync(ct);
+        return true;
+    }
+
+    private static void ValidateCalories(int? calories, string field)
+    {
+        if (calories.HasValue && (calories.Value < 0 || calories.Value > MaxCalories))
+            throw new ValidationException($"{field}应在 0~{MaxCalories} kcal 之间，当前值 {calories.Value} 不合理");
+    }
+
+    private static void ValidateScore(int? score)
+    {
+        if (score.HasValue && (score.Value < 0 || score.Value > 100))
+            throw new ValidationException($"健康评分应在 0~100 之间，当前值 {score.Value} 不合理");
+    }
+
+    private static DietRecordDto ToDto(DietRecord record) => new(
+        record.Id,
+        record.MealType.ToString(),
+        record.TotalCalories,
+        record.HealthScore,
+        record.RecordedAt,
+        record.FoodItems.OrderBy(f => f.SortOrder).Select(f => new DietFoodItemDto(f.Name, f.Portion, f.Calories)).ToList());
+}

backend/src/Health.Application/Exercises/ExerciseContracts.cs

@@ -0,0 +1,67 @@
+using Health.Domain.Entities;
+
+namespace Health.Application.Exercises;
+
+public sealed record ExercisePlanCreateRequest(
+    DateOnly StartDate,
+    DateOnly EndDate,
+    string? ExerciseType,
+    int DurationMinutes,
+    TimeOnly? ReminderTime = null);
+
+public sealed record ExercisePlanItemDto(
+    Guid Id,
+    DateOnly ScheduledDate,
+    string ExerciseType,
+    int DurationMinutes,
+    bool IsCompleted,
+    DateTime? CompletedAt,
+    bool IsRestDay);
+
+public sealed record ExercisePlanDto(
+    Guid Id,
+    DateOnly StartDate,
+    DateOnly EndDate,
+    TimeOnly ReminderTime,
+    DateTime CreatedAt,
+    DateTime UpdatedAt,
+    IReadOnlyList<ExercisePlanItemDto> Items);
+
+public sealed record ExercisePlanSummaryDto(
+    Guid Id,
+    DateOnly StartDate,
+    DateOnly EndDate,
+    TimeOnly ReminderTime,
+    DateTime CreatedAt,
+    int TotalDays,
+    int CompletedDays,
+    IReadOnlyList<ExercisePlanItemDto> Items);
+
+public interface IExerciseService
+{
+    Task<ExercisePlanDto?> GetCurrentAsync(Guid userId, CancellationToken ct);
+    Task<Guid> CreateAsync(Guid userId, ExercisePlanCreateRequest request, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAllAsync(Guid userId, CancellationToken ct);
+    Task<ExercisePlanDto?> GetByIdAsync(Guid userId, Guid planId, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid planId, CancellationToken ct);
+    Task<bool?> ToggleCheckInAsync(Guid userId, Guid itemId, CancellationToken ct);
+    Task<bool> CheckInAsync(Guid userId, Guid itemId, CancellationToken ct);
+}
+
+public interface IExerciseRepository
+{
+    Task<IReadOnlyList<ExercisePlan>> ListActiveOnAsync(Guid userId, DateOnly date, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlan>> ListAsync(Guid userId, int limit, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlan>> ListAllAsync(Guid userId, CancellationToken ct);
+    Task<ExercisePlan?> GetOwnedPlanAsync(Guid userId, Guid planId, CancellationToken ct);
+    Task<ExercisePlanItem?> GetOwnedItemAsync(Guid userId, Guid itemId, CancellationToken ct);
+    Task AddAsync(ExercisePlan plan, CancellationToken ct);
+    void Delete(ExercisePlan plan);
+    Task SaveChangesAsync(CancellationToken ct);
+}
+
+public interface IExerciseReminderProducer
+{
+    Task<int> ProduceDueAsync(DateTime utcNow, CancellationToken ct);
+}

backend/src/Health.Application/Exercises/ExerciseService.cs

@@ -0,0 +1,143 @@
+using Health.Domain;
+using Health.Domain.Entities;
+
+namespace Health.Application.Exercises;
+
+public sealed class ExerciseService(IExerciseRepository exercises) : IExerciseService
+{
+    private const int MaxDurationMinutes = 1440;  // 单次运动时长上限 24 小时
+    private static readonly TimeOnly DefaultReminderTime = new(19, 0);
+    private readonly IExerciseRepository _exercises = exercises;
+
+    public async Task<ExercisePlanDto?> GetCurrentAsync(Guid userId, CancellationToken ct)
+    {
+        var today = BeijingToday();
+        var plans = await _exercises.ListActiveOnAsync(userId, today, ct);
+        var plan = plans.FirstOrDefault(p => p.Items.Any(i => i.ScheduledDate == today));
+        return plan == null ? null : ToDto(plan);
+    }
+
+    public async Task<Guid> CreateAsync(Guid userId, ExercisePlanCreateRequest request, CancellationToken ct)
+    {
+        ValidateDuration(request.DurationMinutes);
+
+        var startDate = request.StartDate;
+        var endDate = request.EndDate < startDate ? startDate : request.EndDate;
+        if (endDate.DayNumber - startDate.DayNumber > 365)
+            endDate = startDate.AddDays(365);
+
+        var exerciseType = string.IsNullOrWhiteSpace(request.ExerciseType) ? "运动" : request.ExerciseType.Trim();
+        var duration = request.DurationMinutes > 0 ? request.DurationMinutes : 30;
+        var plan = NewPlan(userId, startDate, endDate, request.ReminderTime);
+        for (var date = startDate; date <= endDate; date = date.AddDays(1))
+        {
+            plan.Items.Add(new ExercisePlanItem
+            {
+                Id = Guid.NewGuid(),
+                ScheduledDate = date,
+                ExerciseType = exerciseType,
+                DurationMinutes = duration,
+                IsRestDay = false,
+            });
+        }
+        await SaveNewAsync(plan, ct);
+        return plan.Id;
+    }
+
+
+    // 时长上限校验：下限交由各方法兜底为 30，这里只拦截不合理的超大值
+    private static void ValidateDuration(int durationMinutes)
+    {
+        if (durationMinutes > MaxDurationMinutes)
+            throw new ValidationException($"单次运动时长不能超过 {MaxDurationMinutes} 分钟（24 小时），当前值 {durationMinutes} 不合理");
+    }
+
+    public async Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAsync(Guid userId, CancellationToken ct)
+    {
+        var plans = await _exercises.ListAsync(userId, 20, ct);
+        return plans.Select(ToSummaryDto).ToList();
+    }
+
+    public async Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAllAsync(Guid userId, CancellationToken ct)
+    {
+        var plans = await _exercises.ListAllAsync(userId, ct);
+        return plans.Select(ToSummaryDto).ToList();
+    }
+
+    public async Task<ExercisePlanDto?> GetByIdAsync(Guid userId, Guid planId, CancellationToken ct)
+    {
+        var plan = await _exercises.GetOwnedPlanAsync(userId, planId, ct);
+        return plan == null ? null : ToDto(plan);
+    }
+
+    public async Task<bool> DeleteAsync(Guid userId, Guid planId, CancellationToken ct)
+    {
+        var plan = await _exercises.GetOwnedPlanAsync(userId, planId, ct);
+        if (plan == null) return false;
+        _exercises.Delete(plan);
+        await _exercises.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<bool?> ToggleCheckInAsync(Guid userId, Guid itemId, CancellationToken ct)
+    {
+        var item = await _exercises.GetOwnedItemAsync(userId, itemId, ct);
+        if (item == null) return null;
+        if (item.ScheduledDate != BeijingToday())
+            throw new ValidationException("只能打卡今天的运动任务");
+        if (item.IsRestDay)
+            throw new ValidationException("休息日无需打卡");
+        item.IsCompleted = !item.IsCompleted;
+        item.CompletedAt = item.IsCompleted ? DateTime.UtcNow : null;
+        item.Plan.UpdatedAt = DateTime.UtcNow;
+        await _exercises.SaveChangesAsync(ct);
+        return item.IsCompleted;
+    }
+
+    public async Task<bool> CheckInAsync(Guid userId, Guid itemId, CancellationToken ct)
+    {
+        var item = await _exercises.GetOwnedItemAsync(userId, itemId, ct);
+        if (item == null) return false;
+        if (item.ScheduledDate != BeijingToday())
+            throw new ValidationException("只能打卡今天的运动任务");
+        if (item.IsRestDay)
+            throw new ValidationException("休息日无需打卡");
+        item.IsCompleted = true;
+        item.CompletedAt = DateTime.UtcNow;
+        item.Plan.UpdatedAt = DateTime.UtcNow;
+        await _exercises.SaveChangesAsync(ct);
+        return true;
+    }
+
+    private async Task SaveNewAsync(ExercisePlan plan, CancellationToken ct)
+    {
+        await _exercises.AddAsync(plan, ct);
+        await _exercises.SaveChangesAsync(ct);
+    }
+
+    private static ExercisePlan NewPlan(Guid userId, DateOnly startDate, DateOnly endDate, TimeOnly? reminderTime) => new()
+    {
+        Id = Guid.NewGuid(),
+        UserId = userId,
+        StartDate = startDate,
+        EndDate = endDate,
+        ReminderTime = reminderTime ?? DefaultReminderTime,
+        CreatedAt = DateTime.UtcNow,
+        UpdatedAt = DateTime.UtcNow,
+    };
+
+    private static ExercisePlanDto ToDto(ExercisePlan plan) => new(
+        plan.Id, plan.StartDate, plan.EndDate, plan.ReminderTime, plan.CreatedAt, plan.UpdatedAt,
+        plan.Items.OrderBy(i => i.ScheduledDate).Select(ToItemDto).ToList());
+
+    private static ExercisePlanSummaryDto ToSummaryDto(ExercisePlan plan) => new(
+        plan.Id, plan.StartDate, plan.EndDate, plan.ReminderTime, plan.CreatedAt,
+        plan.Items.Count, plan.Items.Count(i => i.IsCompleted),
+        plan.Items.OrderBy(i => i.ScheduledDate).Select(ToItemDto).ToList());
+
+    private static ExercisePlanItemDto ToItemDto(ExercisePlanItem item) => new(
+        item.Id, item.ScheduledDate, item.ExerciseType, item.DurationMinutes,
+        item.IsCompleted, item.CompletedAt, item.IsRestDay);
+
+    private static DateOnly BeijingToday() => DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+}

backend/src/Health.Application/HealthArchives/HealthArchiveContracts.cs

@@ -0,0 +1,51 @@
+using Health.Domain.Entities;
+
+namespace Health.Application.HealthArchives;
+
+public sealed record HealthArchiveSurgeryDto(
+    Guid Id,
+    string Type,
+    DateOnly? Date);
+
+public sealed record HealthArchiveSurgeryInput(
+    string Type,
+    DateOnly? Date);
+
+public sealed record HealthArchiveDto(
+    Guid Id,
+    Guid UserId,
+    string? Diagnosis,
+    string? SurgeryType,
+    DateOnly? SurgeryDate,
+    IReadOnlyList<HealthArchiveSurgeryDto> Surgeries,
+    IReadOnlyList<string> Allergies,
+    IReadOnlyList<string> DietRestrictions,
+    IReadOnlyList<string> ChronicDiseases,
+    string? FamilyHistory,
+    string? SurgeryHistoryStatus,
+    DateTime UpdatedAt);
+
+public sealed record HealthArchiveUpdateRequest(
+    string? Diagnosis,
+    string? SurgeryType,
+    DateOnly? SurgeryDate,
+    IReadOnlyList<string>? Allergies,
+    IReadOnlyList<string>? DietRestrictions,
+    IReadOnlyList<string>? ChronicDiseases,
+    string? FamilyHistory,
+    IReadOnlyList<HealthArchiveSurgeryInput>? Surgeries = null,
+    string? SurgeryHistoryStatus = null);
+
+public interface IHealthArchiveService
+{
+    Task<HealthArchiveDto?> GetAsync(Guid userId, CancellationToken ct);
+    Task<HealthArchiveDto> UpdateAsync(Guid userId, HealthArchiveUpdateRequest request, CancellationToken ct);
+    Task<object> ExecuteAiActionAsync(Guid userId, string action, HealthArchiveUpdateRequest request, CancellationToken ct);
+}
+
+public interface IHealthArchiveRepository
+{
+    Task<HealthArchive?> GetByUserIdAsync(Guid userId, CancellationToken ct);
+    Task AddAsync(HealthArchive archive, CancellationToken ct);
+    Task SaveChangesAsync(CancellationToken ct);
+}

backend/src/Health.Application/HealthArchives/HealthArchiveService.cs

@@ -0,0 +1,184 @@
+using Health.Domain.Entities;
+
+using System.ComponentModel.DataAnnotations;
+
+namespace Health.Application.HealthArchives;
+
+public sealed class HealthArchiveService(IHealthArchiveRepository archives) : IHealthArchiveService
+{
+    private readonly IHealthArchiveRepository _archives = archives;
+
+    public async Task<HealthArchiveDto?> GetAsync(Guid userId, CancellationToken ct)
+    {
+        var archive = await _archives.GetByUserIdAsync(userId, ct);
+        return archive == null ? null : ToDto(archive);
+    }
+
+    public async Task<HealthArchiveDto> UpdateAsync(Guid userId, HealthArchiveUpdateRequest request, CancellationToken ct)
+    {
+        Validate(request);
+        var archive = await GetOrCreateEntityAsync(userId, ct);
+        Apply(archive, request);
+        archive.UpdatedAt = DateTime.UtcNow;
+        await _archives.SaveChangesAsync(ct);
+        return ToDto(archive);
+    }
+
+    public async Task<object> ExecuteAiActionAsync(Guid userId, string action, HealthArchiveUpdateRequest request, CancellationToken ct)
+    {
+        if (action == "query")
+        {
+            var archive = await GetAsync(userId, ct);
+            return archive == null ? new { found = false } : ToAiResult(archive);
+        }
+
+        var current = await GetOrCreateEntityAsync(userId, ct);
+        var scopedRequest = action switch
+        {
+            "update_diagnosis" => request with
+            {
+                SurgeryType = null, SurgeryDate = null, Allergies = null,
+                DietRestrictions = null, ChronicDiseases = null, FamilyHistory = null,
+                Surgeries = null
+            },
+            "update_surgery" => request with
+            {
+                Diagnosis = null, Allergies = null, DietRestrictions = null,
+                ChronicDiseases = null, FamilyHistory = null
+            },
+            "update_allergies" => new HealthArchiveUpdateRequest(null, null, null, request.Allergies, null, null, null),
+            "update_chronic_diseases" => new HealthArchiveUpdateRequest(null, null, null, null, null, request.ChronicDiseases, null),
+            "update_diet_restrictions" => new HealthArchiveUpdateRequest(null, null, null, null, request.DietRestrictions, null, null),
+            _ => null
+        };
+
+        if (scopedRequest == null)
+            return new { success = false, message = $"未知档案操作: {action}" };
+
+        Apply(current, scopedRequest);
+        current.UpdatedAt = DateTime.UtcNow;
+        await _archives.SaveChangesAsync(ct);
+        return new { success = true };
+    }
+
+    private async Task<HealthArchive> GetOrCreateEntityAsync(Guid userId, CancellationToken ct)
+    {
+        var archive = await _archives.GetByUserIdAsync(userId, ct);
+        if (archive != null) return archive;
+
+        archive = new HealthArchive { Id = Guid.NewGuid(), UserId = userId, UpdatedAt = DateTime.UtcNow };
+        await _archives.AddAsync(archive, ct);
+        return archive;
+    }
+
+    private static void Apply(HealthArchive archive, HealthArchiveUpdateRequest request)
+    {
+        if (request.Diagnosis != null) archive.Diagnosis = request.Diagnosis;
+        if (request.Surgeries != null)
+        {
+            archive.Surgeries.Clear();
+            var items = request.Surgeries
+                .Where(s => !string.IsNullOrWhiteSpace(s.Type))
+                .Select((s, index) => new HealthArchiveSurgery
+                {
+                    Id = Guid.NewGuid(),
+                    HealthArchiveId = archive.Id,
+                    Type = s.Type.Trim(),
+                    Date = s.Date,
+                    SortOrder = index,
+                })
+                .ToList();
+            foreach (var item in items) archive.Surgeries.Add(item);
+            SyncLegacySurgeryFields(archive);
+        }
+        else if (request.SurgeryType != null)
+        {
+            SeedLegacySurgeryIfNeeded(archive);
+            var type = request.SurgeryType.Trim();
+            if (type.Length > 0 && !archive.Surgeries.Any(s =>
+                    s.Type == type && s.Date == request.SurgeryDate))
+            {
+                archive.Surgeries.Add(new HealthArchiveSurgery
+                {
+                    Id = Guid.NewGuid(),
+                    HealthArchiveId = archive.Id,
+                    Type = type,
+                    Date = request.SurgeryDate,
+                    SortOrder = archive.Surgeries.Count,
+                });
+            }
+            SyncLegacySurgeryFields(archive);
+        }
+        if (request.Allergies != null) archive.Allergies = request.Allergies.ToList();
+        if (request.DietRestrictions != null) archive.DietRestrictions = request.DietRestrictions.ToList();
+        if (request.ChronicDiseases != null) archive.ChronicDiseases = request.ChronicDiseases.ToList();
+        if (request.FamilyHistory != null) archive.FamilyHistory = request.FamilyHistory;
+        if (request.SurgeryHistoryStatus != null)
+            archive.SurgeryHistoryStatus = request.SurgeryHistoryStatus;
+    }
+
+    private static void Validate(HealthArchiveUpdateRequest request)
+    {
+        if (request.SurgeryHistoryStatus is not null and not ("无" or "有"))
+            throw new ValidationException("手术史状态格式不正确");
+    }
+
+    private static object ToAiResult(HealthArchiveDto archive) => new
+    {
+        found = true,
+        archive.Diagnosis,
+        archive.SurgeryType,
+        SurgeryDate = archive.SurgeryDate?.ToString("yyyy-MM-dd"),
+        surgeries = archive.Surgeries.Select(s => new { s.Type, date = s.Date?.ToString("yyyy-MM-dd") }),
+        archive.Allergies,
+        archive.DietRestrictions,
+        archive.ChronicDiseases,
+        archive.FamilyHistory,
+        archive.SurgeryHistoryStatus,
+    };
+
+    private static HealthArchiveDto ToDto(HealthArchive archive) => new(
+        archive.Id,
+        archive.UserId,
+        archive.Diagnosis,
+        archive.SurgeryType,
+        archive.SurgeryDate,
+        GetSurgeries(archive),
+        archive.Allergies,
+        archive.DietRestrictions,
+        archive.ChronicDiseases,
+        archive.FamilyHistory,
+        archive.SurgeryHistoryStatus,
+        archive.UpdatedAt);
+
+    private static IReadOnlyList<HealthArchiveSurgeryDto> GetSurgeries(HealthArchive archive)
+    {
+        var surgeries = archive.Surgeries
+            .OrderBy(s => s.SortOrder)
+            .Select(s => new HealthArchiveSurgeryDto(s.Id, s.Type, s.Date))
+            .ToList();
+        if (surgeries.Count == 0 && !string.IsNullOrWhiteSpace(archive.SurgeryType))
+            surgeries.Add(new HealthArchiveSurgeryDto(Guid.Empty, archive.SurgeryType, archive.SurgeryDate));
+        return surgeries;
+    }
+
+    private static void SyncLegacySurgeryFields(HealthArchive archive)
+    {
+        var first = archive.Surgeries.OrderBy(s => s.SortOrder).FirstOrDefault();
+        archive.SurgeryType = first?.Type;
+        archive.SurgeryDate = first?.Date;
+    }
+
+    private static void SeedLegacySurgeryIfNeeded(HealthArchive archive)
+    {
+        if (archive.Surgeries.Count > 0 || string.IsNullOrWhiteSpace(archive.SurgeryType)) return;
+        archive.Surgeries.Add(new HealthArchiveSurgery
+        {
+            Id = Guid.NewGuid(),
+            HealthArchiveId = archive.Id,
+            Type = archive.SurgeryType,
+            Date = archive.SurgeryDate,
+            SortOrder = 0,
+        });
+    }
+}

backend/src/Health.Application/HealthRecords/HealthRecordContracts.cs

@@ -0,0 +1,46 @@
+using Health.Domain.Enums;
+using Health.Domain.Entities;
+
+namespace Health.Application.HealthRecords;
+
+public sealed record HealthRecordUpsertRequest(
+    HealthMetricType Type,
+    int? Systolic,
+    int? Diastolic,
+    decimal? Value,
+    string? Unit,
+    HealthRecordSource Source,
+    DateTime? RecordedAt);
+
+public sealed record HealthRecordDto(
+    Guid Id,
+    string Type,
+    int? Systolic,
+    int? Diastolic,
+    decimal? Value,
+    string? Unit,
+    string Source,
+    bool IsAbnormal,
+    DateTime RecordedAt);
+
+public interface IHealthRecordService
+{
+    Task<IReadOnlyList<HealthRecordDto>> GetRecordsAsync(Guid userId, string? type, int? days, CancellationToken ct);
+    Task<Guid> CreateAsync(Guid userId, HealthRecordUpsertRequest request, CancellationToken ct);
+    Task<IReadOnlyList<Guid>> CreateManyAsync(Guid userId, IReadOnlyList<HealthRecordUpsertRequest> requests, CancellationToken ct);
+    Task<bool> UpdateAsync(Guid userId, Guid id, HealthRecordUpsertRequest request, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid id, CancellationToken ct);
+    Task<Dictionary<string, object?>> GetLatestAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<object>> GetTrendAsync(Guid userId, HealthMetricType type, int period, CancellationToken ct);
+}
+
+public interface IHealthRecordRepository
+{
+    Task<IReadOnlyList<HealthRecord>> ListAsync(Guid userId, HealthMetricType? type, DateTime? recordedAfter, int limit, CancellationToken ct);
+    Task<HealthRecord?> GetOwnedAsync(Guid userId, Guid id, CancellationToken ct);
+    Task<HealthRecord?> GetLatestByTypeAsync(Guid userId, HealthMetricType type, CancellationToken ct);
+    Task<IReadOnlyList<HealthRecord>> GetTrendAsync(Guid userId, HealthMetricType type, DateTime recordedAfter, CancellationToken ct);
+    Task AddAsync(HealthRecord record, CancellationToken ct);
+    void Delete(HealthRecord record);
+    Task SaveChangesAsync(CancellationToken ct);
+}

backend/src/Health.Application/HealthRecords/HealthRecordRules.cs

@@ -0,0 +1,60 @@
+using Health.Domain;
+using Health.Domain.Enums;
+
+namespace Health.Application.HealthRecords;
+
+public static class HealthRecordRules
+{
+    public static bool CheckAbnormal(HealthRecordUpsertRequest request) => request.Type switch
+    {
+        HealthMetricType.BloodPressure => request.Systolic >= 140 || request.Diastolic >= 90 || request.Systolic <= 89 || request.Diastolic <= 59,
+        HealthMetricType.HeartRate => request.Value > 100 || request.Value < 60,
+        HealthMetricType.Glucose => request.Value > 6.1m || request.Value < 3.9m,
+        HealthMetricType.SpO2 => request.Value <= 94,
+        HealthMetricType.Weight => false,
+        _ => false
+    };
+
+    /// <summary>
+    /// 合法性校验——拦截物理上不可能的数值（负数、超量程等），不合法即抛 ValidationException。
+    /// 注意：这与 CheckAbnormal（医学异常预警）是两回事，前者拦脏数据，后者只是标记偏离正常范围。
+    /// </summary>
+    public static void Validate(HealthRecordUpsertRequest request)
+    {
+        switch (request.Type)
+        {
+            case HealthMetricType.BloodPressure:
+                var sys = Required(request.Systolic, "收缩压");
+                var dia = Required(request.Diastolic, "舒张压");
+                InRange(sys, 40, 300, "收缩压", "mmHg");
+                InRange(dia, 20, 250, "舒张压", "mmHg");
+                if (sys <= dia)
+                    throw new ValidationException("收缩压必须大于舒张压");
+                break;
+            case HealthMetricType.HeartRate:
+                InRange(Required(request.Value, "心率"), 20m, 300m, "心率", "次/分");
+                break;
+            case HealthMetricType.Glucose:
+                InRange(Required(request.Value, "血糖"), 0.5m, 60m, "血糖", "mmol/L");
+                break;
+            case HealthMetricType.SpO2:
+                InRange(Required(request.Value, "血氧"), 50m, 100m, "血氧", "%");
+                break;
+            case HealthMetricType.Weight:
+                InRange(Required(request.Value, "体重"), 1m, 500m, "体重", "kg");
+                break;
+        }
+    }
+
+    private static int Required(int? value, string field) =>
+        value ?? throw new ValidationException($"{field}不能为空");
+
+    private static decimal Required(decimal? value, string field) =>
+        value ?? throw new ValidationException($"{field}不能为空");
+
+    private static void InRange(decimal value, decimal min, decimal max, string field, string unit)
+    {
+        if (value < min || value > max)
+            throw new ValidationException($"{field}应在 {min}~{max} {unit} 之间，当前值 {value} 不合理");
+    }
+}

backend/src/Health.Application/HealthRecords/HealthRecordService.cs

@@ -0,0 +1,215 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+using Health.Application.Notifications;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Health.Application.HealthRecords;
+
+public sealed class HealthRecordService(
+    IHealthRecordRepository records,
+    IUserNotificationProducer? notifications = null) : IHealthRecordService
+{
+    private readonly IHealthRecordRepository _records = records;
+    private readonly IUserNotificationProducer? _notifications = notifications;
+
+    public async Task<IReadOnlyList<HealthRecordDto>> GetRecordsAsync(Guid userId, string? type, int? days, CancellationToken ct)
+    {
+        HealthMetricType? metricType = null;
+        if (!string.IsNullOrEmpty(type) && Enum.TryParse<HealthMetricType>(type, ignoreCase: true, out var parsed))
+            metricType = parsed;
+
+        var recordedAfter = days.HasValue ? DateTime.UtcNow.AddDays(-days.Value) : (DateTime?)null;
+        var result = await _records.ListAsync(userId, metricType, recordedAfter, 100, ct);
+        return result.Select(ToDto).ToList();
+    }
+
+    public async Task<Guid> CreateAsync(Guid userId, HealthRecordUpsertRequest request, CancellationToken ct)
+    {
+        HealthRecordRules.Validate(request);
+
+        var record = new HealthRecord
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            MetricType = request.Type,
+            Systolic = request.Systolic,
+            Diastolic = request.Diastolic,
+            Value = request.Value,
+            Unit = request.Unit,
+            Source = request.Source,
+            RecordedAt = request.RecordedAt ?? DateTime.UtcNow,
+            CreatedAt = DateTime.UtcNow,
+            IsAbnormal = HealthRecordRules.CheckAbnormal(request),
+        };
+
+        await _records.AddAsync(record, ct);
+        await _records.SaveChangesAsync(ct);
+        await EnqueueAbnormalNotificationAsync(record, ct);
+        return record.Id;
+    }
+
+    public async Task<IReadOnlyList<Guid>> CreateManyAsync(
+        Guid userId,
+        IReadOnlyList<HealthRecordUpsertRequest> requests,
+        CancellationToken ct)
+    {
+        if (requests.Count == 0)
+            throw new ArgumentException("至少需要一条健康记录", nameof(requests));
+
+        foreach (var request in requests)
+            HealthRecordRules.Validate(request);
+
+        var now = DateTime.UtcNow;
+        var records = requests.Select(request => new HealthRecord
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            MetricType = request.Type,
+            Systolic = request.Systolic,
+            Diastolic = request.Diastolic,
+            Value = request.Value,
+            Unit = request.Unit,
+            Source = request.Source,
+            RecordedAt = request.RecordedAt ?? now,
+            CreatedAt = now,
+            IsAbnormal = HealthRecordRules.CheckAbnormal(request),
+        }).ToList();
+
+        foreach (var record in records)
+            await _records.AddAsync(record, ct);
+
+        await _records.SaveChangesAsync(ct);
+
+        foreach (var record in records)
+            await EnqueueAbnormalNotificationAsync(record, ct);
+
+        return records.Select(record => record.Id).ToList();
+    }
+
+    public async Task<bool> UpdateAsync(Guid userId, Guid id, HealthRecordUpsertRequest request, CancellationToken ct)
+    {
+        var record = await _records.GetOwnedAsync(userId, id, ct);
+        if (record == null) return false;
+
+        HealthRecordRules.Validate(request);
+
+        record.MetricType = request.Type;
+        record.Systolic = request.Systolic;
+        record.Diastolic = request.Diastolic;
+        record.Value = request.Value;
+        record.Unit = request.Unit;
+        record.Source = request.Source;
+        record.RecordedAt = request.RecordedAt ?? record.RecordedAt;
+        record.IsAbnormal = HealthRecordRules.CheckAbnormal(request);
+
+        await _records.SaveChangesAsync(ct);
+        await EnqueueAbnormalNotificationAsync(record, ct);
+        return true;
+    }
+
+    public async Task<bool> DeleteAsync(Guid userId, Guid id, CancellationToken ct)
+    {
+        var record = await _records.GetOwnedAsync(userId, id, ct);
+        if (record == null) return false;
+
+        _records.Delete(record);
+        await _records.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<Dictionary<string, object?>> GetLatestAsync(Guid userId, CancellationToken ct)
+    {
+        var types = new[]
+        {
+            HealthMetricType.BloodPressure,
+            HealthMetricType.HeartRate,
+            HealthMetricType.Glucose,
+            HealthMetricType.SpO2,
+            HealthMetricType.Weight
+        };
+
+        var result = new Dictionary<string, object?>();
+        foreach (var type in types)
+        {
+            var latest = await _records.GetLatestByTypeAsync(userId, type, ct);
+            result[type.ToString()] = latest == null ? null : new
+            {
+                latest.Systolic,
+                latest.Diastolic,
+                latest.Value,
+                latest.Unit,
+                latest.IsAbnormal,
+                latest.RecordedAt
+            };
+        }
+
+        return result;
+    }
+
+    public async Task<IReadOnlyList<object>> GetTrendAsync(Guid userId, HealthMetricType type, int period, CancellationToken ct)
+    {
+        var days = period switch { 7 => 7, 30 => 30, 90 => 90, 365 => 365, _ => 7 };
+        var records = await _records.GetTrendAsync(userId, type, DateTime.UtcNow.AddDays(-days), ct);
+        return records.Select(r => new { r.Id, r.Systolic, r.Diastolic, r.Value, r.Unit, r.IsAbnormal, r.RecordedAt }).Cast<object>().ToList();
+    }
+
+    public static HealthRecordDto ToDto(HealthRecord record) => new(
+        record.Id,
+        record.MetricType.ToString(),
+        record.Systolic,
+        record.Diastolic,
+        record.Value,
+        record.Unit,
+        record.Source.ToString(),
+        record.IsAbnormal,
+        record.RecordedAt);
+
+    private async Task EnqueueAbnormalNotificationAsync(HealthRecord record, CancellationToken ct)
+    {
+        if (!record.IsAbnormal || _notifications == null) return;
+
+        var (title, message, severity, target) = record.MetricType switch
+        {
+            HealthMetricType.BloodPressure when record.Systolic >= 140 || record.Diastolic >= 90 =>
+                ("血压偏高提醒", $"本次血压为 {record.Systolic}/{record.Diastolic} mmHg，高于参考范围。建议休息后复测；如伴明显不适，请及时就医。", "warning", "blood_pressure"),
+            HealthMetricType.BloodPressure =>
+                ("血压偏低提醒", $"本次血压为 {record.Systolic}/{record.Diastolic} mmHg，低于参考范围。请留意头晕、乏力等不适，必要时及时就医。", "warning", "blood_pressure"),
+            HealthMetricType.HeartRate when record.Value > 100 =>
+                ("心率偏高提醒", $"本次心率为 {record.Value:0.#} 次/分，高于参考范围。建议安静休息后复测。", "warning", "heart_rate"),
+            HealthMetricType.HeartRate =>
+                ("心率偏低提醒", $"本次心率为 {record.Value:0.#} 次/分，低于参考范围。如伴明显不适，请及时就医。", "warning", "heart_rate"),
+            HealthMetricType.Glucose when record.Value > 6.1m =>
+                ("血糖偏高提醒", $"本次血糖为 {record.Value:0.#} mmol/L，高于参考范围。请结合测量时段并按计划复测。", "warning", "glucose"),
+            HealthMetricType.Glucose =>
+                ("血糖偏低提醒", $"本次血糖为 {record.Value:0.#} mmol/L，低于参考范围。请及时关注身体状况。", "critical", "glucose"),
+            HealthMetricType.SpO2 =>
+                ("血氧偏低提醒", $"本次血氧为 {record.Value:0.#}%，低于参考范围。建议立即复测；如持续偏低或伴呼吸不适，请及时就医。", "critical", "spo2"),
+            _ => ("健康指标提醒", "检测到一项健康指标超出参考范围，请查看详情。", "warning", "")
+        };
+
+        var citation = record.MetricType switch
+        {
+            HealthMetricType.BloodPressure => "参考来源：\n[S-BP-01] 2024 ESC Guidelines for the management of elevated blood pressure and hypertension\nhttps://pubmed.ncbi.nlm.nih.gov/39210715/",
+            HealthMetricType.Glucose => "参考来源：\n[S-GLU-01] Glycemic Goals and Hypoglycemia: Standards of Care in Diabetes—2025\nhttps://pubmed.ncbi.nlm.nih.gov/39651981/",
+            HealthMetricType.HeartRate => "参考来源：\n[S-HR-01] All About Heart Rate, American Heart Association\nhttps://www.heart.org/en/health-topics/high-blood-pressure/the-facts-about-high-blood-pressure/all-about-heart-rate-pulse",
+            HealthMetricType.SpO2 => "参考来源：\n[S-OXY-01] Pulse Oximeter Basics, U.S. Food and Drug Administration\nhttps://www.fda.gov/consumers/consumer-updates/pulse-oximeter-basics",
+            _ => string.Empty,
+        };
+        if (!string.IsNullOrWhiteSpace(citation)) message = $"{message}\n\n{citation}";
+
+        var window = DateTime.UtcNow.Ticks / TimeSpan.FromMinutes(30).Ticks;
+        var sourceId = DeterministicGuid($"{record.UserId}:{record.MetricType}:{severity}:{window}");
+        await _notifications.EnqueueAsync(
+            record.UserId,
+            sourceId,
+            new NotificationMessage("HealthMetricAlert", title, message, severity, "health", target),
+            ct);
+    }
+
+    private static Guid DeterministicGuid(string value)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(value));
+        return new Guid(hash.AsSpan(0, 16));
+    }
+}

backend/src/Health.Application/Maintenance/MaintenanceContracts.cs

@@ -0,0 +1,16 @@
+namespace Health.Application.Maintenance;
+
+public sealed record MaintenanceCleanupResult(
+    int Conversations,
+    int VerificationCodes,
+    int BackgroundTasks);
+
+public interface IMaintenanceService
+{
+    Task<MaintenanceCleanupResult> CleanupAsync(DateTime utcNow, CancellationToken ct);
+}
+
+public interface IMaintenanceRepository
+{
+    Task<MaintenanceCleanupResult> CleanupAsync(DateTime conversationCutoff, DateTime taskCutoff, DateTime utcNow, CancellationToken ct);
+}

backend/src/Health.Application/Maintenance/MaintenanceService.cs

@@ -0,0 +1,9 @@
+namespace Health.Application.Maintenance;
+
+public sealed class MaintenanceService(IMaintenanceRepository repository) : IMaintenanceService
+{
+    private readonly IMaintenanceRepository _repository = repository;
+
+    public Task<MaintenanceCleanupResult> CleanupAsync(DateTime utcNow, CancellationToken ct) =>
+        _repository.CleanupAsync(utcNow.AddDays(-30), utcNow.AddDays(-30), utcNow, ct);
+}

backend/src/Health.Application/Medications/MedicationContracts.cs

@@ -0,0 +1,117 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Medications;
+
+public sealed record MedicationUpsertRequest(
+    string Name,
+    string? Dosage,
+    MedicationFrequency Frequency,
+    IReadOnlyList<TimeOnly> TimeOfDay,
+    DateOnly? StartDate,
+    DateOnly? EndDate,
+    MedicationSource Source,
+    string? Notes);
+
+public sealed record MedicationPatchRequest(
+    string? Name,
+    string? Dosage,
+    MedicationFrequency? Frequency,
+    IReadOnlyList<TimeOnly>? TimeOfDay,
+    DateOnly? StartDate,
+    DateOnly? EndDate,
+    string? Notes,
+    bool ClearEndDate = false);
+
+public sealed record MedicationDto(
+    Guid Id,
+    string Name,
+    string? Dosage,
+    string Frequency,
+    IReadOnlyList<TimeOnly> TimeOfDay,
+    DateOnly? StartDate,
+    DateOnly? EndDate,
+    bool IsActive,
+    string? Notes,
+    string Source,
+    DateTime CreatedAt,
+    DateTime UpdatedAt,
+    bool TodayTaken);
+
+public sealed record MedicationReminderDto(
+    Guid Id,
+    string Name,
+    string? Dosage,
+    string ScheduledTime,
+    string Status);
+
+public sealed record AiMedicationDoseDto(
+    string ScheduledTime,
+    string Status);
+
+public sealed record AiMedicationPlanDto(
+    Guid Id,
+    string Name,
+    string? Dosage,
+    string Frequency,
+    DateOnly? StartDate,
+    DateOnly? EndDate,
+    string Phase,
+    bool ScheduledOnDate,
+    IReadOnlyList<AiMedicationDoseDto> Doses);
+
+public sealed record MedicationReminderTask(
+    Guid TaskId,
+    Guid UserId,
+    Guid MedicationId,
+    string Name,
+    string? Dosage,
+    DateOnly ScheduledDate,
+    TimeOnly ScheduledTime);
+
+public interface IMedicationService
+{
+    Task<IReadOnlyList<MedicationDto>> ListAsync(Guid userId, string? filter, CancellationToken ct);
+    Task<Guid> CreateAsync(Guid userId, MedicationUpsertRequest request, CancellationToken ct);
+    Task<bool> UpdateAsync(Guid userId, Guid medicationId, MedicationPatchRequest request, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid medicationId, CancellationToken ct);
+    Task<IReadOnlyList<MedicationReminderDto>> GetRemindersAsync(Guid userId, CancellationToken ct);
+    Task<bool?> ConfirmDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, MedicationLogStatus status, CancellationToken ct);
+    Task<bool> CancelDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, CancellationToken ct);
+    Task<IReadOnlyList<AiMedicationPlanDto>> GetAiOverviewAsync(Guid userId, DateOnly date, CancellationToken ct);
+}
+
+public interface IMedicationRepository
+{
+    Task<IReadOnlyList<Medication>> ListAsync(Guid userId, string? filter, CancellationToken ct);
+    Task<IReadOnlyList<Medication>> ListActiveForRemindersAsync(Guid userId, DateOnly today, CancellationToken ct);
+    Task<IReadOnlyList<MedicationLog>> ListLogsInWindowAsync(Guid userId, DateTime startUtc, DateTime endUtc, CancellationToken ct);
+    Task<Medication?> GetOwnedAsync(Guid userId, Guid medicationId, CancellationToken ct);
+    Task<bool> DoseLogExistsAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, DateTime startUtc, DateTime endUtc, CancellationToken ct);
+    Task<MedicationLog?> GetDoseLogAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, DateTime startUtc, DateTime endUtc, CancellationToken ct);
+    Task<IReadOnlyList<Medication>> ListActiveForReminderScanAsync(CancellationToken ct);
+    Task AddMedicationAsync(Medication medication, CancellationToken ct);
+    Task AddLogAsync(MedicationLog log, CancellationToken ct);
+    void DeleteMedication(Medication medication);
+    void DeleteLog(MedicationLog log);
+    Task SaveChangesAsync(CancellationToken ct);
+}
+
+public interface IMedicationReminderScanner
+{
+    Task<IReadOnlyList<MedicationReminderTask>> ScanAsync(DateTime utcNow, CancellationToken ct);
+}
+
+public interface IMedicationReminderQueue
+{
+    Task<bool> EnqueueAsync(MedicationReminderTask task, CancellationToken ct);
+    Task RecoverStaleAsync(CancellationToken ct);
+    Task<MedicationReminderTask?> TryTakeAsync(CancellationToken ct);
+    Task CompleteAsync(Guid taskId, CancellationToken ct);
+    Task RetryAsync(Guid taskId, string error, CancellationToken ct);
+}
+
+public interface IMedicationReminderDispatcher
+{
+    Task DispatchAsync(MedicationReminderTask task, CancellationToken ct);
+}

backend/src/Health.Application/Medications/MedicationReminderScanner.cs

@@ -0,0 +1,72 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Medications;
+
+public sealed class MedicationReminderScanner(IMedicationRepository medications) : IMedicationReminderScanner
+{
+    private readonly IMedicationRepository _medications = medications;
+
+    public async Task<IReadOnlyList<MedicationReminderTask>> ScanAsync(DateTime utcNow, CancellationToken ct)
+    {
+        var beijingNow = utcNow.AddHours(8);
+        var date = DateOnly.FromDateTime(beijingNow);
+        var time = TimeOnly.FromDateTime(beijingNow);
+        var windowStart = time.AddMinutes(-5);
+        var todayStartUtc = beijingNow.Date.AddHours(-8);
+        var todayEndUtc = todayStartUtc.AddDays(1);
+        var active = await _medications.ListActiveForReminderScanAsync(ct);
+        var tasks = new List<MedicationReminderTask>();
+
+        foreach (var medication in active)
+        {
+            if (!IsActiveOn(medication, date) || !GetDosesForToday(medication, date)) continue;
+
+            foreach (var scheduledTime in medication.TimeOfDay.Where(t => IsInWindow(t, windowStart, time)))
+            {
+                if (await _medications.DoseLogExistsAsync(
+                    medication.UserId,
+                    medication.Id,
+                    scheduledTime,
+                    todayStartUtc,
+                    todayEndUtc,
+                    ct))
+                    continue;
+
+                tasks.Add(new MedicationReminderTask(
+                    Guid.NewGuid(),
+                    medication.UserId,
+                    medication.Id,
+                    medication.Name,
+                    medication.Dosage,
+                    date,
+                    scheduledTime));
+            }
+        }
+
+        return tasks;
+    }
+
+    private static bool IsActiveOn(Medication medication, DateOnly date) =>
+        (medication.StartDate == null || medication.StartDate <= date)
+        && (medication.EndDate == null || medication.EndDate >= date);
+
+    private static bool IsInWindow(TimeOnly value, TimeOnly start, TimeOnly end) =>
+        end >= start ? value >= start && value <= end : value >= start || value <= end;
+
+    private static bool GetDosesForToday(Medication medication, DateOnly today)
+    {
+        if (medication.Frequency is MedicationFrequency.Daily
+            or MedicationFrequency.TwiceDaily
+            or MedicationFrequency.ThreeTimesDaily
+            or MedicationFrequency.AsNeeded)
+            return true;
+
+        var startDate = medication.StartDate ?? today;
+        if (medication.Frequency == MedicationFrequency.EveryOtherDay)
+            return (today.DayNumber - startDate.DayNumber) % 2 == 0;
+        if (medication.Frequency == MedicationFrequency.Weekly)
+            return today.DayOfWeek == startDate.DayOfWeek;
+        return true;
+    }
+}

backend/src/Health.Application/Medications/MedicationScheduleStatus.cs

@@ -0,0 +1,18 @@
+using Health.Domain.Enums;
+
+namespace Health.Application.Medications;
+
+public static class MedicationScheduleStatus
+{
+    public static string Resolve(
+        TimeOnly scheduledTime,
+        TimeOnly currentTime,
+        MedicationLogStatus? logStatus)
+    {
+        if (logStatus.HasValue)
+            return logStatus == MedicationLogStatus.Taken ? "taken" : "skipped";
+        if (scheduledTime <= currentTime.AddMinutes(-30)) return "overdue";
+        if (scheduledTime <= currentTime.AddHours(3)) return "upcoming";
+        return "scheduled";
+    }
+}

backend/src/Health.Application/Medications/MedicationService.cs

@@ -0,0 +1,281 @@
+using Health.Domain;
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Medications;
+
+public sealed class MedicationService(IMedicationRepository medications) : IMedicationService
+{
+    private readonly IMedicationRepository _medications = medications;
+
+    public async Task<IReadOnlyList<MedicationDto>> ListAsync(Guid userId, string? filter, CancellationToken ct)
+    {
+        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
+        var meds = await _medications.ListAsync(userId, filter, ct);
+        return meds.Select(m => ToDto(m, HasTakenToday(m, todayStartUtc, todayEndUtc))).ToList();
+    }
+
+    public async Task<Guid> CreateAsync(Guid userId, MedicationUpsertRequest request, CancellationToken ct)
+    {
+        var name = ValidateName(request.Name);
+        ValidateDateRange(request.StartDate, request.EndDate);
+        var times = NormalizeTimes(request.TimeOfDay);
+        if (times.Count == 0) times = [new TimeOnly(8, 0)];
+
+        var med = new Medication
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            Name = name,
+            Dosage = request.Dosage,
+            Frequency = request.Frequency,
+            TimeOfDay = times,
+            StartDate = request.StartDate,
+            EndDate = request.EndDate,
+            Source = request.Source,
+            Notes = request.Notes,
+            IsActive = true,
+            CreatedAt = DateTime.UtcNow,
+            UpdatedAt = DateTime.UtcNow,
+        };
+
+        await _medications.AddMedicationAsync(med, ct);
+        await _medications.SaveChangesAsync(ct);
+        return med.Id;
+    }
+
+    public async Task<bool> UpdateAsync(Guid userId, Guid medicationId, MedicationPatchRequest request, CancellationToken ct)
+    {
+        var med = await _medications.GetOwnedAsync(userId, medicationId, ct);
+        if (med == null) return false;
+
+        if (request.Name != null) med.Name = ValidateName(request.Name);
+        if (request.Dosage != null) med.Dosage = request.Dosage;
+        if (request.Frequency.HasValue) med.Frequency = request.Frequency.Value;
+        if (request.TimeOfDay != null) med.TimeOfDay = NormalizeTimes(request.TimeOfDay);
+        if (request.StartDate.HasValue) med.StartDate = request.StartDate.Value;
+        if (request.ClearEndDate) med.EndDate = null;
+        else if (request.EndDate.HasValue) med.EndDate = request.EndDate.Value;
+        ValidateDateRange(med.StartDate, med.EndDate);
+        if (request.Notes != null) med.Notes = request.Notes;
+        med.UpdatedAt = DateTime.UtcNow;
+
+        await _medications.SaveChangesAsync(ct);
+        return true;
+    }
+
+    // ── 输入校验 ──
+
+    private static string ValidateName(string? name)
+    {
+        var trimmed = name?.Trim();
+        if (string.IsNullOrEmpty(trimmed))
+            throw new ValidationException("药品名称不能为空");
+        if (trimmed.Length > 200)
+            throw new ValidationException("药品名称过长（不超过 200 字）");
+        return trimmed;
+    }
+
+    private static void ValidateDateRange(DateOnly? startDate, DateOnly? endDate)
+    {
+        if (startDate.HasValue && endDate.HasValue && endDate.Value < startDate.Value)
+            throw new ValidationException("结束日期不能早于开始日期");
+    }
+
+    // 同一时间点去重并排序；空集合交由调用方/实体默认处理
+    private static List<TimeOnly> NormalizeTimes(IReadOnlyList<TimeOnly> times) =>
+        times.Distinct().OrderBy(t => t).ToList();
+
+    public async Task<bool> DeleteAsync(Guid userId, Guid medicationId, CancellationToken ct)
+    {
+        var med = await _medications.GetOwnedAsync(userId, medicationId, ct);
+        if (med == null) return false;
+
+        _medications.DeleteMedication(med);
+        await _medications.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<IReadOnlyList<MedicationReminderDto>> GetRemindersAsync(Guid userId, CancellationToken ct)
+    {
+        var beijingNow = DateTime.UtcNow.AddHours(8);
+        var now = TimeOnly.FromDateTime(beijingNow);
+        var today = DateOnly.FromDateTime(beijingNow);
+        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
+
+        var meds = await _medications.ListActiveForRemindersAsync(userId, today, ct);
+        var logs = await _medications.ListLogsInWindowAsync(userId, todayStartUtc, todayEndUtc, ct);
+
+        var reminders = new List<MedicationReminderDto>();
+        foreach (var med in meds)
+        {
+            if (!GetDosesForToday(med, today)) continue;
+
+            foreach (var scheduledTime in med.TimeOfDay)
+            {
+                var log = logs.FirstOrDefault(l => l.MedicationId == med.Id && l.ScheduledTime == scheduledTime);
+                var status = MedicationScheduleStatus.Resolve(
+                    scheduledTime,
+                    now,
+                    log?.Status);
+
+                reminders.Add(new MedicationReminderDto(med.Id, med.Name, med.Dosage, scheduledTime.ToString("HH:mm"), status));
+            }
+        }
+
+        return reminders
+            .OrderBy(r => r.Status == "overdue" ? 0 : r.Status == "upcoming" ? 1 : 2)
+            .ToList();
+    }
+
+    public async Task<bool?> ConfirmDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, MedicationLogStatus status, CancellationToken ct)
+    {
+        var medication = await _medications.GetOwnedAsync(userId, medicationId, ct);
+        if (medication == null) return null;
+
+        var today = BeijingToday();
+        if (!IsActiveOn(medication, today) ||
+            !GetDosesForToday(medication, today) ||
+            !medication.TimeOfDay.Contains(scheduledTime))
+            return false;
+
+        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
+        var existing = await _medications.DoseLogExistsAsync(userId, medicationId, scheduledTime, todayStartUtc, todayEndUtc, ct);
+        if (existing) return false;
+
+        await AddLogAsync(userId, medicationId, status, scheduledTime, ct);
+        return true;
+    }
+
+    public async Task<bool> CancelDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, CancellationToken ct)
+    {
+        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
+        var log = await _medications.GetDoseLogAsync(userId, medicationId, scheduledTime, todayStartUtc, todayEndUtc, ct);
+        if (log == null) return false;
+
+        _medications.DeleteLog(log);
+        await _medications.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<IReadOnlyList<AiMedicationPlanDto>> GetAiOverviewAsync(
+        Guid userId,
+        DateOnly date,
+        CancellationToken ct)
+    {
+        var medications = await _medications.ListAsync(userId, null, ct);
+        var (startUtc, endUtc) = GetBeijingDateUtcWindow(date);
+        var logs = await _medications.ListLogsInWindowAsync(userId, startUtc, endUtc, ct);
+        var today = BeijingToday();
+        var now = TimeOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+
+        return medications.Select(medication =>
+        {
+            var phase = ResolvePhase(medication, date);
+            var scheduled = phase == "active" && GetDosesForToday(medication, date);
+            var doses = scheduled
+                ? medication.TimeOfDay.OrderBy(time => time).Select(time =>
+                {
+                    var log = logs.FirstOrDefault(item =>
+                        item.MedicationId == medication.Id && item.ScheduledTime == time);
+                    var status = log != null
+                        ? log.Status.ToString().ToLowerInvariant()
+                        : date < today
+                            ? "missed"
+                            : date > today
+                                ? "scheduled"
+                                : MedicationScheduleStatus.Resolve(time, now, null);
+                    return new AiMedicationDoseDto(time.ToString("HH:mm"), status);
+                }).ToList()
+                : [];
+
+            return new AiMedicationPlanDto(
+                medication.Id,
+                medication.Name,
+                medication.Dosage,
+                medication.Frequency.ToString(),
+                medication.StartDate,
+                medication.EndDate,
+                phase,
+                scheduled,
+                doses);
+        }).ToList();
+    }
+
+    private async Task AddLogAsync(Guid userId, Guid medicationId, MedicationLogStatus status, TimeOnly scheduledTime, CancellationToken ct)
+    {
+        await _medications.AddLogAsync(new MedicationLog
+        {
+            Id = Guid.NewGuid(),
+            MedicationId = medicationId,
+            UserId = userId,
+            Status = status,
+            ScheduledTime = scheduledTime,
+            ConfirmedAt = DateTime.UtcNow,
+            CreatedAt = DateTime.UtcNow,
+        }, ct);
+        await _medications.SaveChangesAsync(ct);
+    }
+
+    private static MedicationDto ToDto(Medication med, bool todayTaken) => new(
+        med.Id,
+        med.Name,
+        med.Dosage,
+        med.Frequency.ToString(),
+        med.TimeOfDay,
+        med.StartDate,
+        med.EndDate,
+        med.IsActive,
+        med.Notes,
+        med.Source.ToString(),
+        med.CreatedAt,
+        med.UpdatedAt,
+        todayTaken);
+
+    private static bool HasTakenToday(Medication med, DateTime todayStartUtc, DateTime todayEndUtc) =>
+        med.Logs.Any(l => l.CreatedAt >= todayStartUtc && l.CreatedAt < todayEndUtc && l.Status == MedicationLogStatus.Taken);
+
+    private static (DateTime StartUtc, DateTime EndUtc) GetBeijingTodayUtcWindow()
+    {
+        return GetBeijingDateUtcWindow(BeijingToday());
+    }
+
+    private static (DateTime StartUtc, DateTime EndUtc) GetBeijingDateUtcWindow(DateOnly date)
+    {
+        var startUtc = DateTime.SpecifyKind(date.ToDateTime(TimeOnly.MinValue).AddHours(-8), DateTimeKind.Utc);
+        return (startUtc, startUtc.AddDays(1));
+    }
+
+    private static DateOnly BeijingToday() => DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+
+    private static bool IsActiveOn(Medication medication, DateOnly date) =>
+        medication.IsActive &&
+        (!medication.StartDate.HasValue || medication.StartDate.Value <= date) &&
+        (!medication.EndDate.HasValue || medication.EndDate.Value >= date);
+
+    private static string ResolvePhase(Medication medication, DateOnly date)
+    {
+        if (!medication.IsActive) return "inactive";
+        if (medication.StartDate.HasValue && medication.StartDate.Value > date) return "upcoming";
+        if (medication.EndDate.HasValue && medication.EndDate.Value < date) return "ended";
+        return "active";
+    }
+
+    private static bool GetDosesForToday(Medication med, DateOnly today)
+    {
+        if (med.Frequency is MedicationFrequency.Daily
+            or MedicationFrequency.TwiceDaily
+            or MedicationFrequency.ThreeTimesDaily
+            or MedicationFrequency.AsNeeded)
+            return true;
+
+        var startDate = med.StartDate ?? today;
+        if (med.Frequency == MedicationFrequency.EveryOtherDay)
+            return (today.DayNumber - startDate.DayNumber) % 2 == 0;
+
+        if (med.Frequency == MedicationFrequency.Weekly)
+            return today.DayOfWeek == startDate.DayOfWeek;
+
+        return true;
+    }
+}

backend/src/Health.Application/Notifications/InAppNotificationContracts.cs

@@ -0,0 +1,67 @@
+namespace Health.Application.Notifications;
+
+public sealed record InAppNotificationDto(
+    Guid Id,
+    string Type,
+    string Title,
+    string Message,
+    string Severity,
+    string? ActionType,
+    string? ActionTargetId,
+    bool IsRead,
+    DateTime CreatedAt);
+
+public sealed record NotificationMessage(
+    string Type,
+    string Title,
+    string Message,
+    string Severity,
+    string? ActionType,
+    string? ActionTargetId);
+
+public interface IInAppNotificationService
+{
+    Task<IReadOnlyList<InAppNotificationDto>> GetPendingAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<InAppNotificationDto>> GetHistoryAsync(Guid userId, CancellationToken ct);
+    Task<bool> AcknowledgeAsync(Guid userId, Guid notificationId, CancellationToken ct);
+    Task<int> MarkAllReadAsync(Guid userId, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid notificationId, CancellationToken ct);
+}
+
+public interface IInAppNotificationRepository
+{
+    Task<IReadOnlyList<InAppNotificationRecord>> GetPendingAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<InAppNotificationRecord>> GetHistoryAsync(Guid userId, CancellationToken ct);
+    Task<bool> AcknowledgeAsync(Guid userId, Guid notificationId, CancellationToken ct);
+    Task<int> MarkAllReadAsync(Guid userId, CancellationToken ct);
+    Task<bool> DeleteAsync(Guid userId, Guid notificationId, CancellationToken ct);
+}
+
+public sealed record InAppNotificationRecord(
+    Guid Id,
+    string Type,
+    string Title,
+    string Message,
+    string Severity,
+    string? ActionType,
+    string? ActionTargetId,
+    bool IsRead,
+    DateTime CreatedAt);
+
+public interface IUserNotificationProducer
+{
+    Task<bool> EnqueueAsync(Guid userId, Guid sourceId, NotificationMessage message, CancellationToken ct);
+}
+
+public interface INotificationOutboxProcessor
+{
+    Task RecoverStaleAsync(CancellationToken ct);
+    Task<bool> ProcessNextAsync(CancellationToken ct);
+}
+
+public sealed record ReminderCatchUpResult(int CreatedCount);
+
+public interface IReminderCatchUpService
+{
+    Task<ReminderCatchUpResult> CheckDueAsync(Guid userId, DateTime utcNow, CancellationToken ct);
+}

backend/src/Health.Application/Notifications/InAppNotificationService.cs

@@ -0,0 +1,31 @@
+namespace Health.Application.Notifications;
+
+public sealed class InAppNotificationService(IInAppNotificationRepository notifications) : IInAppNotificationService
+{
+    private readonly IInAppNotificationRepository _notifications = notifications;
+
+    public async Task<IReadOnlyList<InAppNotificationDto>> GetPendingAsync(Guid userId, CancellationToken ct)
+    {
+        var records = await _notifications.GetPendingAsync(userId, ct);
+        return records.Select(ToDto).ToList();
+    }
+
+    public async Task<IReadOnlyList<InAppNotificationDto>> GetHistoryAsync(Guid userId, CancellationToken ct)
+    {
+        var records = await _notifications.GetHistoryAsync(userId, ct);
+        return records.Select(ToDto).ToList();
+    }
+
+    public Task<bool> AcknowledgeAsync(Guid userId, Guid notificationId, CancellationToken ct) =>
+        _notifications.AcknowledgeAsync(userId, notificationId, ct);
+
+    public Task<int> MarkAllReadAsync(Guid userId, CancellationToken ct) =>
+        _notifications.MarkAllReadAsync(userId, ct);
+
+    public Task<bool> DeleteAsync(Guid userId, Guid notificationId, CancellationToken ct) =>
+        _notifications.DeleteAsync(userId, notificationId, ct);
+
+    private static InAppNotificationDto ToDto(InAppNotificationRecord record) => new(
+        record.Id, record.Type, record.Title, record.Message, record.Severity,
+        record.ActionType, record.ActionTargetId, record.IsRead, record.CreatedAt);
+}

backend/src/Health.Application/Reports/ReportContracts.cs

@@ -0,0 +1,83 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Reports;
+
+public sealed record ReportUploadFile(
+    string FileName,
+    long Length,
+    Stream Content);
+
+public sealed record ReportDto(
+    Guid Id,
+    Guid UserId,
+    string FileUrl,
+    string FileType,
+    string Category,
+    string Status,
+    string AiStatus,
+    string ReviewStatus,
+    string? Severity,
+    string? AiSummary,
+    string? AiIndicators,
+    string? DoctorComment,
+    string? DoctorRecommendation,
+    string? DoctorName,
+    DateTime? ReviewedAt,
+    DateTime CreatedAt);
+
+public sealed record ReportUploadResult(
+    bool Success,
+    int Code,
+    string? Message,
+    ReportDto? Report);
+
+public sealed record ReportAnalysisJob(
+    Guid TaskId,
+    Guid ReportId,
+    string FilePath);
+
+public sealed record StoredReportFile(
+    string FileUrl,
+    string FilePath);
+
+public interface IReportService
+{
+    Task<IReadOnlyList<ReportDto>> GetReportsAsync(Guid userId, CancellationToken ct);
+    Task<ReportDto?> GetReportAsync(Guid userId, Guid reportId, CancellationToken ct);
+    Task<ReportUploadResult> UploadReportAsync(Guid userId, ReportUploadFile file, CancellationToken ct);
+    Task<bool> DeleteReportAsync(Guid userId, Guid reportId, CancellationToken ct);
+    Task<bool> ReanalyzeReportAsync(Guid userId, Guid reportId, CancellationToken ct);
+}
+
+public interface IReportAnalysisQueue
+{
+    Task EnqueueAsync(ReportAnalysisJob job, CancellationToken ct = default);
+    Task RecoverStaleAsync(CancellationToken ct);
+    Task<ReportAnalysisJob?> TryTakeAsync(CancellationToken ct);
+    Task CompleteAsync(Guid taskId, CancellationToken ct);
+    Task RetryAsync(Guid taskId, string error, CancellationToken ct);
+}
+
+public interface IReportAnalysisService
+{
+    Task AnalyzeAsync(ReportAnalysisJob job, CancellationToken ct);
+}
+
+public interface IReportRepository
+{
+    Task<IReadOnlyList<Report>> ListAsync(Guid userId, CancellationToken ct);
+    Task<Report?> GetOwnedAsync(Guid userId, Guid reportId, CancellationToken ct);
+    Task<Report?> GetByIdAsync(Guid reportId, CancellationToken ct);
+    Task AddAsync(Report report, CancellationToken ct);
+    void Delete(Report report);
+    Task SaveChangesAsync(CancellationToken ct);
+}
+
+public interface IReportFileStorage
+{
+    Task<StoredReportFile> SaveAsync(ReportUploadFile file, string extension, CancellationToken ct);
+    string GetLocalFilePath(string fileUrl);
+    bool Exists(string filePath);
+    void Delete(string filePath);
+}

backend/src/Health.Application/Reports/ReportService.cs

@@ -0,0 +1,122 @@
+using Health.Domain.Entities;
+using Health.Domain.Enums;
+
+namespace Health.Application.Reports;
+
+public sealed class ReportService(
+    IReportRepository reports,
+    IReportFileStorage fileStorage,
+    IReportAnalysisQueue queue) : IReportService
+{
+    private const long MaxReportFileBytes = 20 * 1024 * 1024;
+    private static readonly HashSet<string> AllowedExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ".jpg", ".jpeg", ".png", ".webp", ".pdf"
+    };
+
+    private readonly IReportRepository _reports = reports;
+    private readonly IReportFileStorage _fileStorage = fileStorage;
+    private readonly IReportAnalysisQueue _queue = queue;
+
+    public async Task<IReadOnlyList<ReportDto>> GetReportsAsync(Guid userId, CancellationToken ct)
+    {
+        var result = await _reports.ListAsync(userId, ct);
+        return result.Select(ToDto).ToList();
+    }
+
+    public async Task<ReportDto?> GetReportAsync(Guid userId, Guid reportId, CancellationToken ct)
+    {
+        var report = await _reports.GetOwnedAsync(userId, reportId, ct);
+        return report == null ? null : ToDto(report);
+    }
+
+    public async Task<ReportUploadResult> UploadReportAsync(Guid userId, ReportUploadFile file, CancellationToken ct)
+    {
+        if (file.Length <= 0)
+            return Fail(400, "未上传文件");
+
+        if (file.Length > MaxReportFileBytes)
+            return Fail(400, "报告文件不能超过 20MB，请压缩后重新上传");
+
+        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
+        if (!AllowedExtensions.Contains(ext))
+            return Fail(400, "目前支持上传 JPG、PNG、WEBP 图片或 PDF 报告");
+
+        var storedFile = await _fileStorage.SaveAsync(file, ext, ct);
+        var report = new Report
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            FileUrl = storedFile.FileUrl,
+            FileType = ext == ".pdf" ? ReportFileType.Pdf : ReportFileType.Image,
+            Category = ReportCategory.Other,
+            Status = ReportStatus.Analyzing,
+            AiSummary = null,
+            AiIndicators = null,
+            CreatedAt = DateTime.UtcNow,
+        };
+
+        await _reports.AddAsync(report, ct);
+        await _queue.EnqueueAsync(new ReportAnalysisJob(Guid.NewGuid(), report.Id, storedFile.FilePath), ct);
+
+        return new ReportUploadResult(true, 0, "报告已上传，AI 正在分析中", ToDto(report));
+    }
+
+    public async Task<bool> DeleteReportAsync(Guid userId, Guid reportId, CancellationToken ct)
+    {
+        var report = await _reports.GetOwnedAsync(userId, reportId, ct);
+        if (report == null) return false;
+
+        var filePath = _fileStorage.GetLocalFilePath(report.FileUrl);
+        if (_fileStorage.Exists(filePath))
+            _fileStorage.Delete(filePath);
+
+        _reports.Delete(report);
+        await _reports.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task<bool> ReanalyzeReportAsync(Guid userId, Guid reportId, CancellationToken ct)
+    {
+        var report = await _reports.GetOwnedAsync(userId, reportId, ct);
+        if (report == null) return false;
+
+        var filePath = _fileStorage.GetLocalFilePath(report.FileUrl);
+        if (!_fileStorage.Exists(filePath)) return false;
+
+        report.Status = ReportStatus.Analyzing;
+        report.AiSummary = null;
+        report.AiIndicators = null;
+        await _queue.EnqueueAsync(new ReportAnalysisJob(Guid.NewGuid(), report.Id, filePath), ct);
+        return true;
+    }
+
+    public static ReportDto ToDto(Report report) => new(
+        report.Id,
+        report.UserId,
+        $"/api/reports/{report.Id}/file",
+        report.FileType.ToString(),
+        report.Category.ToString(),
+        report.Status.ToString(),
+        ToAiStatus(report),
+        report.Status == ReportStatus.DoctorReviewed ? "Reviewed" : "Pending",
+        report.Severity,
+        report.AiSummary,
+        report.AiIndicators,
+        report.DoctorComment,
+        report.DoctorRecommendation,
+        report.DoctorName,
+        report.ReviewedAt,
+        report.CreatedAt);
+
+    private static string ToAiStatus(Report report) => report.Status switch
+    {
+        ReportStatus.Analyzing => "Analyzing",
+        ReportStatus.AnalysisFailed => "Failed",
+        _ when string.IsNullOrWhiteSpace(report.AiSummary) => "Analyzing",
+        _ => "Succeeded"
+    };
+
+    private static ReportUploadResult Fail(int code, string message) =>
+        new(false, code, message, null);
+}

backend/src/Health.Application/Speech/realtime_speech_contracts.cs

@@ -0,0 +1,10 @@
+using System.Net.WebSockets;
+
+namespace Health.Application.Speech;
+
+public interface IRealtimeSpeechRecognitionProxy
+{
+    bool IsConfigured { get; }
+
+    Task ProxyAsync(WebSocket clientSocket, CancellationToken cancellationToken);
+}

backend/src/Health.Application/Users/UserContracts.cs

@@ -0,0 +1,42 @@
+using Health.Domain.Entities;
+
+namespace Health.Application.Users;
+
+public sealed record UserProfileDto(
+    Guid Id,
+    string? Phone,  // Apple 用户无手机号
+    string Role,
+    string? Name,
+    string? Gender,
+    string? BirthDate,
+    string? AvatarUrl);
+
+public sealed record UserProfileUpdateRequest(
+    string? Name,
+    string? Gender,
+    DateOnly? BirthDate,
+    string? AvatarUrl);
+
+public sealed record AccountFileReferences(
+    IReadOnlyList<string> FileUrls,
+    IReadOnlyList<string> ConversationMetadataJson);
+
+public interface IUserService
+{
+    Task<UserProfileDto?> GetProfileAsync(Guid userId, CancellationToken ct);
+    Task<bool> UpdateProfileAsync(Guid userId, UserProfileUpdateRequest request, CancellationToken ct);
+    Task DeleteAccountAsync(Guid userId, CancellationToken ct);
+}
+
+public interface IUserRepository
+{
+    Task<User?> GetAsync(Guid userId, CancellationToken ct);
+    Task<AccountFileReferences> GetAccountFileReferencesAsync(Guid userId, CancellationToken ct);
+    Task SaveChangesAsync(CancellationToken ct);
+    Task DeleteAccountDataAsync(Guid userId, CancellationToken ct);
+}
+
+public interface IAccountFileCleanup
+{
+    Task DeleteAsync(Guid userId, AccountFileReferences references, CancellationToken ct);
+}

backend/src/Health.Application/Users/UserService.cs

@@ -0,0 +1,43 @@
+namespace Health.Application.Users;
+
+public sealed class UserService(
+    IUserRepository users,
+    IAccountFileCleanup fileCleanup) : IUserService
+{
+    private readonly IUserRepository _users = users;
+    private readonly IAccountFileCleanup _fileCleanup = fileCleanup;
+
+    public async Task<UserProfileDto?> GetProfileAsync(Guid userId, CancellationToken ct)
+    {
+        var user = await _users.GetAsync(userId, ct);
+        return user == null ? null : new UserProfileDto(
+            user.Id,
+            user.Phone,
+            user.Role,
+            user.Name,
+            user.Gender,
+            user.BirthDate?.ToString("yyyy-MM-dd"),
+            user.AvatarUrl);
+    }
+
+    public async Task<bool> UpdateProfileAsync(Guid userId, UserProfileUpdateRequest request, CancellationToken ct)
+    {
+        var user = await _users.GetAsync(userId, ct);
+        if (user == null) return false;
+
+        if (request.Name != null) user.Name = request.Name;
+        if (request.Gender != null) user.Gender = request.Gender;
+        if (request.BirthDate.HasValue) user.BirthDate = request.BirthDate.Value;
+        if (request.AvatarUrl != null) user.AvatarUrl = request.AvatarUrl;
+        user.UpdatedAt = DateTime.UtcNow;
+        await _users.SaveChangesAsync(ct);
+        return true;
+    }
+
+    public async Task DeleteAccountAsync(Guid userId, CancellationToken ct)
+    {
+        var references = await _users.GetAccountFileReferencesAsync(userId, ct);
+        await _fileCleanup.DeleteAsync(userId, references, ct);
+        await _users.DeleteAccountDataAsync(userId, ct);
+    }
+}

backend/src/Health.Domain/Entities/consultation.cs

@@ -44,6 +44,8 @@ public sealed class Doctor
     public string Name { get; set; } = string.Empty;
     public string? Title { get; set; }           // 主任医师/副主任医师
     public string? Department { get; set; }      // 心血管内科/营养科
+    public string? Phone { get; set; }           // 医生手机号
+    public string? ProfessionalDirection { get; set; }  // 专业方向
     public string? AvatarUrl { get; set; }
     public string? Introduction { get; set; }
     public bool IsActive { get; set; } = true;

backend/src/Health.Domain/Entities/doctor_profile.cs

@@ -0,0 +1,23 @@
+namespace Health.Domain.Entities;
+
+/// <summary>
+/// 医生扩展信息
+/// </summary>
+public sealed class DoctorProfile
+{
+    public Guid Id { get; set; }
+    public Guid UserId { get; set; }
+    public Guid? DoctorId { get; set; }  // FK → Doctor 实体
+    public string? Name { get; set; }
+    public Doctor? Doctor { get; set; }  // 导航属性
+    public string? Title { get; set; }
+    public string? Department { get; set; }
+    public string? Hospital { get; set; }
+    public string? AvatarUrl { get; set; }
+    public bool IsOnline { get; set; }
+    public bool IsActive { get; set; } = true;
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+
+    public User User { get; set; } = null!;
+}

backend/src/Health.Domain/Entities/exercise_plan.cs

@@ -7,7 +7,9 @@ public sealed class ExercisePlan
 {
     public Guid Id { get; set; }
     public Guid UserId { get; set; }
-    public DateOnly WeekStartDate { get; set; } // 本周一
+    public DateOnly StartDate { get; set; }
+    public DateOnly EndDate { get; set; }
+    public TimeOnly ReminderTime { get; set; } = new(19, 0);
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
 
@@ -22,7 +24,7 @@ public sealed class ExercisePlanItem
 {
     public Guid Id { get; set; }
     public Guid PlanId { get; set; }
-    public int DayOfWeek { get; set; }    // 0=周一, 6=周日
+    public DateOnly ScheduledDate { get; set; }
     public string ExerciseType { get; set; } = string.Empty; // 散步/慢跑/游泳
     public int DurationMinutes { get; set; }
     public bool IsCompleted { get; set; }

backend/src/Health.Domain/Entities/medication.cs

@@ -17,6 +17,7 @@ public sealed class Medication
     public DateOnly? EndDate { get; set; }
     public bool IsActive { get; set; } = true;
     public MedicationSource Source { get; set; }
+    public string? Notes { get; set; }
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
 

backend/src/Health.Domain/Entities/report.cs

@@ -17,7 +17,9 @@ public sealed class Report
     [Column(TypeName = "jsonb")]
     public string? AiIndicators { get; set; }      // JSONB: [{name, value, unit, range, status}]
     public ReportStatus Status { get; set; }
-    public string? DoctorComment { get; set; }     // 医生审核意见
+    public string? Severity { get; set; }           // 严重程度：Normal/Abnormal/Severe/Critical
+    public string? DoctorComment { get; set; }       // 医生审核意见
+    public string? DoctorRecommendation { get; set; } // 医生建议（用药/复查/生活方式）
     public string? DoctorName { get; set; }
     public DateTime? ReviewedAt { get; set; }
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

backend/src/Health.Domain/Entities/support_entities.cs

@@ -35,9 +35,22 @@ public sealed class HealthArchive
     public List<string> DietRestrictions { get; set; } = [];    // 饮食限制
     public List<string> ChronicDiseases { get; set; } = [];     // 慢病史
     public string? FamilyHistory { get; set; }       // 家族病史
+    public string? SurgeryHistoryStatus { get; set; } // 无/有，区分未填写与无手术史
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
 
     public User User { get; set; } = null!;
+    public ICollection<HealthArchiveSurgery> Surgeries { get; set; } = [];
+}
+
+public sealed class HealthArchiveSurgery
+{
+    public Guid Id { get; set; }
+    public Guid HealthArchiveId { get; set; }
+    public string Type { get; set; } = string.Empty;
+    public DateOnly? Date { get; set; }
+    public int SortOrder { get; set; }
+
+    public HealthArchive HealthArchive { get; set; } = null!;
 }
 
 /// <summary>
@@ -77,6 +90,17 @@ public sealed class NotificationPreference
     public bool FollowUpReminder { get; set; } = true;
     public bool DoctorReply { get; set; } = true;
     public bool AbnormalAlert { get; set; } = true;
+    public bool PushEnabled { get; set; } = true;
+    public bool DndEnabled { get; set; }
+    public int DndStartMinutes { get; set; } = 22 * 60;
+    public int DndEndMinutes { get; set; } = 8 * 60;
+    // 健康录入提醒——总开关 + 5 子项
+    public bool HealthRecordReminder { get; set; } = true;
+    public bool HealthRecordReminderBloodPressure { get; set; } = true;
+    public bool HealthRecordReminderHeartRate { get; set; } = true;
+    public bool HealthRecordReminderGlucose { get; set; } = true;
+    public bool HealthRecordReminderSpO2 { get; set; } = true;
+    public bool HealthRecordReminderWeight { get; set; } = true;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
 
     public User User { get; set; } = null!;
@@ -97,3 +121,20 @@ public sealed class DeviceToken
 
     public User User { get; set; } = null!;
 }
+
+public sealed class UserNotification
+{
+    public Guid Id { get; set; }
+    public Guid UserId { get; set; }
+    public Guid SourceId { get; set; }
+    public string Type { get; set; } = string.Empty;
+    public string Title { get; set; } = string.Empty;
+    public string Message { get; set; } = string.Empty;
+    public string Severity { get; set; } = "info";
+    public string? ActionType { get; set; }
+    public string? ActionTargetId { get; set; }
+    public bool IsRead { get; set; }
+    public DateTime? ReadAt { get; set; }
+    public bool IsDeleted { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

backend/src/Health.Domain/Entities/user.cs

@@ -1,13 +1,17 @@
 namespace Health.Domain.Entities;
 
 /// <summary>
-/// 用户（患者）
+/// 用户（支持用户/医生双角色）
 /// </summary>
 public sealed class User
 {
     public Guid Id { get; set; }
-    public string Phone { get; set; } = string.Empty;
+    public string? Phone { get; set; }  // Apple 用户无手机号
+    public string? AppleUserId { get; set; }  // Apple Sign-In 唯一标识
+    public string Role { get; set; } = "User"; // "User" | "Doctor" | "Admin"
+    public Guid? DoctorId { get; set; }  // 患者选择的医生
     public string? Name { get; set; }
+    public Doctor? Doctor { get; set; }  // 导航属性
     public string? Gender { get; set; }
     public DateOnly? BirthDate { get; set; }
     public string? AvatarUrl { get; set; }
@@ -26,4 +30,5 @@ public sealed class User
     public ICollection<DeviceToken> DeviceTokens { get; set; } = [];
     public HealthArchive? HealthArchive { get; set; }
     public NotificationPreference? NotificationPreference { get; set; }
+    public DoctorProfile? DoctorProfile { get; set; }
 }

backend/src/Health.Domain/Enums/health_enums.cs

@@ -58,11 +58,12 @@ public enum MedicationLogStatus
 /// </summary>
 public enum MedicationFrequency
 {
-    Daily,       // 每天一次
-    TwiceDaily,  // 每天两次
+    Daily,           // 每天一次
+    TwiceDaily,      // 每天两次
     ThreeTimesDaily, // 每天三次
-    Weekly,      // 每周
-    AsNeeded     // 必要时
+    EveryOtherDay,   // 隔天一次
+    Weekly,          // 每周
+    AsNeeded         // 必要时
 }
 
 /// <summary>
@@ -70,6 +71,8 @@ public enum MedicationFrequency
 /// </summary>
 public enum ReportStatus
 {
+    Analyzing,      // AI 分析中
+    AnalysisFailed, // AI 分析失败
     PendingDoctor,  // 待医生确认
     DoctorReviewed  // 医生已确认
 }
@@ -133,12 +136,13 @@ public enum FollowUpStatus
 public enum AgentType
 {
     Default,      // 默认对话
-    Consultation, // AI 问诊
+    Consultation, // AI 对话
     Health,       // 记数据
     Diet,         // 拍饮食
-    Medication,   // 药管家
+    Medication,   // 药提醒
     Report,       // 看报告
-    Exercise      // 运动计划
+    Exercise,     // 运动计划
+    Unified       // 统一入口（自动路由）
 }
 
 /// <summary>

backend/src/Health.Domain/ValidationException.cs

@@ -0,0 +1,7 @@
+namespace Health.Domain;
+
+/// <summary>
+/// 业务输入校验失败异常——由 Application 层规则抛出，
+/// 中间件统一映射为 400 / code 40001，message 可安全展示给用户。
+/// </summary>
+public sealed class ValidationException(string message) : Exception(message);

backend/src/Health.Infrastructure/AI/AgentHandlers/ai_date_time.cs

@@ -0,0 +1,49 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+internal static partial class AiDateTime
+{
+    public static DateTime BeijingNow => DateTime.UtcNow.AddHours(8);
+    public static DateOnly BeijingToday => DateOnly.FromDateTime(BeijingNow);
+
+    public static (DateTime StartUtc, DateTime EndUtc) BeijingDateWindowUtc(DateOnly date)
+    {
+        var startUtc = DateTime.SpecifyKind(date.ToDateTime(TimeOnly.MinValue).AddHours(-8), DateTimeKind.Utc);
+        return (startUtc, startUtc.AddDays(1));
+    }
+
+    public static DateTime ToUtc(DateTime value) => value.Kind switch
+    {
+        DateTimeKind.Utc => value,
+        DateTimeKind.Local => value.ToUniversalTime(),
+        _ => DateTime.SpecifyKind(value, DateTimeKind.Utc),
+    };
+
+    public static string ToBeijingText(DateTime value) =>
+        ToUtc(value).AddHours(8).ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+
+    public static bool TryParseUserDateTime(string? value, out DateTime utc)
+    {
+        utc = default;
+        if (string.IsNullOrWhiteSpace(value)) return false;
+
+        if ((value.EndsWith("Z", StringComparison.OrdinalIgnoreCase) || OffsetSuffix().IsMatch(value)) &&
+            DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var offsetValue))
+        {
+            utc = offsetValue.UtcDateTime;
+            return true;
+        }
+
+        if (!DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var beijingValue))
+            return false;
+
+        utc = DateTime.SpecifyKind(beijingValue, DateTimeKind.Unspecified).AddHours(-8);
+        utc = DateTime.SpecifyKind(utc, DateTimeKind.Utc);
+        return true;
+    }
+
+    [GeneratedRegex(@"[+-]\d{2}:?\d{2}$")]
+    private static partial Regex OffsetSuffix();
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/common_agent_handler.cs

@@ -0,0 +1,184 @@
+using Health.Application.HealthArchives;
+using Health.Application.HealthRecords;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 共享工具处理器——被多个 Agent 引用的通用工具
+/// </summary>
+public static class CommonAgentHandler
+{
+    public static readonly ToolDefinition SearchMedicalKnowledgeTool = new()
+    {
+        Function = new()
+        {
+            Name = "search_medical_knowledge",
+            Description = "按需检索医学知识库。仅用于症状分析、健康建议、疾病/药品/检查指标解释等需要医学资料支撑的回答；健康数据录入、用药或运动计划创建/查询/打卡、普通寒暄不得调用。",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    query = new
+                    {
+                        type = "string",
+                        description = "需要检索的医学问题，保留关键症状、疾病、药品或指标名称",
+                    },
+                },
+                required = new[] { "query" },
+            },
+        },
+    };
+
+    public static readonly ToolDefinition QueryHealthRecordsTool = new()
+    {
+        Function = new()
+        {
+            Name = "query_health_records",
+            Description = "查询近期健康数据",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    type = new { type = "string", @enum = new[] { "blood_pressure", "heart_rate", "glucose", "spo2", "weight", "all" }, description = "健康指标类型" },
+                    scope = new { type = "string", @enum = new[] { "today", "yesterday", "date", "recent_days", "range" }, description = "日期范围，默认 recent_days" },
+                    date = new { type = "string", description = "scope=date 时的北京时间日期 yyyy-MM-dd" },
+                    start_date = new { type = "string", description = "scope=range 时的北京时间开始日期 yyyy-MM-dd" },
+                    end_date = new { type = "string", description = "scope=range 时的北京时间结束日期 yyyy-MM-dd（包含）" },
+                    days = new { type = "integer", description = "scope=recent_days 时的天数，1到365" },
+                }
+            }
+        }
+    };
+
+    public static readonly ToolDefinition CheckArchiveTool = new()
+    {
+        Function = new() { Name = "check_archive", Description = "查询患者健康档案", Parameters = new { type = "object", properties = new { } } }
+    };
+
+    public static List<ToolDefinition> Tools => [QueryHealthRecordsTool, CheckArchiveTool];
+
+    public static async Task<object> Execute(
+        string toolName,
+        JsonElement args,
+        Guid userId,
+        IHealthRecordService healthRecords,
+        IHealthArchiveService archives,
+        CancellationToken ct = default)
+    {
+        return toolName switch
+        {
+            "query_health_records" => await ExecuteQueryHealthRecords(healthRecords, userId, args, ct),
+            "check_archive" => await ExecuteCheckArchive(archives, userId, ct),
+            _ => new { success = false, message = $"未知工具: {toolName}" }
+        };
+    }
+
+    private static async Task<object> ExecuteQueryHealthRecords(IHealthRecordService healthRecords, Guid userId, JsonElement args, CancellationToken ct)
+    {
+        var rawType = args.TryGetProperty("type", out var t) ? t.GetString() : null;
+        if (!TryNormalizeMetricType(rawType, out var metricType))
+            return new { success = false, message = $"无法识别健康指标类型: {rawType}" };
+
+        var scope = args.TryGetProperty("scope", out var scopeValue)
+            ? scopeValue.GetString()?.ToLowerInvariant()
+            : "recent_days";
+        DateTime? startUtc = null;
+        DateTime? endUtc = null;
+        int days;
+
+        switch (scope)
+        {
+            case "today":
+                (startUtc, endUtc) = AiDateTime.BeijingDateWindowUtc(AiDateTime.BeijingToday);
+                days = 2;
+                break;
+            case "yesterday":
+                (startUtc, endUtc) = AiDateTime.BeijingDateWindowUtc(AiDateTime.BeijingToday.AddDays(-1));
+                days = 3;
+                break;
+            case "date":
+                if (!TryReadDate(args, "date", out var date))
+                    return new { success = false, message = "查询指定日期时必须提供有效的 date" };
+                (startUtc, endUtc) = AiDateTime.BeijingDateWindowUtc(date);
+                days = DaysSince(startUtc.Value);
+                break;
+            case "range":
+                if (!TryReadDate(args, "start_date", out var startDate) ||
+                    !TryReadDate(args, "end_date", out var endDate) || endDate < startDate)
+                    return new { success = false, message = "必须提供有效的 start_date 和 end_date，且结束日期不能早于开始日期" };
+                startUtc = AiDateTime.BeijingDateWindowUtc(startDate).StartUtc;
+                endUtc = AiDateTime.BeijingDateWindowUtc(endDate).EndUtc;
+                days = DaysSince(startUtc.Value);
+                break;
+            default:
+                days = args.TryGetProperty("days", out var d) && d.TryGetInt32(out var parsedDays)
+                    ? Math.Clamp(parsedDays, 1, 365)
+                    : 7;
+                scope = "recent_days";
+                break;
+        }
+
+        var records = await healthRecords.GetRecordsAsync(userId, metricType, days, ct);
+        var filtered = records
+            .Where(record => !startUtc.HasValue || AiDateTime.ToUtc(record.RecordedAt) >= startUtc.Value)
+            .Where(record => !endUtc.HasValue || AiDateTime.ToUtc(record.RecordedAt) < endUtc.Value)
+            .Select(record => new
+            {
+                record.Id,
+                record.Type,
+                record.Systolic,
+                record.Diastolic,
+                record.Value,
+                record.Unit,
+                record.Source,
+                record.IsAbnormal,
+                recorded_at_beijing = AiDateTime.ToBeijingText(record.RecordedAt),
+            })
+            .ToList();
+        return new { success = true, scope, count = filtered.Count, records = filtered };
+    }
+
+    private static async Task<object> ExecuteCheckArchive(IHealthArchiveService archives, Guid userId, CancellationToken ct)
+    {
+        var archive = await archives.GetAsync(userId, ct);
+        if (archive == null) return new { found = false };
+        return new
+        {
+            found = true,
+            archive.Diagnosis,
+            archive.SurgeryType,
+            SurgeryDate = archive.SurgeryDate?.ToString("yyyy-MM-dd"),
+            archive.Surgeries,
+            archive.Allergies,
+            archive.DietRestrictions,
+            archive.ChronicDiseases,
+            archive.FamilyHistory,
+        };
+    }
+
+    private static bool TryNormalizeMetricType(string? value, out string? normalized)
+    {
+        normalized = value?.Trim().ToLowerInvariant() switch
+        {
+            null or "" or "all" or "全部" => null,
+            "bloodpressure" or "blood_pressure" or "血压" => "BloodPressure",
+            "heartrate" or "heart_rate" or "心率" or "脉搏" => "HeartRate",
+            "glucose" or "blood_glucose" or "血糖" => "Glucose",
+            "spo2" or "blood_oxygen" or "血氧" or "血氧饱和度" => "SpO2",
+            "weight" or "体重" => "Weight",
+            _ => "__invalid__",
+        };
+        return normalized != "__invalid__";
+    }
+
+    private static bool TryReadDate(JsonElement args, string name, out DateOnly date)
+    {
+        date = default;
+        return args.TryGetProperty(name, out var value) && DateOnly.TryParse(value.GetString(), out date);
+    }
+
+    private static int DaysSince(DateTime startUtc) =>
+        Math.Clamp((int)Math.Ceiling((DateTime.UtcNow - startUtc).TotalDays) + 1, 1, 3650);
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/consultation_agent_handler.cs

@@ -0,0 +1,10 @@
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 问诊 Agent 工具处理器（问诊转医生走专门界面，此处只保留档案和记录查询）
+/// </summary>
+public static class ConsultationAgentHandler
+{
+    public static List<ToolDefinition> Tools => [CommonAgentHandler.QueryHealthRecordsTool, CommonAgentHandler.CheckArchiveTool];
+
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/diet_agent_handler.cs

@@ -0,0 +1,10 @@
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 饮食 Agent 工具处理器（饮食拍照走专门界面，此处只保留档案查询）
+/// </summary>
+public static class DietAgentHandler
+{
+    public static List<ToolDefinition> Tools => [CommonAgentHandler.CheckArchiveTool];
+
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/exercise_agent_handler.cs

@@ -0,0 +1,209 @@
+using Health.Application.Exercises;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+public static class ExerciseAgentHandler
+{
+    public static readonly ToolDefinition ManageExerciseTool = new()
+    {
+        Function = new()
+        {
+            Name = "manage_exercise",
+            Description = "运动计划管理（创建/查询/打卡）",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    action = new { type = "string", @enum = new[] { "create", "query", "checkin" }, description = "create/query/checkin" },
+                    scope = new { type = "string", @enum = new[] { "today", "scheduled_date", "current_plans", "upcoming_plans", "ended_plans", "all_plans" }, description = "查询时必填：今日任务/指定日期任务/当前计划/即将开始/已结束/全部计划" },
+                    date = new { type = "string", description = "仅 scope=scheduled_date 时必填，使用北京时间日期 yyyy-MM-dd" },
+                    start_date = new { type = "string", description = "开始日期 yyyy-MM-dd，默认今天" },
+                    duration_days = new { type = "integer", description = "连续运动天数，如一周为7天" },
+                    exercise_type = new { type = "string", description = "运动类型，如散步、慢跑、游泳" },
+                    duration_minutes = new { type = "integer", description = "每天运动时长，单位分钟" },
+                    reminder_time = new { type = "string", description = "每天提醒时间 HH:mm，默认19:00" },
+                    item_id = new { type = "string", description = "打卡条目 ID" },
+                },
+                required = new[] { "action" },
+            },
+        },
+    };
+
+    public static List<ToolDefinition> Tools => [ManageExerciseTool];
+
+    public static string? ValidateWriteArguments(JsonElement args)
+    {
+        var action = args.TryGetProperty("action", out var actionValue)
+            ? actionValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (action != "create") return null;
+
+        if (!args.TryGetProperty("exercise_type", out var typeValue) ||
+            string.IsNullOrWhiteSpace(typeValue.GetString()))
+            return "创建运动计划前需要确认运动项目";
+        if (!args.TryGetProperty("duration_minutes", out var minutesValue) ||
+            !minutesValue.TryGetInt32(out var minutes) || minutes is <= 0 or > 300)
+            return "创建运动计划前需要确认合理的单次运动时长";
+        if (!args.TryGetProperty("duration_days", out var daysValue) ||
+            !daysValue.TryGetInt32(out var days) || days is <= 0 or > 366)
+            return "创建运动计划前需要确认计划持续天数";
+        if (!args.TryGetProperty("start_date", out var startValue) ||
+            !DateOnly.TryParse(startValue.GetString(), out _))
+            return "创建运动计划前需要确认开始日期";
+        if (!args.TryGetProperty("reminder_time", out var reminderValue) ||
+            !TimeOnly.TryParse(reminderValue.GetString(), out _))
+            return "创建运动计划前需要确认具体提醒时间";
+        return null;
+    }
+
+    public static async Task<object> Execute(
+        string toolName,
+        JsonElement args,
+        Guid userId,
+        IExerciseService exercises,
+        CancellationToken ct = default)
+    {
+        if (toolName != "manage_exercise")
+            return new { success = false, message = $"未知工具: {toolName}" };
+
+        var action = args.TryGetProperty("action", out var actionValue)
+            ? actionValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (action == "create")
+        {
+            var validationError = ValidateWriteArguments(args);
+            if (validationError != null)
+                return new { success = false, message = validationError };
+
+            var startDate = args.TryGetProperty("start_date", out var startValue) && DateOnly.TryParse(startValue.GetString(), out var parsedStart)
+                ? parsedStart
+                : DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+            var days = args.TryGetProperty("duration_days", out var daysValue) && daysValue.TryGetInt32(out var parsedDays)
+                ? Math.Clamp(parsedDays, 1, 366)
+                : 7;
+            var exerciseType = args.TryGetProperty("exercise_type", out var typeValue) ? typeValue.GetString() : "散步";
+            var minutes = args.TryGetProperty("duration_minutes", out var minutesValue) && minutesValue.TryGetInt32(out var parsedMinutes) ? parsedMinutes : 30;
+            var reminder = args.TryGetProperty("reminder_time", out var reminderValue) && TimeOnly.TryParse(reminderValue.GetString(), out var parsedReminder)
+                ? parsedReminder
+                : new TimeOnly(19, 0);
+            var planId = await exercises.CreateAsync(userId, new ExercisePlanCreateRequest(
+                startDate, startDate.AddDays(days - 1), exerciseType, minutes, reminder), ct);
+            return new { success = true, plan_id = planId, exercise_type = exerciseType, duration_minutes = minutes, day_count = days, start_date = startDate, end_date = startDate.AddDays(days - 1), reminder_time = reminder };
+        }
+
+        if (action == "checkin")
+        {
+            var itemId = args.TryGetProperty("item_id", out var itemValue) && itemValue.TryGetGuid(out var parsedId) ? parsedId : Guid.Empty;
+            var success = await exercises.CheckInAsync(userId, itemId, ct);
+            return success ? new { success = true } : new { success = false, message = "条目不存在" };
+        }
+
+        if (action != "query")
+            return new { success = false, message = $"未知操作: {action}" };
+
+        var scope = args.TryGetProperty("scope", out var scopeValue)
+            ? scopeValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (scope is not ("today" or "scheduled_date" or "current_plans" or "upcoming_plans" or "ended_plans" or "all_plans"))
+            return new
+            {
+                success = false,
+                message = "查询运动计划时必须明确 scope：today、scheduled_date、current_plans、upcoming_plans、ended_plans 或 all_plans",
+            };
+        if (scope == "scheduled_date" &&
+            (!args.TryGetProperty("date", out var requestedDate) || !DateOnly.TryParse(requestedDate.GetString(), out _)))
+            return new { success = false, message = "查询指定日期的运动安排时必须提供有效的 date" };
+        var queryDate = scope == "scheduled_date"
+            ? DateOnly.Parse(args.GetProperty("date").GetString()!)
+            : AiDateTime.BeijingToday;
+        var isDateScope = scope is "today" or "scheduled_date";
+        var plans = await exercises.ListAllAsync(userId, ct);
+        var overview = plans.Select(plan => new
+        {
+            plan_id = plan.Id,
+            plan.StartDate,
+            plan.EndDate,
+            phase = queryDate < plan.StartDate ? "upcoming" : queryDate > plan.EndDate ? "ended" : "active",
+            plan.ReminderTime,
+            total_items = plan.Items.Count,
+            completed_items = plan.Items.Count(item => item.IsCompleted),
+            returned_items = isDateScope
+                ? plan.Items.Count(item => item.ScheduledDate == queryDate)
+                : Math.Min(plan.Items.Count, 14),
+            items_truncated = !isDateScope && plan.Items.Count > 14,
+            items = plan.Items
+                .Where(item => !isDateScope || item.ScheduledDate == queryDate)
+                .OrderBy(item => item.ScheduledDate)
+                .Take(isDateScope ? int.MaxValue : 14)
+                .Select(item => new
+                {
+                    item.Id,
+                    item.ScheduledDate,
+                    item.ExerciseType,
+                    item.DurationMinutes,
+                    item.IsCompleted,
+                    item.IsRestDay,
+                    completed_at_beijing = item.CompletedAt.HasValue ? AiDateTime.ToBeijingText(item.CompletedAt.Value) : null,
+                })
+                .ToList(),
+        });
+        var filtered = scope switch
+        {
+            "all_plans" => overview,
+            "current_plans" => overview.Where(plan => plan.phase == "active"),
+            "upcoming_plans" => overview
+                .Where(plan => plan.phase == "upcoming")
+                .OrderBy(plan => plan.StartDate),
+            "ended_plans" => overview
+                .Where(plan => plan.phase == "ended")
+                .OrderByDescending(plan => plan.EndDate),
+            _ => overview.Where(plan => plan.phase == "active" && plan.items.Count > 0),
+        };
+        var result = filtered.ToList();
+        var scheduledTasks = result.SelectMany(plan => plan.items).Where(item => !item.IsRestDay).ToList();
+        var nextPlan = plans.Where(plan => plan.StartDate > queryDate).OrderBy(plan => plan.StartDate).FirstOrDefault();
+        string authoritativeAnswer;
+        if (result.Count == 0)
+        {
+            authoritativeAnswer = isDateScope
+                ? $"没有查到 {queryDate:yyyy-MM-dd} 的运动安排。"
+                : "当前没有查到符合条件的运动计划。";
+        }
+        else if (isDateScope)
+        {
+            var taskLines = scheduledTasks.Select(item =>
+                $"- {item.ExerciseType}：{item.DurationMinutes} 分钟，{(item.IsCompleted ? "已完成" : "未完成")}");
+            authoritativeAnswer =
+                $"{queryDate:yyyy-MM-dd} 的运动安排：\n{string.Join('\n', taskLines)}";
+        }
+        else
+        {
+            var planLines = result.Select(plan =>
+            {
+                var representative = plan.items.FirstOrDefault(item => !item.IsRestDay);
+                var exerciseType = representative?.ExerciseType ?? "运动";
+                var durationMinutes = representative?.DurationMinutes ?? 0;
+                return $"- {exerciseType}：{plan.StartDate:yyyy-MM-dd} 至 {plan.EndDate:yyyy-MM-dd}，"
+                    + $"每天 {durationMinutes} 分钟，提醒时间 {plan.ReminderTime:HH:mm}";
+            });
+            authoritativeAnswer =
+                $"查到 {result.Count} 个符合条件的运动计划：\n{string.Join('\n', planLines)}";
+        }
+        return new
+        {
+            found = result.Count > 0,
+            query_date = queryDate.ToString("yyyy-MM-dd"),
+            scope,
+            count = result.Count,
+            all_tasks_completed = isDateScope
+                ? scheduledTasks.Count > 0 && scheduledTasks.All(item => item.IsCompleted)
+                : (bool?)null,
+            has_upcoming_plans = nextPlan != null,
+            next_start_date = nextPlan?.StartDate.ToString("yyyy-MM-dd"),
+            days_until_next_start = nextPlan == null ? (int?)null : nextPlan.StartDate.DayNumber - queryDate.DayNumber,
+            plans = result,
+            authoritative_answer = authoritativeAnswer,
+        };
+    }
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/health_data_agent_handler.cs

@@ -0,0 +1,296 @@
+using Health.Application.HealthRecords;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 记数据 Agent 工具处理器——录入健康指标
+/// </summary>
+public static class HealthDataAgentHandler
+{
+    private static readonly string[] MetricTypes = ["blood_pressure", "heart_rate", "glucose", "spo2", "weight"];
+
+    public static readonly ToolDefinition RecordHealthDataTool = new()
+    {
+        Function = new()
+        {
+            Name = "record_health_data",
+            Description = "记录健康数据（血压/心率/血糖/血氧/体重）。用户说“脉搏”时按“心率”处理，type 使用 heart_rate，数值写入 heart_rate。",
+            Parameters = new { type = "object", properties = new { type = new { type = "string", @enum = new[] { "blood_pressure", "heart_rate", "glucose", "spo2", "weight" } }, systolic = new { type = "integer" }, diastolic = new { type = "integer" }, heart_rate = new { type = "number" }, glucose = new { type = "number" }, spo2 = new { type = "number" }, weight = new { type = "number" }, recorded_at = new { type = "string", description = "测量时间；不带时区时按北京时间解释" } }, required = new[] { "type" } }
+        }
+    };
+
+    public static readonly ToolDefinition RecordHealthDataBatchTool = new()
+    {
+        Function = new()
+        {
+            Name = "record_health_data_batch",
+            Description = "提交当前这一轮要录入的全部健康指标。一次只调用一次；即使只有一个指标也放入 metrics。血压可先只提供已知的一侧，脉搏按心率 heart_rate 处理。后端会整批校验、追问或生成一张确认卡。",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    metrics = new
+                    {
+                        type = "array",
+                        minItems = 1,
+                        description = "当前录入批次的全部指标，不得遗漏；不要带入普通历史对话或上一张已生成卡片的数据",
+                        items = new
+                        {
+                            type = "object",
+                            properties = new
+                            {
+                                type = new { type = "string", @enum = MetricTypes },
+                                systolic = new { type = "integer" },
+                                diastolic = new { type = "integer" },
+                                heart_rate = new { type = "number" },
+                                glucose = new { type = "number" },
+                                spo2 = new { type = "number" },
+                                weight = new { type = "number" },
+                                recorded_at = new { type = "string", description = "测量时间；不带时区时按北京时间解释" },
+                            },
+                            required = new[] { "type" },
+                        },
+                    },
+                },
+                required = new[] { "metrics" },
+            },
+        },
+    };
+
+    public static List<ToolDefinition> Tools => [RecordHealthDataBatchTool, CommonAgentHandler.QueryHealthRecordsTool];
+
+    public static string? ValidateWriteArguments(JsonElement args)
+    {
+        var type = args.TryGetProperty("type", out var typeValue) ? typeValue.GetString() : null;
+        return type switch
+        {
+            "blood_pressure" => ValidateBloodPressure(args),
+            "heart_rate" => ValidateValue(args, "heart_rate", "心率", 1m, 250m),
+            "glucose" => ValidateValue(args, "glucose", "血糖", 0.1m, 50m),
+            "spo2" => ValidateValue(args, "spo2", "血氧", 1m, 100m),
+            "weight" => ValidateValue(args, "weight", "体重", 1m, 500m),
+            _ => "缺少有效的健康指标类型",
+        };
+    }
+
+    public static string? GetUrgentWarning(JsonElement args)
+    {
+        var type = args.TryGetProperty("type", out var typeValue) ? typeValue.GetString() : null;
+        return type switch
+        {
+            "blood_pressure"
+                when args.TryGetProperty("systolic", out var systolic) &&
+                     systolic.TryGetInt32(out var systolicValue) &&
+                     args.TryGetProperty("diastolic", out var diastolic) &&
+                     diastolic.TryGetInt32(out var diastolicValue) &&
+                     (systolicValue >= 180 || diastolicValue >= 120)
+                => "这次血压数值已达到明显危险范围，请不要继续等待录入，尽快联系医生或前往急诊评估。",
+            "heart_rate" when IsValueOutside(args, "heart_rate", 45m, 130m)
+                => "这次心率数值明显异常，请尽快联系医生评估；如伴有胸痛、晕厥或呼吸困难，请立即就医。",
+            "glucose" when IsValueOutside(args, "glucose", 3.0m, 16.7m)
+                => "这次血糖数值属于需要尽快处理的危险范围，请立即联系医生或前往医疗机构评估。",
+            "spo2"
+                when args.TryGetProperty("spo2", out var spo2) &&
+                     spo2.TryGetDecimal(out var spo2Value) &&
+                     spo2Value <= 90m
+                => "这次血氧数值明显偏低，请尽快就医评估；如有呼吸困难、胸闷或意识异常，请立即拨打当地急救电话。",
+            _ => null,
+        };
+    }
+
+    public static IReadOnlyList<JsonElement> GetBatchMetrics(JsonElement args) =>
+        args.TryGetProperty("metrics", out var metrics) && metrics.ValueKind == JsonValueKind.Array
+            ? metrics.EnumerateArray().Select(metric => metric.Clone()).ToList()
+            : [];
+
+    public static Dictionary<string, object?> CreatePreview(JsonElement args)
+    {
+        var type = args.TryGetProperty("type", out var typeValue) ? typeValue.GetString() ?? "" : "";
+        var (metricType, value, unit, systolic, diastolic) = ParseMetric(type, args);
+        if (metricType == null)
+            return [];
+
+        var request = new HealthRecordUpsertRequest(
+            metricType.Value,
+            systolic,
+            diastolic,
+            value,
+            unit,
+            HealthRecordSource.AiEntry,
+            null);
+        return new Dictionary<string, object?>
+        {
+            ["type"] = metricType.Value.ToString(),
+            ["value"] = metricType == HealthMetricType.BloodPressure
+                ? $"{systolic}/{diastolic}"
+                : value?.ToString() ?? "",
+            ["unit"] = unit,
+            ["abnormal"] = HealthRecordRules.CheckAbnormal(request),
+        };
+    }
+
+    public static async Task<object> Execute(
+        string toolName,
+        JsonElement args,
+        Guid userId,
+        IHealthRecordService healthRecords,
+        CancellationToken ct)
+    {
+        return toolName switch
+        {
+            "record_health_data" => await ExecuteRecordHealthData(healthRecords, userId, args, ct),
+            "record_health_data_batch" => await ExecuteRecordHealthDataBatch(healthRecords, userId, args, ct),
+            _ => new { success = false, message = $"未知工具: {toolName}" }
+        };
+    }
+
+    private static async Task<object> ExecuteRecordHealthData(
+        IHealthRecordService healthRecords,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var validationError = ValidateWriteArguments(args);
+        if (validationError != null)
+            return new { success = false, message = validationError };
+
+        var type = args.TryGetProperty("type", out var t) ? t.GetString()! : "";
+        var (metricType, value, unit, systolic, diastolic) = ParseMetric(type, args);
+        if (metricType == null)
+            return new { success = false, message = $"未知指标类型: {type}" };
+
+        var recordedAt = args.TryGetProperty("recorded_at", out var ra) &&
+                         AiDateTime.TryParseUserDateTime(ra.GetString(), out var parsedRecordedAt)
+            ? parsedRecordedAt
+            : DateTime.UtcNow;
+
+        var request = new HealthRecordUpsertRequest(
+            metricType.Value,
+            systolic,
+            diastolic,
+            value,
+            unit,
+            HealthRecordSource.AiEntry,
+            recordedAt);
+
+        var id = await healthRecords.CreateAsync(userId, request, ct);
+        var valStr = metricType == HealthMetricType.BloodPressure ? $"{systolic}/{diastolic}" : value?.ToString() ?? "";
+        return new
+        {
+            success = true,
+            record_id = id,
+            type = metricType.Value.ToString(),
+            value = valStr,
+            unit,
+            isAbnormal = HealthRecordRules.CheckAbnormal(request)
+        };
+    }
+
+    private static async Task<object> ExecuteRecordHealthDataBatch(
+        IHealthRecordService healthRecords,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var metrics = GetBatchMetrics(args);
+        if (metrics.Count == 0)
+            return new { success = false, message = "当前录入批次没有健康指标" };
+
+        var requests = new List<HealthRecordUpsertRequest>(metrics.Count);
+        var previews = new List<Dictionary<string, object?>>(metrics.Count);
+        foreach (var metric in metrics)
+        {
+            var validationError = ValidateWriteArguments(metric);
+            if (validationError != null)
+                return new { success = false, message = validationError };
+
+            var type = metric.GetProperty("type").GetString()!;
+            var (metricType, value, unit, systolic, diastolic) = ParseMetric(type, metric);
+            if (metricType == null)
+                return new { success = false, message = $"未知指标类型: {type}" };
+
+            var recordedAt = metric.TryGetProperty("recorded_at", out var recordedAtValue) &&
+                             AiDateTime.TryParseUserDateTime(recordedAtValue.GetString(), out var parsedRecordedAt)
+                ? parsedRecordedAt
+                : DateTime.UtcNow;
+            requests.Add(new HealthRecordUpsertRequest(
+                metricType.Value,
+                systolic,
+                diastolic,
+                value,
+                unit,
+                HealthRecordSource.AiEntry,
+                recordedAt));
+            previews.Add(CreatePreview(metric));
+        }
+
+        var ids = await healthRecords.CreateManyAsync(userId, requests, ct);
+        return new
+        {
+            success = true,
+            record_ids = ids,
+            items = previews,
+        };
+    }
+
+    private static string? ValidateBloodPressure(JsonElement args)
+    {
+        if (!args.TryGetProperty("systolic", out var systolicValue) || !systolicValue.TryGetInt32(out var systolic) ||
+            !args.TryGetProperty("diastolic", out var diastolicValue) || !diastolicValue.TryGetInt32(out var diastolic))
+            return "录入血压前需要同时提供收缩压和舒张压";
+        if (systolic is <= 0 or > 260 || diastolic is <= 0 or > 160 || systolic <= diastolic)
+            return "血压数值明显无效，请核对收缩压和舒张压后重新提供";
+        return null;
+    }
+
+    private static string? ValidateValue(JsonElement args, string property, string label, decimal minimum, decimal maximum)
+    {
+        if (!args.TryGetProperty(property, out var valueElement) || !valueElement.TryGetDecimal(out var value))
+            return $"录入{label}前需要提供数值";
+        return value < minimum || value > maximum ? $"{label}数值明显无效，请重新提供" : null;
+    }
+
+    private static bool IsValueOutside(JsonElement args, string property, decimal minimum, decimal maximum) =>
+        args.TryGetProperty(property, out var valueElement) &&
+        valueElement.TryGetDecimal(out var value) &&
+        (value <= minimum || value >= maximum);
+
+    private static (HealthMetricType? Type, decimal? Value, string Unit, int? Systolic, int? Diastolic) ParseMetric(string type, JsonElement args)
+    {
+        return type switch
+        {
+            "blood_pressure" => (
+                HealthMetricType.BloodPressure,
+                null,
+                "mmHg",
+                args.TryGetProperty("systolic", out var s) ? s.GetInt32() : null,
+                args.TryGetProperty("diastolic", out var d) ? d.GetInt32() : null),
+            "heart_rate" => (
+                HealthMetricType.HeartRate,
+                args.TryGetProperty("heart_rate", out var hr) ? hr.GetDecimal() : null,
+                "次/分",
+                null,
+                null),
+            "glucose" => (
+                HealthMetricType.Glucose,
+                args.TryGetProperty("glucose", out var g) ? g.GetDecimal() : null,
+                "mmol/L",
+                null,
+                null),
+            "spo2" => (
+                HealthMetricType.SpO2,
+                args.TryGetProperty("spo2", out var o) ? o.GetDecimal() : null,
+                "%",
+                null,
+                null),
+            "weight" => (
+                HealthMetricType.Weight,
+                args.TryGetProperty("weight", out var w) ? w.GetDecimal() : null,
+                "kg",
+                null,
+                null),
+            _ => (null, null, "", null, null)
+        };
+    }
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/medication_agent_handler.cs

@@ -0,0 +1,266 @@
+using Health.Application.Medications;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 药提醒 Agent 工具处理器。
+/// </summary>
+public static class MedicationAgentHandler
+{
+    public static readonly ToolDefinition ManageMedicationTool = new()
+    {
+        Function = new()
+        {
+            Name = "manage_medication",
+            Description = "用药管理（创建计划、按日期查询计划与逐顿服药状态、确认某一顿服药）",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    action = new { type = "string", @enum = new[] { "create", "query", "confirm" }, description = "create/query/confirm" },
+                    scope = new { type = "string", @enum = new[] { "today", "scheduled_date", "current_plans", "upcoming_plans", "ended_plans", "inactive_plans", "all_plans" }, description = "查询时必填：今日安排/指定日期安排/当前计划/即将开始/自然结束/已停用/全部计划" },
+                    date = new { type = "string", description = "仅 scope=scheduled_date 时必填，使用北京时间日期 yyyy-MM-dd" },
+                    medication_id = new { type = "string", description = "药品 ID，确认服药时使用" },
+                    scheduled_time = new { type = "string", description = "要确认的计划服药时间 HH:mm" },
+                    name = new { type = "string", description = "药品名称" },
+                    dosage = new { type = "string", description = "剂量，如 100mg" },
+                    frequency = new { type = "string", @enum = new[] { "Daily", "TwiceDaily", "ThreeTimesDaily", "EveryOtherDay", "Weekly", "AsNeeded" }, description = "服药频率" },
+                    time_of_day = new { type = "array", items = new { type = "string" }, description = "服药时间，如 [\"08:00\",\"20:00\"]" },
+                    duration_days = new { type = "integer", description = "服用天数" },
+                    long_term = new { type = "boolean", description = "是否明确为长期服用；与 duration_days 二选一" },
+                    start_date = new { type = "string", description = "开始日期 yyyy-MM-dd" },
+                },
+                required = new[] { "action" }
+            }
+        }
+    };
+
+    public static List<ToolDefinition> Tools => [ManageMedicationTool, CommonAgentHandler.CheckArchiveTool];
+    public static async Task<object> Execute(
+        string toolName,
+        JsonElement args,
+        Guid userId,
+        IMedicationService medications,
+        CancellationToken ct = default)
+    {
+        return toolName switch
+        {
+            "manage_medication" => await ExecuteManageMedication(medications, userId, args, ct),
+            _ => new { success = false, message = $"未知工具: {toolName}" }
+        };
+    }
+
+    private static async Task<object> ExecuteManageMedication(IMedicationService medications, Guid userId, JsonElement args, CancellationToken ct)
+    {
+        var action = args.TryGetProperty("action", out var a) ? a.GetString()?.ToLowerInvariant() : null;
+        return action switch
+        {
+            "create" => await CreateMedication(medications, userId, args, ct),
+            "query" => await QueryMedications(medications, userId, args, ct),
+            "confirm" => await ConfirmMedication(medications, userId, args, ct),
+            _ => new { success = false, message = $"未知操作: {action}" }
+        };
+    }
+
+    private static async Task<object> CreateMedication(IMedicationService medications, Guid userId, JsonElement args, CancellationToken ct)
+    {
+        var validationError = ValidateWriteArguments(args);
+        if (validationError != null)
+            return new { success = false, message = validationError };
+
+        var name = args.TryGetProperty("name", out var n) ? n.GetString()! : "";
+        var dosage = args.TryGetProperty("dosage", out var dg) ? dg.GetString() : null;
+        var frequency = ReadFrequency(args);
+        var times = ReadTimes(args);
+        var durationDays = args.TryGetProperty("duration_days", out var dd) ? dd.GetInt32() : 0;
+        var longTerm = args.TryGetProperty("long_term", out var longTermValue) && longTermValue.ValueKind == JsonValueKind.True;
+        var startDate = ReadStartDate(args);
+        // 结束日为包含式（IsActiveOn 用 EndDate >= date 判断），故 N 天疗程结束日 = 起始日 + (N-1)
+        DateOnly? endDate = longTerm ? null : startDate.AddDays(durationDays - 1);
+
+        var medicationId = await medications.CreateAsync(userId, new MedicationUpsertRequest(
+            name,
+            dosage,
+            frequency,
+            times.Count > 0 ? times : [new TimeOnly(8, 0)],
+            startDate,
+            endDate,
+            MedicationSource.AiEntry,
+            null), ct);
+
+        var timeLabels = times.Count > 0 ? string.Join(", ", times.Select(t => t.ToString("HH:mm"))) : "08:00";
+        return new
+        {
+            success = true,
+            medication_id = medicationId,
+            name,
+            dosage,
+            frequency = frequency.ToString(),
+            time = timeLabels,
+            start_date = startDate.ToString("yyyy-MM-dd"),
+            duration_days = durationDays,
+            long_term = longTerm,
+        };
+    }
+
+    private static async Task<object> QueryMedications(
+        IMedicationService medications,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var scope = args.TryGetProperty("scope", out var scopeValue)
+            ? scopeValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (scope is not ("today" or "scheduled_date" or "current_plans" or "upcoming_plans" or "ended_plans" or "inactive_plans" or "all_plans"))
+            return new
+            {
+                success = false,
+                message = "查询用药时必须明确 scope：today、scheduled_date、current_plans、upcoming_plans、ended_plans、inactive_plans 或 all_plans",
+            };
+        if (scope == "scheduled_date" &&
+            (!args.TryGetProperty("date", out var requestedDate) || !DateOnly.TryParse(requestedDate.GetString(), out _)))
+            return new { success = false, message = "查询指定日期的用药安排时必须提供有效的 date" };
+        var date = scope == "scheduled_date"
+            ? DateOnly.Parse(args.GetProperty("date").GetString()!)
+            : AiDateTime.BeijingToday;
+        var isDateScope = scope is "today" or "scheduled_date";
+        var overview = await medications.GetAiOverviewAsync(userId, date, ct);
+        var plans = scope switch
+        {
+            "all_plans" => overview.ToList(),
+            "current_plans" => overview.Where(plan => plan.Phase == "active").ToList(),
+            "upcoming_plans" => overview
+                .Where(plan => plan.Phase == "upcoming")
+                .OrderBy(plan => plan.StartDate)
+                .ToList(),
+            "ended_plans" => overview
+                .Where(plan => plan.Phase == "ended")
+                .OrderByDescending(plan => plan.EndDate)
+                .ToList(),
+            "inactive_plans" => overview
+                .Where(plan => plan.Phase == "inactive")
+                .OrderByDescending(plan => plan.EndDate)
+                .ToList(),
+            _ => overview.Where(plan => plan.ScheduledOnDate).ToList(),
+        };
+        var doseStatuses = plans.SelectMany(plan => plan.Doses).ToList();
+        var nextPlan = overview
+            .Where(plan => plan.Phase == "upcoming" && plan.StartDate.HasValue)
+            .OrderBy(plan => plan.StartDate)
+            .FirstOrDefault();
+
+        return new
+        {
+            query_date = date.ToString("yyyy-MM-dd"),
+            scope,
+            count = plans.Count,
+            all_doses_completed = isDateScope
+                ? doseStatuses.Count > 0 && doseStatuses.All(dose => dose.Status == "taken")
+                : (bool?)null,
+            has_upcoming_plans = nextPlan != null,
+            next_start_date = nextPlan?.StartDate?.ToString("yyyy-MM-dd"),
+            days_until_next_start = nextPlan?.StartDate is DateOnly nextStart
+                ? nextStart.DayNumber - date.DayNumber
+                : (int?)null,
+            plans,
+        };
+    }
+
+    private static async Task<object> ConfirmMedication(IMedicationService medications, Guid userId, JsonElement args, CancellationToken ct)
+    {
+        var validationError = ValidateWriteArguments(args);
+        if (validationError != null)
+            return new { success = false, message = validationError };
+
+        var medId = args.TryGetProperty("medication_id", out var mid) && mid.TryGetGuid(out var parsedMedicationId)
+            ? parsedMedicationId
+            : Guid.Empty;
+        if (!args.TryGetProperty("scheduled_time", out var timeValue) ||
+            !TimeOnly.TryParse(timeValue.GetString(), out var scheduledTime))
+            return new { success = false, message = "缺少要确认的计划服药时间" };
+
+        var success = await medications.ConfirmDoseAsync(
+            userId,
+            medId,
+            scheduledTime,
+            MedicationLogStatus.Taken,
+            ct);
+        return success == true
+            ? new { success = true, medication_id = medId, scheduled_time = scheduledTime.ToString("HH:mm") }
+            : new { success = false, message = success == null ? "药品不存在" : "该时间不属于今天的服药安排，或这一顿已经记录" };
+    }
+
+    public static string? ValidateWriteArguments(JsonElement args)
+    {
+        var action = args.TryGetProperty("action", out var actionValue)
+            ? actionValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (action == "confirm")
+        {
+            if (!args.TryGetProperty("medication_id", out var medicationId) || !medicationId.TryGetGuid(out _))
+                return "确认服药时缺少有效的药品 ID";
+            if (!args.TryGetProperty("scheduled_time", out var scheduledTime) || !TimeOnly.TryParse(scheduledTime.GetString(), out _))
+                return "确认服药时缺少具体的计划服药时间";
+            return null;
+        }
+
+        if (action != "create") return null;
+        if (!args.TryGetProperty("name", out var name) || string.IsNullOrWhiteSpace(name.GetString()))
+            return "创建用药计划前需要确认药品名称";
+        if (!args.TryGetProperty("dosage", out var dosage) || string.IsNullOrWhiteSpace(dosage.GetString()))
+            return "创建用药计划前需要确认每次剂量";
+        if (!args.TryGetProperty("frequency", out var frequencyValue) ||
+            !Enum.TryParse<MedicationFrequency>(frequencyValue.GetString(), ignoreCase: true, out _))
+            return "创建用药计划前需要确认服药频率";
+        if (!args.TryGetProperty("time_of_day", out var times) || times.ValueKind != JsonValueKind.Array)
+            return "创建用药计划前需要确认具体服药时间";
+        var timeValues = times.EnumerateArray().ToList();
+        if (timeValues.Count == 0 || timeValues.Any(value => !TimeOnly.TryParse(value.GetString(), out _)))
+            return "创建用药计划前需要提供有效的具体服药时间";
+        if (!args.TryGetProperty("start_date", out var startDate) || !DateOnly.TryParse(startDate.GetString(), out _))
+            return "创建用药计划前需要确认开始日期";
+
+        var durationDays = 0;
+        var hasDuration = args.TryGetProperty("duration_days", out var duration) &&
+                          duration.TryGetInt32(out durationDays) && durationDays > 0;
+        var isLongTerm = args.TryGetProperty("long_term", out var longTerm) && longTerm.ValueKind == JsonValueKind.True;
+        if (hasDuration && durationDays > 3650)
+            return "服用天数不能超过3650天；长期服用请明确设置 long_term=true";
+        if (hasDuration && isLongTerm)
+            return "服用天数和长期服用不能同时设置";
+        if (!hasDuration && !isLongTerm)
+            return "创建用药计划前需要确认服用天数，或明确说明长期服用";
+        return null;
+    }
+
+
+    private static MedicationFrequency ReadFrequency(JsonElement args)
+    {
+        var frequencyStr = args.TryGetProperty("frequency", out var f) ? f.GetString() : "Daily";
+        return Enum.TryParse<MedicationFrequency>(frequencyStr, ignoreCase: true, out var frequency) ? frequency : MedicationFrequency.Daily;
+    }
+
+    private static DateOnly ReadStartDate(JsonElement args)
+    {
+        var startDateStr = args.TryGetProperty("start_date", out var sd) && sd.GetString() is string sds ? sds : null;
+        return DateOnly.TryParse(startDateStr, out var parsedDate)
+            ? parsedDate
+            : DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+    }
+
+    private static List<TimeOnly> ReadTimes(JsonElement args)
+    {
+        List<TimeOnly> times = [];
+        if (!args.TryGetProperty("time_of_day", out var tod) || tod.ValueKind != JsonValueKind.Array)
+            return times;
+
+        foreach (var t in tod.EnumerateArray())
+        {
+            if (TimeOnly.TryParse(t.GetString(), out var parsed)) times.Add(parsed);
+        }
+
+        return times;
+    }
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/patient_read_agent_handler.cs

@@ -0,0 +1,257 @@
+using Health.Application.Diets;
+using Health.Application.Notifications;
+using Health.Application.Reports;
+
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 统一助手使用的患者本人业务数据只读工具。
+/// </summary>
+public static class PatientReadAgentHandler
+{
+    public static readonly ToolDefinition QueryDietRecordsTool = new()
+    {
+        Function = new()
+        {
+            Name = "query_diet_records",
+            Description = "查询当前用户指定北京时间日期的饮食记录和总热量",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    date = new { type = "string", description = "北京时间日期 yyyy-MM-dd，默认今天" },
+                    meal_type = new { type = "string", @enum = new[] { "Breakfast", "Lunch", "Dinner", "Snack" }, description = "可选餐次" },
+                }
+            }
+        }
+    };
+
+    public static readonly ToolDefinition QueryFollowUpsTool = new()
+    {
+        Function = new()
+        {
+            Name = "query_followups",
+            Description = "查询当前用户的复查随访安排",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    scope = new { type = "string", @enum = new[] { "next", "upcoming", "completed", "date", "all" }, description = "查询时必填：下一次/未来安排/已完成/指定日期/全部" },
+                    date = new { type = "string", description = "scope=date 时的北京时间日期 yyyy-MM-dd" },
+                    limit = new { type = "integer", description = "最多返回条数，1到20" },
+                }
+            }
+        }
+    };
+
+    public static readonly ToolDefinition QueryReportsTool = new()
+    {
+        Function = new()
+        {
+            Name = "query_reports",
+            Description = "查询当前用户已经保存的检查报告状态、AI摘要和医生审核结论，不读取其他用户报告",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    limit = new { type = "integer", description = "最多返回条数，1到10，默认5" },
+                    status = new { type = "string", description = "可选报告状态" },
+                }
+            }
+        }
+    };
+
+    public static readonly ToolDefinition QueryNotificationsTool = new()
+    {
+        Function = new()
+        {
+            Name = "query_notifications",
+            Description = "查询当前用户的站内通知",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    scope = new { type = "string", @enum = new[] { "unread", "today", "recent" }, description = "默认 unread" },
+                    limit = new { type = "integer", description = "最多返回条数，1到20" },
+                }
+            }
+        }
+    };
+
+    public static async Task<object> QueryDietAsync(
+        IDietService diets,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        if (args.TryGetProperty("date", out var suppliedDate) && !DateOnly.TryParse(suppliedDate.GetString(), out _))
+            return new { success = false, message = "查询饮食记录时提供了无效的 date" };
+        var date = args.TryGetProperty("date", out var dateValue) && DateOnly.TryParse(dateValue.GetString(), out var parsedDate)
+            ? parsedDate
+            : AiDateTime.BeijingToday;
+        var mealType = args.TryGetProperty("meal_type", out var mealValue) ? mealValue.GetString() : null;
+        var records = await diets.ListAsync(userId, date.ToString("yyyy-MM-dd"), mealType, ct);
+        return new
+        {
+            query_date = date.ToString("yyyy-MM-dd"),
+            count = records.Count,
+            total_calories = records.Sum(record => record.TotalCalories ?? 0),
+            records = records.Select(record => new
+            {
+                record.Id,
+                record.MealType,
+                record.TotalCalories,
+                record.HealthScore,
+                record.RecordedAt,
+                record.FoodItems,
+            }),
+        };
+    }
+
+    public static async Task<object> QueryFollowUpsAsync(
+        AppDbContext db,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var scope = args.TryGetProperty("scope", out var scopeValue)
+            ? scopeValue.GetString()?.ToLowerInvariant()
+            : null;
+        if (scope is not ("next" or "upcoming" or "completed" or "date" or "all"))
+            return new
+            {
+                success = false,
+                message = "查询复查安排时必须明确 scope：next、upcoming、completed、date 或 all",
+            };
+        var limit = ReadLimit(args, 10, 20);
+        var nowUtc = DateTime.UtcNow;
+        var query = db.FollowUps.AsNoTracking().Where(item => item.UserId == userId);
+
+        if (scope is "next" or "upcoming")
+            query = query.Where(item => item.Status == FollowUpStatus.Upcoming && item.ScheduledAt >= nowUtc);
+        else if (scope == "completed")
+            query = query.Where(item => item.Status == FollowUpStatus.Completed);
+        else if (scope == "date")
+        {
+            if (!args.TryGetProperty("date", out var dateValue) || !DateOnly.TryParse(dateValue.GetString(), out var date))
+                return new { success = false, message = "按日期查询复查时必须提供有效的 date" };
+            var (startUtc, endUtc) = AiDateTime.BeijingDateWindowUtc(date);
+            query = query.Where(item => item.ScheduledAt >= startUtc && item.ScheduledAt < endUtc);
+        }
+
+        var take = scope == "next" ? 1 : limit;
+        var orderedQuery = scope is "all" or "completed"
+            ? query.OrderByDescending(item => item.ScheduledAt)
+            : query.OrderBy(item => item.ScheduledAt);
+        var matchingCount = await query.CountAsync(ct);
+        var items = await orderedQuery
+            .Take(take)
+            .Select(item => new
+            {
+                item.Id,
+                item.Title,
+                item.DoctorName,
+                item.Department,
+                item.ScheduledAt,
+                item.Notes,
+                item.Status,
+            })
+            .ToListAsync(ct);
+        return new
+        {
+            success = true,
+            scope,
+            count = items.Count,
+            matching_count = matchingCount,
+            results_truncated = matchingCount > items.Count,
+            followups = items.Select(item => new
+            {
+                item.Id,
+                item.Title,
+                item.DoctorName,
+                item.Department,
+                scheduled_at_beijing = AiDateTime.ToBeijingText(item.ScheduledAt),
+                item.Notes,
+                status = item.Status.ToString(),
+            }),
+        };
+    }
+
+    public static async Task<object> QueryReportsAsync(
+        IReportService reports,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var limit = ReadLimit(args, 5, 10);
+        var status = args.TryGetProperty("status", out var statusValue) ? statusValue.GetString() : null;
+        var records = await reports.GetReportsAsync(userId, ct);
+        var filtered = records
+            .Where(report => string.IsNullOrWhiteSpace(status) || report.Status.Equals(status, StringComparison.OrdinalIgnoreCase))
+            .OrderByDescending(report => report.CreatedAt)
+            .Take(limit)
+            .Select(report => new
+            {
+                report.Id,
+                report.Category,
+                report.Status,
+                report.AiStatus,
+                report.ReviewStatus,
+                report.Severity,
+                ai_summary = Truncate(report.AiSummary, 1800),
+                doctor_comment = Truncate(report.DoctorComment, 1000),
+                doctor_recommendation = Truncate(report.DoctorRecommendation, 1000),
+                report.DoctorName,
+                reviewed_at_beijing = report.ReviewedAt.HasValue ? AiDateTime.ToBeijingText(report.ReviewedAt.Value) : null,
+                created_at_beijing = AiDateTime.ToBeijingText(report.CreatedAt),
+            })
+            .ToList();
+        return new { count = filtered.Count, reports = filtered };
+    }
+
+    public static async Task<object> QueryNotificationsAsync(
+        IInAppNotificationService notifications,
+        Guid userId,
+        JsonElement args,
+        CancellationToken ct)
+    {
+        var scope = args.TryGetProperty("scope", out var scopeValue)
+            ? scopeValue.GetString()?.ToLowerInvariant() ?? "unread"
+            : "unread";
+        if (scope is not ("unread" or "today" or "recent")) scope = "unread";
+        var limit = ReadLimit(args, 10, 20);
+        var records = scope == "unread"
+            ? await notifications.GetPendingAsync(userId, ct)
+            : await notifications.GetHistoryAsync(userId, ct);
+        var (todayStartUtc, todayEndUtc) = AiDateTime.BeijingDateWindowUtc(AiDateTime.BeijingToday);
+        var filtered = records
+            .Where(item => scope != "today" ||
+                (AiDateTime.ToUtc(item.CreatedAt) >= todayStartUtc && AiDateTime.ToUtc(item.CreatedAt) < todayEndUtc))
+            .OrderByDescending(item => item.CreatedAt)
+            .Take(limit)
+            .Select(item => new
+            {
+                item.Id,
+                item.Type,
+                item.Title,
+                item.Message,
+                item.Severity,
+                item.IsRead,
+                created_at_beijing = AiDateTime.ToBeijingText(item.CreatedAt),
+            })
+            .ToList();
+        return new { scope, count = filtered.Count, notifications = filtered };
+    }
+
+    private static int ReadLimit(JsonElement args, int defaultValue, int max) =>
+        args.TryGetProperty("limit", out var value) && value.TryGetInt32(out var parsed)
+            ? Math.Clamp(parsed, 1, max)
+            : defaultValue;
+
+    private static string? Truncate(string? value, int maxLength) =>
+        string.IsNullOrWhiteSpace(value) || value.Length <= maxLength ? value : value[..maxLength] + "…";
+}

backend/src/Health.Infrastructure/AI/AgentHandlers/report_agent_handler.cs

@@ -0,0 +1,49 @@
+namespace Health.Infrastructure.AI.AgentHandlers;
+
+/// <summary>
+/// 看报告 Agent 工具处理器——报告分析
+/// </summary>
+public static class ReportAgentHandler
+{
+    public static readonly ToolDefinition AnalyzeReportTool = new()
+    {
+        Function = new() { Name = "analyze_report", Description = "分析报告图片", Parameters = new { type = "object", properties = new { image_url = new { type = "string" } }, required = new[] { "image_url" } } }
+    };
+
+    public static List<ToolDefinition> Tools => [AnalyzeReportTool, CommonAgentHandler.QueryHealthRecordsTool];
+
+    public static async Task<object> AnalyzeReport(AppDbContext db, Guid userId, JsonElement args, VisionClient visionClient)
+    {
+        var imageUrl = args.TryGetProperty("image_url", out var u) ? u.GetString()! : "";
+        if (string.IsNullOrEmpty(imageUrl))
+            return new { success = false, message = "缺少报告图片" };
+
+        var prompt = """
+            你是报告结构化提取助手。请识别以下检查报告图片，以JSON格式返回：
+            {
+              "reportType": "报告类型（血常规/生化全项/心电图/彩超/出院小结/其他）",
+              "indicators": [
+                {"name":"指标名","value":"数值","unit":"单位","range":"参考范围","status":"normal/high/low"}
+              ],
+              "summary": "列出异常指标及其数值和参考范围，客观说明超出范围，不解释可能原因，不结合用户档案做关联分析，建议咨询医生解读",
+              "needsDoctorReview": true/false
+            }
+            只返回JSON，不要其他内容。
+            """;
+
+        var response = await visionClient.VisionAsync(prompt, [imageUrl], userText: "请分析这份检查报告");
+        var content = response.Choices?.FirstOrDefault()?.Message?.Content ?? "{}";
+
+        // 保存到报告记录
+        var report = await db.Reports
+            .OrderByDescending(r => r.CreatedAt)
+            .FirstOrDefaultAsync(r => r.UserId == userId && r.Status == ReportStatus.PendingDoctor);
+        if (report != null)
+        {
+            report.AiSummary = content;
+            report.AiIndicators = content;
+        }
+
+        return new { success = true, analysis = content };
+    }
+}

backend/src/Health.Infrastructure/AI/AiToolExecutionService.cs

@@ -0,0 +1,91 @@
+using System.Text.Json;
+using Health.Application.AI;
+using Health.Application.Exercises;
+using Health.Application.Diets;
+using Health.Application.HealthArchives;
+using Health.Application.HealthRecords;
+using Health.Application.Medications;
+using Health.Application.Notifications;
+using Health.Application.Reports;
+using Health.Infrastructure.AI.AgentHandlers;
+
+namespace Health.Infrastructure.AI;
+
+public sealed class AiToolExecutionService(
+    AppDbContext db,
+    VisionClient visionClient,
+    IHealthArchiveService healthArchives,
+    IHealthRecordService healthRecords,
+    IExerciseService exercises,
+    IMedicationService medications,
+    IDietService diets,
+    IReportService reports,
+    IInAppNotificationService notifications,
+    IAiWriteConfirmationStore confirmations) : IAiToolExecutionService
+{
+    private readonly AppDbContext _db = db;
+    private readonly VisionClient _visionClient = visionClient;
+    private readonly IHealthArchiveService _healthArchives = healthArchives;
+    private readonly IHealthRecordService _healthRecords = healthRecords;
+    private readonly IExerciseService _exercises = exercises;
+    private readonly IMedicationService _medications = medications;
+    private readonly IDietService _diets = diets;
+    private readonly IReportService _reports = reports;
+    private readonly IInAppNotificationService _notifications = notifications;
+    private readonly IAiWriteConfirmationStore _confirmations = confirmations;
+
+    public async Task<object> ExecuteAsync(string toolName, string arguments, Guid userId, CancellationToken ct)
+    {
+        using var json = JsonDocument.Parse(arguments);
+        var root = json.RootElement;
+        return await (toolName switch
+        {
+            "record_health_data" or "record_health_data_batch"
+                => HealthDataAgentHandler.Execute(toolName, root, userId, _healthRecords, ct),
+            "query_health_records" => CommonAgentHandler.Execute(toolName, root, userId, _healthRecords, _healthArchives, ct),
+            "check_archive" => CommonAgentHandler.Execute(toolName, root, userId, _healthRecords, _healthArchives, ct),
+            "manage_medication" => MedicationAgentHandler.Execute(toolName, root, userId, _medications, ct),
+            "analyze_report" => ReportAgentHandler.AnalyzeReport(_db, userId, root, _visionClient),
+            "manage_exercise" => ExerciseAgentHandler.Execute(toolName, root, userId, _exercises, ct),
+            "query_diet_records" => PatientReadAgentHandler.QueryDietAsync(_diets, userId, root, ct),
+            "query_followups" => PatientReadAgentHandler.QueryFollowUpsAsync(_db, userId, root, ct),
+            "query_reports" => PatientReadAgentHandler.QueryReportsAsync(_reports, userId, root, ct),
+            "query_notifications" => PatientReadAgentHandler.QueryNotificationsAsync(_notifications, userId, root, ct),
+            _ => Task.FromResult<object>(new { success = false, message = $"未知工具: {toolName}" }),
+        });
+    }
+
+    public async Task<AiConfirmedWriteResult> ConfirmAsync(Guid commandId, Guid userId, CancellationToken ct)
+    {
+        await using var transaction = await _db.Database.BeginTransactionAsync(ct);
+        var command = await _confirmations.TakeAsync(commandId, userId, ct);
+        if (command == null)
+            return new AiConfirmedWriteResult(40004, null, "确认请求不存在、已执行或已过期");
+
+        try
+        {
+            var result = await ExecuteAsync(command.ToolName, command.Arguments, userId, ct);
+            if (!Succeeded(result, out var error))
+            {
+                await transaction.RollbackAsync(ct);
+                return new AiConfirmedWriteResult(40001, result, error ?? "写入失败，请检查内容后重试");
+            }
+            await _confirmations.CompleteAsync(command, ct);
+            await transaction.CommitAsync(ct);
+            return new AiConfirmedWriteResult(0, result, null);
+        }
+        catch (Exception ex)
+        {
+            await transaction.RollbackAsync(ct);
+            return new AiConfirmedWriteResult(50001, null, $"写入失败: {ex.Message}");
+        }
+    }
+
+    private static bool Succeeded(object result, out string? error)
+    {
+        using var json = JsonDocument.Parse(JsonSerializer.Serialize(result));
+        var root = json.RootElement;
+        error = root.TryGetProperty("message", out var message) ? message.GetString() : null;
+        return !root.TryGetProperty("success", out var success) || success.ValueKind != JsonValueKind.False;
+    }
+}

backend/src/Health.Infrastructure/AI/AttachmentContextBuilder.cs

@@ -0,0 +1,168 @@
+using System.Text.Json;
+using Health.Application.AI;
+using Health.Infrastructure.Files;
+using Microsoft.Extensions.Logging;
+using UglyToad.PdfPig;
+
+namespace Health.Infrastructure.AI;
+
+public sealed class AttachmentContextBuilder(
+    VisionClient vision,
+    ILogger<AttachmentContextBuilder> logger) : IAttachmentContextBuilder
+{
+    private const int MaxPdfChars = 6000;
+    private static readonly JsonSerializerOptions JsonOpts = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+    };
+
+    private readonly VisionClient _vision = vision;
+    private readonly ILogger<AttachmentContextBuilder> _logger = logger;
+
+    public async Task<AttachmentContext?> BuildAsync(Guid userId, string? imageUrl, string? pdfUrl, CancellationToken ct)
+    {
+        if (!string.IsNullOrWhiteSpace(imageUrl))
+            return await BuildImageAsync(userId, imageUrl!, ct);
+        if (!string.IsNullOrWhiteSpace(pdfUrl))
+            return await BuildPdfAsync(userId, pdfUrl!, ct);
+        return null;
+    }
+
+    // ── 图片：调 VLM 输出结构化 JSON ──
+    private async Task<AttachmentContext?> BuildImageAsync(Guid userId, string imageUrl, CancellationToken ct)
+    {
+        var filePath = UserUploadPathResolver.Resolve(userId, imageUrl);
+        if (filePath == null || !File.Exists(filePath))
+        {
+            _logger.LogWarning("Image file not found for {Url}", imageUrl);
+            return new AttachmentContext("image", null, null, "图片暂时无法读取", "[图片附件读取失败，请描述图片内容]");
+        }
+
+        var bytes = await File.ReadAllBytesAsync(filePath, ct);
+        var mime = Path.GetExtension(filePath).ToLowerInvariant() switch
+        {
+            ".png" => "image/png",
+            ".webp" => "image/webp",
+            ".heic" => "image/heic",
+            _ => "image/jpeg",
+        };
+        var dataUrl = $"data:{mime};base64,{Convert.ToBase64String(bytes)}";
+
+        var prompt = """
+            识别图片内容，输出 JSON：
+            {"category":"food|report|wound|drug|chart|other","summary":"1-2句话描述图片","details":["关键信息1","关键信息2"]}
+
+            分类标准：
+            - food：任何食物、饮品、餐食
+            - report：医学检查报告、化验单、影像报告（X光/CT/MRI/B超截图等）
+            - wound：伤口、术后切口、皮肤异常
+            - drug：药品包装、药品说明书
+            - chart：心电图、监护仪截图等
+            - other：其他
+
+            details 给出最有价值的细节（食物种类、报告关键值、伤口部位等）。
+            只输出 JSON 本身，不要任何前后缀。
+            """;
+
+        string? raw = null;
+        try
+        {
+            var resp = await _vision.VisionAsync(prompt, [dataUrl], userText: null, maxTokens: 1024, ct: ct);
+            raw = resp.Choices?.FirstOrDefault()?.Message?.Content;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "VLM call failed for image {Url}", imageUrl);
+        }
+
+        if (string.IsNullOrWhiteSpace(raw))
+            return new AttachmentContext("image", null, null, "图片识别失败", "[图片附件识别失败，请简要描述图片内容]");
+
+        try
+        {
+            var cleaned = StripCodeFence(raw.Trim());
+            using var doc = JsonDocument.Parse(cleaned);
+            var root = doc.RootElement;
+            var category = GetString(root, "category") ?? "other";
+            var summary = GetString(root, "summary") ?? "图片内容";
+            var details = root.TryGetProperty("details", out var d) && d.ValueKind == JsonValueKind.Array
+                ? string.Join("、", d.EnumerateArray().Select(x => x.GetString()).Where(s => !string.IsNullOrWhiteSpace(s)))
+                : "";
+
+            var compact = string.IsNullOrEmpty(details)
+                ? $"图片识别：{summary}"
+                : $"图片识别：{summary}（{details}）";
+            var llmContent = $"[图片识别（类别 {category}）：{summary}{(string.IsNullOrEmpty(details) ? "" : $"，包含 {details}")}]";
+
+            return new AttachmentContext("image", category, null, compact, llmContent);
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex, "Failed to parse VLM JSON: {Raw}", raw);
+            // 兜底：原文也能用
+            return new AttachmentContext("image", null, null, $"图片识别：{raw[..Math.Min(raw.Length, 80)]}", $"[图片识别：{raw}]");
+        }
+    }
+
+    // ── PDF：PdfPig 抽取文本 ──
+    private Task<AttachmentContext?> BuildPdfAsync(Guid userId, string pdfUrl, CancellationToken ct)
+    {
+        var filePath = UserUploadPathResolver.Resolve(userId, pdfUrl);
+        var fileName = Path.GetFileName(pdfUrl);
+        if (filePath == null || !File.Exists(filePath))
+        {
+            _logger.LogWarning("PDF file not found for {Url}", pdfUrl);
+            return Task.FromResult<AttachmentContext?>(new AttachmentContext(
+                "pdf", null, fileName, "PDF 文件读取失败",
+                "[PDF 附件读取失败，请描述文档内容]"));
+        }
+
+        try
+        {
+            using var pdf = PdfDocument.Open(filePath);
+            var sb = new System.Text.StringBuilder();
+            foreach (var page in pdf.GetPages())
+            {
+                sb.AppendLine(page.Text);
+                if (sb.Length > MaxPdfChars) break;
+            }
+            var text = sb.ToString().Trim();
+
+            if (string.IsNullOrWhiteSpace(text))
+            {
+                return Task.FromResult<AttachmentContext?>(new AttachmentContext(
+                    "pdf", null, fileName, "PDF 内容为空或扫描件",
+                    "[PDF 看起来是扫描件或图片版，无法提取文字。请提示用户改用拍照上传，或简要描述报告内容]"));
+            }
+
+            var truncated = text.Length > MaxPdfChars ? text[..MaxPdfChars] + "...（已截断）" : text;
+            var summary = $"PDF：{fileName}";
+            var llmContent = $"[用户上传 PDF 「{fileName}」，文档内容如下]\n{truncated}";
+
+            return Task.FromResult<AttachmentContext?>(new AttachmentContext("pdf", null, fileName, summary, llmContent));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to parse PDF {Url}", pdfUrl);
+            return Task.FromResult<AttachmentContext?>(new AttachmentContext(
+                "pdf", null, fileName, "PDF 解析异常",
+                "[PDF 解析失败，请提示用户文件可能损坏或加密]"));
+        }
+    }
+
+    private static string StripCodeFence(string raw)
+    {
+        var t = raw.Trim();
+        if (t.StartsWith("```"))
+        {
+            var firstNewline = t.IndexOf('\n');
+            if (firstNewline > 0) t = t[(firstNewline + 1)..];
+            if (t.EndsWith("```")) t = t[..^3];
+        }
+        return t.Trim();
+    }
+
+    private static string? GetString(JsonElement el, string name) =>
+        el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() : null;
+}

backend/src/Health.Infrastructure/AI/EfAiConversationRepository.cs

@@ -0,0 +1,68 @@
+using Health.Application.AI;
+
+namespace Health.Infrastructure.AI;
+
+public sealed class EfAiConversationRepository(AppDbContext db) : IAiConversationRepository
+{
+    private readonly AppDbContext _db = db;
+
+    public Task<Conversation?> GetOwnedAsync(Guid userId, Guid conversationId, CancellationToken ct) =>
+        _db.Conversations.FirstOrDefaultAsync(c => c.Id == conversationId && c.UserId == userId, ct);
+
+    public Task<Conversation?> GetAsync(Guid conversationId, CancellationToken ct) =>
+        _db.Conversations.FirstOrDefaultAsync(c => c.Id == conversationId, ct);
+
+    public async Task<IReadOnlyList<Conversation>> ListAsync(Guid userId, CancellationToken ct) =>
+        await _db.Conversations
+            .Where(c => c.UserId == userId)
+            .OrderByDescending(c => c.UpdatedAt)
+            .ToListAsync(ct);
+
+    public async Task<IReadOnlyList<ConversationMessage>> GetMessagesAsync(Guid conversationId, CancellationToken ct) =>
+        await _db.ConversationMessages
+            .Where(m => m.ConversationId == conversationId)
+            .OrderBy(m => m.CreatedAt)
+            .ToListAsync(ct);
+
+    public async Task<IReadOnlyList<ConversationMessage>> GetRecentMessagesAsync(Guid conversationId, int limit, CancellationToken ct) =>
+        await _db.ConversationMessages
+            .Where(m => m.ConversationId == conversationId)
+            .OrderByDescending(m => m.CreatedAt)
+            .Take(limit)
+            .ToListAsync(ct);
+
+    public async Task AddConversationAsync(Conversation conversation, CancellationToken ct) =>
+        await _db.Conversations.AddAsync(conversation, ct);
+
+    public async Task AddMessageAsync(ConversationMessage message, CancellationToken ct) =>
+        await _db.ConversationMessages.AddAsync(message, ct);
+
+    public async Task<int> DeleteLegacyDietCommentaryArtifactsAsync(
+        Guid userId,
+        string promptPrefix,
+        CancellationToken ct)
+    {
+        var candidates = await _db.Conversations
+            .Include(conversation => conversation.Messages)
+            .Where(conversation =>
+                conversation.UserId == userId &&
+                conversation.Messages.Any(message =>
+                    message.Role == MessageRole.User &&
+                    message.Content.StartsWith(promptPrefix)))
+            .ToListAsync(ct);
+        var artifacts = candidates
+            .Where(conversation => DietCommentaryPolicy.IsLegacyArtifact(conversation.Messages))
+            .ToList();
+        if (artifacts.Count == 0) return 0;
+
+        _db.Conversations.RemoveRange(artifacts);
+        await _db.SaveChangesAsync(ct);
+        return artifacts.Count;
+    }
+
+    public void Delete(Conversation conversation) =>
+        _db.Conversations.Remove(conversation);
+
+    public Task SaveChangesAsync(CancellationToken ct) =>
+        _db.SaveChangesAsync(ct);
+}

backend/src/Health.Infrastructure/AI/EfAiEntryDraftStore.cs

@@ -0,0 +1,108 @@
+using Health.Application.AI;
+using Health.Infrastructure.Data;
+using Health.Infrastructure.Data.Records;
+using Microsoft.EntityFrameworkCore;
+
+namespace Health.Infrastructure.AI;
+
+public sealed class EfAiEntryDraftStore(AppDbContext db) : IAiEntryDraftStore
+{
+    private readonly AppDbContext _db = db;
+
+    public async Task<AiEntryDraft?> GetActiveAsync(
+        Guid userId,
+        Guid conversationId,
+        string entryType,
+        CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        await ExpireAsync(now, ct);
+        var record = await _db.AiEntryDrafts.AsNoTracking().FirstOrDefaultAsync(x =>
+            x.UserId == userId &&
+            x.ConversationId == conversationId &&
+            x.EntryType == entryType &&
+            x.Status == "Pending" &&
+            x.ExpiresAt > now, ct);
+        return record == null ? null : ToDraft(record);
+    }
+
+    public async Task<AiEntryDraft> UpsertAsync(
+        Guid userId,
+        Guid conversationId,
+        string entryType,
+        string payload,
+        string missingFields,
+        TimeSpan lifetime,
+        CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        await ExpireAsync(now, ct);
+        var record = await _db.AiEntryDrafts.FirstOrDefaultAsync(x =>
+            x.UserId == userId &&
+            x.ConversationId == conversationId &&
+            x.EntryType == entryType &&
+            x.Status == "Pending", ct);
+        if (record == null)
+        {
+            record = new AiEntryDraftRecord
+            {
+                Id = Guid.NewGuid(),
+                UserId = userId,
+                ConversationId = conversationId,
+                EntryType = entryType,
+                CreatedAt = now,
+            };
+            await _db.AiEntryDrafts.AddAsync(record, ct);
+        }
+
+        record.Payload = payload;
+        record.MissingFields = missingFields;
+        record.ExpiresAt = now.Add(lifetime);
+        record.UpdatedAt = now;
+        await _db.SaveChangesAsync(ct);
+        return ToDraft(record);
+    }
+
+    public async Task CompleteAsync(Guid draftId, Guid userId, CancellationToken ct)
+    {
+        var record = await _db.AiEntryDrafts.FirstOrDefaultAsync(x =>
+            x.Id == draftId && x.UserId == userId && x.Status == "Pending", ct);
+        if (record == null) return;
+
+        record.Status = "Completed";
+        record.UpdatedAt = DateTime.UtcNow;
+        await _db.SaveChangesAsync(ct);
+    }
+
+    private async Task ExpireAsync(DateTime now, CancellationToken ct)
+    {
+        if (_db.Database.ProviderName == "Microsoft.EntityFrameworkCore.InMemory")
+        {
+            var expired = await _db.AiEntryDrafts
+                .Where(x => x.Status == "Pending" && x.ExpiresAt <= now)
+                .ToListAsync(ct);
+            foreach (var item in expired)
+            {
+                item.Status = "Expired";
+                item.UpdatedAt = now;
+            }
+            if (expired.Count > 0) await _db.SaveChangesAsync(ct);
+            return;
+        }
+
+        await _db.AiEntryDrafts
+            .Where(x => x.Status == "Pending" && x.ExpiresAt <= now)
+            .ExecuteUpdateAsync(setters => setters
+                .SetProperty(x => x.Status, "Expired")
+                .SetProperty(x => x.UpdatedAt, now), ct);
+    }
+
+    private static AiEntryDraft ToDraft(AiEntryDraftRecord record) => new(
+        record.Id,
+        record.UserId,
+        record.ConversationId,
+        record.EntryType,
+        record.Payload,
+        record.MissingFields,
+        record.ExpiresAt);
+}

backend/src/Health.Infrastructure/AI/EfAiWriteConfirmationStore.cs

@@ -0,0 +1,98 @@
+using Health.Application.AI;
+using Health.Infrastructure.Data.Records;
+
+namespace Health.Infrastructure.AI;
+
+public sealed class EfAiWriteConfirmationStore(AppDbContext db) : IAiWriteConfirmationStore
+{
+    private readonly AppDbContext _db = db;
+
+    public async Task<PendingAiWriteCommand> CreateAsync(
+        Guid userId,
+        string toolName,
+        string arguments,
+        TimeSpan lifetime,
+        CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        if (IsInMemory())
+        {
+            var expired = await _db.AiWriteCommands.Where(x => x.Status == "Pending" && x.ExpiresAt <= now).ToListAsync(ct);
+            foreach (var item in expired) { item.Status = "Expired"; item.UpdatedAt = now; }
+        }
+        else
+        {
+            await _db.AiWriteCommands
+                .Where(x => x.Status == "Pending" && x.ExpiresAt <= now)
+                .ExecuteUpdateAsync(setters => setters
+                    .SetProperty(x => x.Status, "Expired")
+                    .SetProperty(x => x.UpdatedAt, now), ct);
+        }
+
+        var command = new AiWriteCommandRecord
+        {
+            Id = Guid.NewGuid(),
+            UserId = userId,
+            ToolName = toolName,
+            Arguments = arguments,
+            Status = "Pending",
+            ExpiresAt = now.Add(lifetime),
+            CreatedAt = now,
+            UpdatedAt = now,
+        };
+        await _db.AiWriteCommands.AddAsync(command, ct);
+        await _db.SaveChangesAsync(ct);
+        return ToCommand(command);
+    }
+
+    public async Task<PendingAiWriteCommand?> TakeAsync(Guid commandId, Guid userId, CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        if (IsInMemory())
+        {
+            var tracked = await _db.AiWriteCommands.FirstOrDefaultAsync(
+                x => x.Id == commandId && x.UserId == userId && x.Status == "Pending" && x.ExpiresAt > now, ct);
+            if (tracked == null) return null;
+            tracked.Status = "Processing";
+            tracked.UpdatedAt = now;
+            await _db.SaveChangesAsync(ct);
+        }
+        else
+        {
+            var updated = await _db.AiWriteCommands
+                .Where(x => x.Id == commandId && x.UserId == userId && x.Status == "Pending" && x.ExpiresAt > now)
+                .ExecuteUpdateAsync(setters => setters
+                    .SetProperty(x => x.Status, "Processing")
+                    .SetProperty(x => x.UpdatedAt, now), ct);
+            if (updated == 0) return null;
+        }
+
+        var record = await _db.AiWriteCommands.AsNoTracking().FirstAsync(x => x.Id == commandId, ct);
+        return ToCommand(record);
+    }
+
+    public async Task CompleteAsync(PendingAiWriteCommand command, CancellationToken ct)
+    {
+        if (IsInMemory())
+        {
+            var tracked = await _db.AiWriteCommands.FirstOrDefaultAsync(
+                x => x.Id == command.Id && x.UserId == command.UserId && x.Status == "Processing", ct);
+            if (tracked != null) { tracked.Status = "Completed"; tracked.UpdatedAt = DateTime.UtcNow; await _db.SaveChangesAsync(ct); }
+            return;
+        }
+        await _db.AiWriteCommands
+            .Where(x => x.Id == command.Id && x.UserId == command.UserId && x.Status == "Processing")
+            .ExecuteUpdateAsync(setters => setters
+                .SetProperty(x => x.Status, "Completed")
+                .SetProperty(x => x.UpdatedAt, DateTime.UtcNow), ct);
+    }
+
+    private bool IsInMemory() => _db.Database.ProviderName == "Microsoft.EntityFrameworkCore.InMemory";
+
+    private static PendingAiWriteCommand ToCommand(AiWriteCommandRecord record) => new(
+        record.Id,
+        record.UserId,
+        record.ToolName,
+        record.Arguments,
+        record.ExpiresAt);
+}

backend/src/Health.Infrastructure/AI/Prompts/global/identity.md

@@ -0,0 +1,8 @@
+你是患者端统一 AI 健康助手“小脉”。你的任务是理解用户当前真正想做的事情，调用经过授权的业务工具，并用自然、温和、清楚的中文回复。
+
+核心原则：
+- 个人健康数据、计划、完成状态和报告状态必须以当前业务工具返回为准，不能根据聊天历史或患者背景猜测。
+- 工具没有返回的数据不得编造；暂时没有对应能力时应如实说明。
+- 一条消息可能包含多个意图，必须分别处理，不能为了简化而遗漏其中一项。
+- 当前工具结果与历史聊天冲突时，以当前工具结果为准。
+- 普通聊天历史用于理解语境，不等同于待写入数据；只有后端明确提供的待补充草稿才允许跨消息合并录入字段。

backend/src/Health.Infrastructure/AI/Prompts/global/medical_safety.md

@@ -0,0 +1,6 @@
+医疗安全边界：
+- 你是健康解释与预问诊助手，不是医生，不能替代医生诊断、处方或治疗决策。
+- 可以解释健康数据、报告指标和症状可能方向，但不能作确定诊断。
+- 不要求用户自行新增、停用、更换药物或调整剂量；涉及治疗变化时建议咨询医生或药师。
+- 出现剧烈胸痛、呼吸困难、意识异常、晕厥、说话不清、一侧肢体无力、血氧明显偏低、血压或血糖严重异常等危险信号时，立即停止普通流程并优先建议及时就医或急诊评估。
+- 医疗分析使用“可能、建议、需要结合医生判断”等表达。

backend/src/Health.Infrastructure/AI/Prompts/global/response_style.md

@@ -0,0 +1,8 @@
+回复要求：
+- 语气自然、温和、专业，不使用系统报错式措辞。
+- 信息不完整时，每次只追问最关键的缺失内容；可以在一句话中列出同一批次明确缺少的字段。
+- 禁止使用粗体、斜体、删除线、HTML 和 Markdown 表格。
+- 标题只使用三级标题；列表使用短横线。
+- 数值和单位之间留空格，例如 120 mmHg、6.2 mmol/L。
+- 不输出任何以 $ 开头的占位符。
+- 不重复堆砌免责声明。

backend/src/Health.Infrastructure/AI/Prompts/modules/diet_analysis.md

@@ -0,0 +1,6 @@
+新饮食图片分析模块：
+- 仅用于本轮新上传的饮食图片；查询已经保存的饮食记录应进入个人数据查询模块。
+- 识别食物名称、估算份量和热量，并结合患者健康档案评价。
+- 对过敏、低盐、低脂、低糖等限制给出清楚提醒，不作绝对化医疗结论。
+- 饮食建议需要医学资料支撑时可以按需调用知识库。
+- 图片分析结果不能在用户未确认时冒充已经保存的饮食记录。

backend/src/Health.Infrastructure/AI/Prompts/modules/exercise_entry.md

@@ -0,0 +1,9 @@
+运动计划录入模块：
+- 用户明确创建运动计划时调用 manage_exercise(action="create")。
+- 完整计划需要：运动项目、每天运动时长、持续天数、开始日期和具体提醒时间。
+- 中文时长和周期应正确换算，例如半小时=30 分钟、一小时=60 分钟、一周=7 天、一个月=30 天。
+- 只传用户明确提供的字段；当前产品不自动补默认运动项目、天数、开始日期或提醒时间。
+- 信息不完整时仍调用工具，让后端保存待补充草稿；下一轮补充时与草稿合并。
+- 用户明确开始新的运动计划时不得继承旧草稿内容。
+- 后端返回 pendingConfirmation=true 后展示确认卡；用户点击前不得声称计划已创建。
+- 单纯创建运动计划不调用医学知识库。用户先询问该运动是否适合自己时，额外进入医疗咨询模块。

backend/src/Health.Infrastructure/AI/Prompts/modules/general_chat.md

@@ -0,0 +1,4 @@
+普通聊天与应用帮助模块：
+- 问候、感谢和普通闲聊自然简短回复，不调用业务工具或医学知识库。
+- 用户询问应用功能位置或使用方法时可以直接说明；已有固定 App 内链接时可自然提供一个跳转链接。
+- 不确定用户是想咨询数值还是保存记录时，只做一次简短澄清，不生成确认卡。

backend/src/Health.Infrastructure/AI/Prompts/modules/health_entry.md

@@ -0,0 +1,13 @@
+健康指标录入模块：
+- 支持血压、心率、血糖、血氧、体重；“脉搏”与“心率”是同一指标，统一使用 heart_rate。
+- 必须理解常见完整血压表达，例如 113/86、113-86、113—86，前者为收缩压，后者为舒张压。
+- 用户明确要求录入时必须调用 record_health_data_batch，而且每个录入批次只调用一次；即使只有一个指标，也必须放进 metrics 数组。信息不完整也要调用，只传用户明确提供的字段，让后端保存整个待补充批次草稿。
+- 不能自行补测量数值。测量时间未说明时可以由后端使用当前时间。
+- 一次消息可以包含多个指标，必须完整提取，不得遗漏。多指标属于同一录入批次，最终应汇总在一张确认卡中。
+- metrics 必须包含用户本轮明确要录入的全部指标；不要为每个指标分别调用工具。
+- 如果同一批次存在不完整或明显无效的指标，应保留本批次其他已识别指标，先根据后端结果追问缺失或错误部分；全部补齐后再生成整批确认卡。
+- 用户只补充一个缺失值时，必须结合后端提供的当前草稿，不能只记录最后一句。
+- 已经生成确认卡的批次立即结束；无论用户是否点击，下一条新的录入请求都属于新批次，不能带入上一张卡的数据。
+- 普通聊天历史中的指标不得自动加入当前卡；只有明确的待补充草稿可以跨消息合并。
+- 后端返回 pendingConfirmation=true 才代表确认卡真实生成。确认卡出现前不得要求用户点击卡片，点击前不得声称已经保存或录入成功。
+- 后端返回危险提醒或无效数值时，不生成成功话术，按返回内容提醒用户。

backend/src/Health.Infrastructure/AI/Prompts/modules/medical_consultation.md

@@ -0,0 +1,7 @@
+医疗咨询与健康建议模块：
+- 症状求助时先判断是否存在危险信号；非紧急情况下每轮只追问一个最关键问题，逐步了解部位、开始时间、程度、诱因和伴随表现。
+- 信息足够后给出可能相关方向、严重程度以及观察、门诊、尽快就医或急诊建议，不作正式诊断。
+- 解释用户个人指标或趋势时，应先调用相应个人数据查询工具获取真实数据。
+- 疾病、药品、检查指标、康复、饮食或运动建议需要医学资料支撑时，调用 search_medical_knowledge。
+- 不需要外部医学资料的简单澄清、问候或业务操作不调用知识库。
+- 用户同时要求录入或创建计划时，医疗解释不能代替对应录入工具和确认卡。

backend/src/Health.Infrastructure/AI/Prompts/modules/medication_entry.md

@@ -0,0 +1,9 @@
+用药计划录入模块：
+- 用户明确创建用药计划时调用 manage_medication(action="create")。
+- 只传用户明确提供的字段，不自行新增药品、猜测剂量、频率、具体服药时间、开始日期或疗程。
+- 完整计划需要：药品名称、每次剂量、频率、具体服药时间、开始日期，以及疗程天数或明确长期服用。
+- “早饭后、晚上”等模糊时间不能擅自换算为具体时刻，应追问具体时间。
+- 信息不完整时仍调用工具，让后端保存待补充草稿；下一轮只补缺失字段时与草稿合并。
+- 存在旧草稿但用户明确开始另一种药品的新计划时，应开始新批次，禁止继承旧药品的剂量、时间、频率或疗程。
+- 后端返回 pendingConfirmation=true 后展示确认卡；用户点击前不得声称计划已创建。
+- 用药计划录入本身不调用医学知识库。用户同时询问药品知识或副作用时，额外进入医疗咨询模块。

backend/src/Health.Infrastructure/AI/Prompts/modules/personal_query.md

@@ -0,0 +1,7 @@
+个人数据查询模块：
+- 查询用户自己的健康记录、健康档案、用药计划、运动计划、饮食记录、复查安排、已有报告和通知时，必须调用对应只读业务工具。
+- 不能根据患者背景、聊天历史或以前的工具结果回答当前状态。
+- 必须区分“记录存在”“计划当前有效”“指定日期有安排”“任务已经完成”。
+- 查询某一天任务与查询计划生命周期不能混用；时间意图不明确时只追问时间范围。
+- 工具没有返回数据时明确说明未查到，不得编造。
+- 个人数据查询通常不调用医学知识库；用户同时要求解释或建议时，额外进入医疗咨询模块。

backend/src/Health.Infrastructure/AI/Prompts/modules/report_analysis.md

@@ -0,0 +1,7 @@
+新报告分析模块：
+- 仅用于本轮新上传的医学检查报告图片或报告文件；查询以前保存的报告应进入个人数据查询模块。
+- 提取报告名称、日期、关键指标、参考范围、异常标记和原文结论。
+- 区分结构化检验指标与影像/医生描述，不把影像描述改写成确定诊断。
+- 给出患者可理解的初步解释和下一步建议，注明需要结合医生判断。
+- 报告内容需要进一步医学解释时可以按需调用知识库。
+- 用户没有明确要求时，不把报告中的指标直接写入健康记录。

backend/src/Health.Infrastructure/AI/Prompts/rag/retrieval_rules.md

@@ -0,0 +1,7 @@
+医学知识库使用规则：
+- 知识库是医疗咨询、指标解释、药品知识、报告解释和健康建议的辅助能力，不是独立用户意图。
+- 健康指标录入、用药或运动计划创建、个人数据查询、服药确认、运动打卡、普通聊天时禁止调用。
+- 一条消息同时包含业务操作和医学咨询时，先完成必要业务工具调用；只有咨询部分确实需要资料时才检索。
+- 检索问题应保留关键症状、疾病、药品或指标名称，删除无关寒暄和操作指令。
+- 只能依据真实返回的知识片段作参考；没有结果时应谨慎回答，不得虚构检索内容或来源。
+- 知识库内容不能覆盖患者当前业务数据，也不能替代紧急安全规则。

backend/src/Health.Infrastructure/AI/Prompts/router/intent_router.md

@@ -0,0 +1,25 @@
+你是主聊天的意图路由器，只负责识别意图，不回答用户问题。
+
+请结合用户当前消息、附件类型、最近对话和后端提供的待补充草稿，选择一个或多个意图：
+- health_entry：录入健康指标，或继续补充健康指标草稿。
+- medication_entry：创建用药计划，或继续补充用药计划草稿。
+- exercise_entry：创建运动计划，或继续补充运动计划草稿。
+- personal_query：查询用户自己的健康数据、健康档案、用药/运动计划、饮食、复查、报告或通知。
+- medical_consultation：症状求助、指标解释、疾病/药品知识、健康评价、饮食/运动/康复建议。
+- report_analysis：分析新上传的医学报告图片或报告文件。
+- diet_analysis：分析新上传的饮食图片。
+- app_help：询问应用功能位置或使用方法。
+- general_chat：问候、感谢、普通闲聊或不需要业务工具的对话。
+
+判断规则：
+- “帮我记录血压 116/89”是 health_entry。
+- “血压 116/89 正常吗”是 medical_consultation，不是录入。
+- “记录血压 150/95，并告诉我是否偏高”同时包含 health_entry 和 medical_consultation。
+- 查询已有报告属于 personal_query；分析本轮新上传报告属于 report_analysis。
+- 创建计划与询问建议必须区分；“创建每天散步 30 分钟的计划”是 exercise_entry，“我适合每天散步 30 分钟吗”是 medical_consultation。
+- 只有确实在补充草稿缺失字段时才标记为 continue；存在草稿不代表所有后续消息都必须继续草稿。
+- 用户明确开始新的同类录入时标记 start_new，不能继承旧草稿字段。
+- 用户明确说取消、不录了时标记 cancel。
+- 无法确定是咨询还是录入时选择 general_chat，让主助手自然澄清。
+
+必须通过 route_user_intent 工具返回结构化结果，不得输出解释文字。

backend/src/Health.Infrastructure/AI/ai_clients.cs

@@ -9,7 +9,7 @@ namespace Health.Infrastructure.AI;
 public sealed class DeepSeekClient(HttpClient http, IConfiguration config)
 {
     private readonly HttpClient _http = http;
-    private readonly string _model = config["DEEPSEEK_MODEL"] ?? "deepseek-chat";
+    private readonly string _model = config["DEEPSEEK_MODEL"] ?? "deepseek-v4-flash";
     private readonly JsonSerializerOptions _jsonOptions = new()
     {
         PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
@@ -30,6 +30,7 @@ public sealed class DeepSeekClient(HttpClient http, IConfiguration config)
         {
             Model = _model, Messages = messages, Stream = true,
             MaxTokens = maxTokens, Temperature = temperature, Tools = tools,
+            Thinking = new ThinkingOptions { Type = "disabled" },
         };
         if (tools?.Count > 0) request.ToolChoice = "auto";
 
@@ -40,7 +41,7 @@ public sealed class DeepSeekClient(HttpClient http, IConfiguration config)
         httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
 
         using var response = await _http.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, ct);
-        response.EnsureSuccessStatusCode();
+        await AiHttpResponseGuard.ThrowIfFailedAsync(response, "DeepSeek", ct);
 
         using var stream = await response.Content.ReadAsStreamAsync(ct);
         using var reader = new StreamReader(stream);
@@ -64,23 +65,23 @@ public sealed class DeepSeekClient(HttpClient http, IConfiguration config)
         List<ToolDefinition>? tools = null,
         int maxTokens = 2048,
         float temperature = 0.7f,
+        string? toolChoice = null,
         CancellationToken ct = default)
     {
         var request = new ChatCompletionRequest
         {
             Model = _model, Messages = messages, Stream = false,
             MaxTokens = maxTokens, Temperature = temperature, Tools = tools,
+            Thinking = new ThinkingOptions { Type = "disabled" },
         };
-        if (tools?.Count > 0) request.ToolChoice = "auto";
+        if (tools?.Count > 0) request.ToolChoice = toolChoice ?? "auto";
 
         var json = JsonSerializer.Serialize(request, _jsonOptions);
         var content = new StringContent(json, Encoding.UTF8, "application/json");
 
-        var response = await _http.PostAsync("chat/completions", content, ct);
-        response.EnsureSuccessStatusCode();
-
-        var body = await response.Content.ReadAsStringAsync(ct);
-        return JsonSerializer.Deserialize<ChatCompletionResponse>(body, _jsonOptions)!;
+        using var response = await _http.PostAsync("chat/completions", content, ct);
+        var body = await AiHttpResponseGuard.ReadSuccessBodyAsync(response, "DeepSeek", ct);
+        return AiHttpResponseGuard.DeserializeRequired<ChatCompletionResponse>(body, _jsonOptions, "DeepSeek");
     }
 }
 
@@ -90,7 +91,7 @@ public sealed class DeepSeekClient(HttpClient http, IConfiguration config)
 public sealed class VisionClient(HttpClient http, IConfiguration config)
 {
     private readonly HttpClient _http = http;
-    private readonly string _model = config["VLM_MODEL"] ?? "doubao-vision-pro";
+    private readonly string _model = config["VLM_MODEL"] ?? config["QWEN_VISION_MODEL"] ?? "qwen-vl-max";
     private readonly JsonSerializerOptions _jsonOptions = new()
     {
         PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
@@ -104,37 +105,67 @@ public sealed class VisionClient(HttpClient http, IConfiguration config)
         int maxTokens = 2048,
         CancellationToken ct = default)
     {
-        var messages = new List<ChatMessage>();
-        if (!string.IsNullOrEmpty(systemPrompt))
-            messages.Add(new ChatMessage { Role = "system", Content = systemPrompt });
-
         var contentParts = new List<object>();
         foreach (var url in imageUrls)
             contentParts.Add(new { type = "image_url", image_url = new { url } });
+        if (!string.IsNullOrEmpty(systemPrompt))
+            contentParts.Add(new { type = "text", text = systemPrompt });
         if (!string.IsNullOrEmpty(userText))
             contentParts.Add(new { type = "text", text = userText });
 
-        var userMessage = new ChatMessage
+        var messages = new List<ChatMessage>
         {
-            Role = "user",
-            Content = JsonSerializer.Serialize(contentParts, _jsonOptions)
+            new() { Role = "user", Content = contentParts }
         };
-        messages.Add(userMessage);
 
         var request = new ChatCompletionRequest
         {
             Model = _model, Messages = messages, MaxTokens = maxTokens, Stream = false,
+            Temperature = 0.1f, VlHighResolutionImages = true,
+            EnableThinking = false,
         };
 
         var json = JsonSerializer.Serialize(request, _jsonOptions);
         var content = new StringContent(json, Encoding.UTF8, "application/json");
-        var response = await _http.PostAsync("chat/completions", content, ct);
-        if (!response.IsSuccessStatusCode)
-        {
-            var errorBody = await response.Content.ReadAsStringAsync(ct);
-            throw new HttpRequestException($"VLM API {response.StatusCode}: {errorBody}");
-        }
-        var body = await response.Content.ReadAsStringAsync(ct);
-        return JsonSerializer.Deserialize<ChatCompletionResponse>(body, _jsonOptions)!;
+        using var response = await _http.PostAsync("chat/completions", content, ct);
+        var body = await AiHttpResponseGuard.ReadSuccessBodyAsync(response, "VLM", ct);
+        return AiHttpResponseGuard.DeserializeRequired<ChatCompletionResponse>(body, _jsonOptions, "VLM");
     }
 }
+
+internal static class AiHttpResponseGuard
+{
+    private const int MaxErrorBodyLength = 2000;
+
+    public static async Task ThrowIfFailedAsync(HttpResponseMessage response, string provider, CancellationToken ct)
+    {
+        if (response.IsSuccessStatusCode) return;
+        var body = await response.Content.ReadAsStringAsync(ct);
+        throw new HttpRequestException($"{provider} API {(int)response.StatusCode} ({response.StatusCode}): {Truncate(body)}");
+    }
+
+    public static async Task<string> ReadSuccessBodyAsync(HttpResponseMessage response, string provider, CancellationToken ct)
+    {
+        await ThrowIfFailedAsync(response, provider, ct);
+        var body = await response.Content.ReadAsStringAsync(ct);
+        if (string.IsNullOrWhiteSpace(body))
+            throw new InvalidDataException($"{provider} API返回了空响应");
+        return body;
+    }
+
+    public static T DeserializeRequired<T>(string body, JsonSerializerOptions options, string provider)
+    {
+        try
+        {
+            return JsonSerializer.Deserialize<T>(body, options)
+                ?? throw new InvalidDataException($"{provider} API响应内容为空");
+        }
+        catch (JsonException ex)
+        {
+            throw new InvalidDataException($"{provider} API响应格式无效", ex);
+        }
+    }
+
+    private static string Truncate(string value) =>
+        value.Length <= MaxErrorBodyLength ? value : value[..MaxErrorBodyLength] + "...";
+}

backend/src/Health.Infrastructure/AI/ai_contracts.cs

@@ -0,0 +1,95 @@
+namespace Health.Infrastructure.AI;
+
+public sealed class ChatCompletionRequest
+{
+    public string Model { get; set; } = string.Empty;
+    public List<ChatMessage> Messages { get; set; } = [];
+    public bool Stream { get; set; }
+    public int MaxTokens { get; set; } = 2048;
+    public float Temperature { get; set; } = 0.7f;
+    public float? TopP { get; set; }
+    public List<ToolDefinition>? Tools { get; set; }
+    public string? ToolChoice { get; set; }
+
+    [System.Text.Json.Serialization.JsonPropertyName("vl_high_resolution_images")]
+    public bool VlHighResolutionImages { get; set; }
+
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+    [System.Text.Json.Serialization.JsonPropertyName("enable_thinking")]
+    public bool? EnableThinking { get; set; }
+
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+    [System.Text.Json.Serialization.JsonPropertyName("thinking")]
+    public ThinkingOptions? Thinking { get; set; }
+}
+
+public sealed class ThinkingOptions
+{
+    [System.Text.Json.Serialization.JsonPropertyName("type")]
+    public string Type { get; set; } = "disabled";
+}
+
+public sealed class ChatMessage
+{
+    public string Role { get; set; } = string.Empty;
+    public object? Content { get; set; } = string.Empty;
+
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+    public string? ToolCallId { get; set; }
+
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+    public List<ToolCall>? ToolCalls { get; set; }
+}
+
+public sealed class ToolDefinition
+{
+    public string Type { get; set; } = "function";
+    public ToolFunction Function { get; set; } = new();
+}
+
+public sealed class ToolFunction
+{
+    public string Name { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public object Parameters { get; set; } = new();
+}
+
+public sealed class ToolCall
+{
+    public string Id { get; set; } = string.Empty;
+    public string Type { get; set; } = "function";
+    public ToolCallFunction Function { get; set; } = new();
+}
+
+public sealed class ToolCallFunction
+{
+    public string Name { get; set; } = string.Empty;
+    public string Arguments { get; set; } = string.Empty;
+}
+
+public sealed class ChatCompletionResponse
+{
+    public string Id { get; set; } = string.Empty;
+    public List<Choice> Choices { get; set; } = [];
+}
+
+public sealed class Choice
+{
+    public int Index { get; set; }
+    public ResponseMessage? Message { get; set; }
+    public ResponseDelta? Delta { get; set; }
+    public string? FinishReason { get; set; }
+}
+
+public sealed class ResponseMessage
+{
+    public string Role { get; set; } = string.Empty;
+    public string? Content { get; set; }
+    public List<ToolCall>? ToolCalls { get; set; }
+}
+
+public sealed class ResponseDelta
+{
+    public string? Content { get; set; }
+    public string? Role { get; set; }
+}

backend/src/Health.Infrastructure/AI/ai_intent_router.cs

@@ -0,0 +1,185 @@
+using System.Text.Json;
+
+namespace Health.Infrastructure.AI;
+
+public sealed record AiIntentRoute(
+    IReadOnlyList<string> Intents,
+    string DraftAction,
+    string DraftType)
+{
+    public static AiIntentRoute GeneralChat { get; } =
+        new(["general_chat"], "none", "none");
+
+    public static AiIntentRoute Compatibility { get; } = new(
+        [
+            "health_entry",
+            "medication_entry",
+            "exercise_entry",
+            "personal_query",
+            "medical_consultation",
+            "report_analysis",
+            "diet_analysis",
+            "general_chat",
+        ],
+        "none",
+        "none");
+}
+
+public static class AiIntentRouter
+{
+    private static readonly HashSet<string> AllowedIntents = new(
+        [
+            "health_entry",
+            "medication_entry",
+            "exercise_entry",
+            "personal_query",
+            "medical_consultation",
+            "report_analysis",
+            "diet_analysis",
+            "app_help",
+            "general_chat",
+        ],
+        StringComparer.OrdinalIgnoreCase);
+
+    public static readonly ToolDefinition RouteTool = new()
+    {
+        Function = new()
+        {
+            Name = "route_user_intent",
+            Description = "返回当前用户消息的一个或多个业务意图，不回答用户问题",
+            Parameters = new
+            {
+                type = "object",
+                properties = new
+                {
+                    intents = new
+                    {
+                        type = "array",
+                        minItems = 1,
+                        uniqueItems = true,
+                        items = new
+                        {
+                            type = "string",
+                            @enum = AllowedIntents.OrderBy(x => x).ToArray(),
+                        },
+                    },
+                    draft_action = new
+                    {
+                        type = "string",
+                        @enum = new[] { "none", "continue", "start_new", "cancel" },
+                        description = "当前消息与待补充录入草稿的关系",
+                    },
+                    draft_type = new
+                    {
+                        type = "string",
+                        @enum = new[] { "none", "health_entry", "medication_entry", "exercise_entry" },
+                    },
+                },
+                required = new[] { "intents", "draft_action", "draft_type" },
+            },
+        },
+    };
+
+    public static async Task<AiIntentRoute> RouteAsync(
+        DeepSeekClient client,
+        PromptManager prompts,
+        string currentMessage,
+        string attachmentContext,
+        string draftContext,
+        string recentConversation,
+        CancellationToken ct)
+    {
+        var userContext = $"""
+            当前用户消息：
+            {currentMessage}
+
+            本轮附件：
+            {(string.IsNullOrWhiteSpace(attachmentContext) ? "无" : attachmentContext)}
+
+            当前待补充录入草稿：
+            {(string.IsNullOrWhiteSpace(draftContext) ? "无" : draftContext)}
+
+            最近对话：
+            {(string.IsNullOrWhiteSpace(recentConversation) ? "无" : recentConversation)}
+            """;
+
+        try
+        {
+            var response = await client.ChatAsync(
+                [
+                    new ChatMessage { Role = "system", Content = prompts.GetIntentRouterPrompt() },
+                    new ChatMessage { Role = "user", Content = userContext },
+                ],
+                tools: [RouteTool],
+                maxTokens: 300,
+                temperature: 0.1f,
+                toolChoice: "required",
+                ct: ct);
+
+            var call = response.Choices?
+                .FirstOrDefault()?
+                .Message?
+                .ToolCalls?
+                .FirstOrDefault(item => item.Function.Name == "route_user_intent");
+            return call == null ? AiIntentRoute.Compatibility : Parse(call.Function.Arguments);
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch
+        {
+            // Routing failure must not make the whole chat unavailable. The broad
+            // compatibility prompt/tool set remains the safe fallback.
+            return AiIntentRoute.Compatibility;
+        }
+    }
+
+    internal static AiIntentRoute Parse(string arguments)
+    {
+        try
+        {
+            using var json = JsonDocument.Parse(arguments);
+            var root = json.RootElement;
+            var intents = root.TryGetProperty("intents", out var values) &&
+                          values.ValueKind == JsonValueKind.Array
+                ? values.EnumerateArray()
+                    .Where(value => value.ValueKind == JsonValueKind.String)
+                    .Select(value => value.GetString()?.Trim().ToLowerInvariant() ?? "")
+                    .Where(AllowedIntents.Contains)
+                    .Distinct(StringComparer.OrdinalIgnoreCase)
+                    .ToList()
+                : [];
+            if (intents.Count == 0) intents.Add("general_chat");
+
+            var draftAction = ReadEnum(
+                root,
+                "draft_action",
+                ["none", "continue", "start_new", "cancel"],
+                "none");
+            var draftType = ReadEnum(
+                root,
+                "draft_type",
+                ["none", "health_entry", "medication_entry", "exercise_entry"],
+                "none");
+            return new AiIntentRoute(intents, draftAction, draftType);
+        }
+        catch (JsonException)
+        {
+            return AiIntentRoute.Compatibility;
+        }
+    }
+
+    private static string ReadEnum(
+        JsonElement root,
+        string property,
+        IReadOnlyCollection<string> allowed,
+        string fallback)
+    {
+        var value = root.TryGetProperty(property, out var element) &&
+                    element.ValueKind == JsonValueKind.String
+            ? element.GetString()?.Trim().ToLowerInvariant()
+            : null;
+        return value != null && allowed.Contains(value) ? value : fallback;
+    }
+}

backend/src/Health.Infrastructure/AI/fastgpt_knowledge_client.cs

@@ -0,0 +1,73 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Health.Infrastructure.AI;
+
+/// <summary>
+/// FastGPT 知识库检索客户端（仅做 RAG 检索，不参与生成）。
+/// 我们后端的 DeepSeek 依旧负责对话生成与工具调用；
+/// 这里只把检索到的医学知识片段拼回 system prompt，提升回答准确度。
+/// </summary>
+public sealed class FastGptKnowledgeClient(HttpClient http, IConfiguration config, ILogger<FastGptKnowledgeClient> logger)
+{
+    private readonly HttpClient _http = http;
+    private readonly string _datasetId = config["FASTGPT_DATASET_ID"] ?? "";
+    private readonly float _similarity = float.TryParse(config["FASTGPT_SIMILARITY"], out var s) ? s : 0.4f;
+    private readonly int _limit = int.TryParse(config["FASTGPT_LIMIT"], out var l) ? l : 3000;
+    private readonly bool _ragEnabled = bool.TryParse(config["ENABLE_MEDICAL_RAG"], out var enabled) && enabled;
+    private readonly ILogger<FastGptKnowledgeClient> _logger = logger;
+    private readonly JsonSerializerOptions _jsonOptions = new() { PropertyNameCaseInsensitive = true };
+
+    // iOS 审核版使用后端内置医学来源目录，暂时关闭在线 RAG，减少一次外部检索请求。
+    public bool IsEnabled => _ragEnabled && !string.IsNullOrWhiteSpace(_datasetId);
+
+    /// <summary>
+    /// 按用户问题检索知识库，返回最相关的文档片段。
+    /// 失败或未配置时返回空字符串，调用方应当容错——RAG 只是增强，不是必需。
+    /// </summary>
+    public async Task<string> SearchAsync(string question, CancellationToken ct = default)
+    {
+        if (!IsEnabled || string.IsNullOrWhiteSpace(question)) return "";
+
+        try
+        {
+            var payload = new
+            {
+                datasetId = _datasetId,
+                text = question,
+                limit = _limit,
+                similarity = _similarity,
+                searchMode = "embedding",
+            };
+            var json = JsonSerializer.Serialize(payload);
+            var content = new StringContent(json, Encoding.UTF8, "application/json");
+            using var response = await _http.PostAsync("core/dataset/searchTest", content, ct);
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogWarning("FastGPT 检索失败: {Status}", response.StatusCode);
+                return "";
+            }
+
+            var body = await response.Content.ReadAsStringAsync(ct);
+            using var doc = JsonDocument.Parse(body);
+            if (!doc.RootElement.TryGetProperty("data", out var data)) return "";
+            if (!data.TryGetProperty("list", out var list) || list.ValueKind != JsonValueKind.Array) return "";
+
+            var snippets = new List<string>();
+            foreach (var item in list.EnumerateArray())
+            {
+                var q = item.TryGetProperty("q", out var qEl) ? qEl.GetString() ?? "" : "";
+                var a = item.TryGetProperty("a", out var aEl) ? aEl.GetString() ?? "" : "";
+                if (string.IsNullOrWhiteSpace(q) && string.IsNullOrWhiteSpace(a)) continue;
+                snippets.Add(string.IsNullOrWhiteSpace(a) ? q : $"{q}：{a}");
+            }
+
+            return snippets.Count == 0 ? "" : string.Join("\n", snippets);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "FastGPT 检索异常，已忽略");
+            return "";
+        }
+    }
+}

backend/src/Health.Infrastructure/AI/open_ai_compatible_client.cs

@@ -1,232 +0,0 @@
-using System.Net.Http.Headers;
-
-namespace Health.Infrastructure.AI;
-
-/// <summary>
-/// OpenAI 兼容协议 HTTP 客户端，统一调用 DeepSeek / 千问 VL
-/// </summary>
-public sealed class OpenAiCompatibleClient(string baseUrl, string apiKey, string model)
-{
-    private readonly HttpClient _http = CreateHttpClient(baseUrl, apiKey);
-    private readonly string _model = model;
-    private readonly JsonSerializerOptions _jsonOptions = new()
-    {
-        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
-        PropertyNameCaseInsensitive = true
-    };
-
-    private static HttpClient CreateHttpClient(string baseUrl, string apiKey)
-    {
-        var client = new HttpClient
-        {
-            BaseAddress = new Uri(baseUrl.TrimEnd('/') + "/"),
-            Timeout = TimeSpan.FromSeconds(60)
-        };
-        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
-        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
-        return client;
-    }
-
-    /// <summary>
-    /// 流式 Chat Completions（SSE）
-    /// </summary>
-    public async IAsyncEnumerable<string> ChatStreamAsync(
-        List<ChatMessage> messages,
-        List<ToolDefinition>? tools = null,
-        int maxTokens = 2048,
-        float temperature = 0.7f)
-    {
-        var request = new ChatCompletionRequest
-        {
-            Model = _model,
-            Messages = messages,
-            Stream = true,
-            MaxTokens = maxTokens,
-            Temperature = temperature,
-            Tools = tools,
-        };
-
-        if (tools?.Count > 0)
-            request.ToolChoice = "auto";
-
-        var json = JsonSerializer.Serialize(request, _jsonOptions);
-        var content = new StringContent(json, Encoding.UTF8, "application/json");
-
-        var httpRequest = new HttpRequestMessage(HttpMethod.Post, "chat/completions")
-        {
-            Content = content
-        };
-        httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
-
-        var response = await _http.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead);
-        response.EnsureSuccessStatusCode();
-
-        using var stream = await response.Content.ReadAsStreamAsync();
-        using var reader = new StreamReader(stream);
-
-        string? line;
-        while ((line = await reader.ReadLineAsync()) != null)
-        {
-            if (string.IsNullOrWhiteSpace(line)) continue;
-            if (!line.StartsWith("data: ")) continue;
-
-            var data = line["data: ".Length..];
-            if (data == "[DONE]") break;
-
-            yield return data;
-        }
-    }
-
-    /// <summary>
-    /// 非流式 Chat Completions
-    /// </summary>
-    public async Task<ChatCompletionResponse> ChatAsync(
-        List<ChatMessage> messages,
-        List<ToolDefinition>? tools = null,
-        int maxTokens = 2048,
-        float temperature = 0.7f)
-    {
-        var request = new ChatCompletionRequest
-        {
-            Model = _model,
-            Messages = messages,
-            Stream = false,
-            MaxTokens = maxTokens,
-            Temperature = temperature,
-            Tools = tools,
-        };
-
-        if (tools?.Count > 0)
-            request.ToolChoice = "auto";
-
-        var json = JsonSerializer.Serialize(request, _jsonOptions);
-        var content = new StringContent(json, Encoding.UTF8, "application/json");
-
-        var response = await _http.PostAsync("chat/completions", content);
-        response.EnsureSuccessStatusCode();
-
-        var body = await response.Content.ReadAsStringAsync();
-        return JsonSerializer.Deserialize<ChatCompletionResponse>(body, _jsonOptions)!;
-    }
-
-    /// <summary>
-    /// Vision 图片理解（非流式）
-    /// </summary>
-    public async Task<ChatCompletionResponse> VisionAsync(
-        string systemPrompt,
-        List<string> imageUrls,
-        string? userText = null,
-        int maxTokens = 2048)
-    {
-        var messages = new List<ChatMessage>();
-
-        if (!string.IsNullOrEmpty(systemPrompt))
-            messages.Add(new ChatMessage { Role = "system", Content = systemPrompt });
-
-        // 构建多模态消息内容
-        var contentParts = new List<object>();
-        foreach (var url in imageUrls)
-            contentParts.Add(new { type = "image_url", image_url = new { url } });
-        if (!string.IsNullOrEmpty(userText))
-            contentParts.Add(new { type = "text", text = userText });
-
-        var userMessage = new ChatMessage
-        {
-            Role = "user",
-            Content = JsonSerializer.Serialize(contentParts, _jsonOptions)
-        };
-
-        messages.Add(userMessage);
-
-        var request = new ChatCompletionRequest
-        {
-            Model = _model,
-            Messages = messages,
-            MaxTokens = maxTokens,
-            Stream = false,
-        };
-
-        var json = JsonSerializer.Serialize(request, _jsonOptions);
-        var content = new StringContent(json, Encoding.UTF8, "application/json");
-        var response = await _http.PostAsync("chat/completions", content);
-        response.EnsureSuccessStatusCode();
-        var body = await response.Content.ReadAsStringAsync();
-        return JsonSerializer.Deserialize<ChatCompletionResponse>(body, _jsonOptions)!;
-    }
-}
-
-#region 请求/响应模型
-
-public sealed class ChatCompletionRequest
-{
-    public string Model { get; set; } = string.Empty;
-    public List<ChatMessage> Messages { get; set; } = [];
-    public bool Stream { get; set; }
-    public int MaxTokens { get; set; } = 2048;
-    public float Temperature { get; set; } = 0.7f;
-    public List<ToolDefinition>? Tools { get; set; }
-    public string? ToolChoice { get; set; }
-}
-
-public sealed class ChatMessage
-{
-    public string Role { get; set; } = string.Empty;
-    public string Content { get; set; } = string.Empty;
-    public string? ToolCallId { get; set; }
-    public List<ToolCall>? ToolCalls { get; set; }
-}
-
-public sealed class ToolDefinition
-{
-    public string Type { get; set; } = "function";
-    public ToolFunction Function { get; set; } = new();
-}
-
-public sealed class ToolFunction
-{
-    public string Name { get; set; } = string.Empty;
-    public string Description { get; set; } = string.Empty;
-    public object Parameters { get; set; } = new();
-}
-
-public sealed class ToolCall
-{
-    public string Id { get; set; } = string.Empty;
-    public string Type { get; set; } = "function";
-    public ToolCallFunction Function { get; set; } = new();
-}
-
-public sealed class ToolCallFunction
-{
-    public string Name { get; set; } = string.Empty;
-    public string Arguments { get; set; } = string.Empty;
-}
-
-public sealed class ChatCompletionResponse
-{
-    public string Id { get; set; } = string.Empty;
-    public List<Choice> Choices { get; set; } = [];
-}
-
-public sealed class Choice
-{
-    public int Index { get; set; }
-    public ResponseMessage? Message { get; set; }
-    public ResponseDelta? Delta { get; set; }
-    public string? FinishReason { get; set; }
-}
-
-public sealed class ResponseMessage
-{
-    public string Role { get; set; } = string.Empty;
-    public string? Content { get; set; }
-    public List<ToolCall>? ToolCalls { get; set; }
-}
-
-public sealed class ResponseDelta
-{
-    public string? Content { get; set; }
-    public string? Role { get; set; }
-}
-
-#endregion