```

feat(localization): 添加AI功能相关的本地化字符串新增了多个AI功能相关的本地化文本，包括AI整理、AI解读、本地推理等界面的文字显示，并添加了语音识别和性能测试相关的提示信息。同时更新了一些现有条目的状态标记。 ```
fix(语音日记): dictation 服务改 @State 防视图重建丢实例
2026-06-10 08:15:43 +08:00 · 2026-06-10 08:04:15 +08:00 · 2026-06-10 07:13:24 +08:00 · 2026-06-10 07:12:48 +08:00 · 2026-06-10 07:12:48 +08:00 · 2026-06-10 07:12:48 +08:00
74 changed files with 6756 additions and 402 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,6 @@
 /Models/
 /build/
 .DS_Store
+
+# MNN 预编译二进制:由 scripts/build-mnn-xcframework.sh 本地生成,不入库防历史膨胀
+/Frameworks/MNN.xcframework/
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -22,9 +22,10 @@
 | UI | SwiftUI | iOS 17+,用 `@Observable` / `@Model` |
 | 持久化 | SwiftData | 见 §5 数据模型 |
 | 图表 | Swift Charts | iOS 16+ 原生 |
-| **AI 运行时** | **MLX Swift (Apple 官方)** | 不要建议 Core ML / llama.cpp / Ollama |
-| LLM | Qwen3-1.7B 4bit (HF: `mlx-community/Qwen3-1.7B-4bit`) | ~1.0GB,负责文本生成、关键词抽取、趋势解读 |
-| VL | Qwen2.5-VL-3B-Instruct 4bit (HF: `mlx-community/Qwen2.5-VL-3B-Instruct-4bit`) | ~2.0GB,负责拍照→结构化指标 |
+| **AI 运行时(主)** | **MNN (alibaba) + Arm SME2 + CPU** | 挑战赛考核点:Qwen + MNN + SME2 端侧 CPU 推理。device-only(xcframework 见 `scripts/build-mnn-xcframework.sh`),A19/iPhone17 启用 SME2、A17 回退 NEON。经 `MNNLLMBridge`(ObjC++)→ `MNNBackend` |
+| **AI 运行时(兜底)** | **MLX Swift (Apple 官方,Metal GPU)** | 双后端:`InferenceEngine` 切换,模拟器/兜底用 MLX。不要建议 Core ML / llama.cpp / Ollama |
+| LLM | MNN 主(iPhone17+/SME2):Qwen3.5-2B(`taobao-mnn/Qwen3.5-2B-MNN`,~1.1GiB);MLX 兜底:Qwen3.5-2B-4bit | 文本生成、关键词抽取、趋势解读。4B 实测过慢已退回 2B | 
+| VL | Qwen3-VL-4B-Instruct 4bit (MLX `mlx-community/Qwen3-VL-4B-Instruct-4bit`) | 拍照→结构化指标。MNN VL 需 OMNI 构建,暂走 MLX |
 | 文档扫描 | VisionKit `VNDocumentCameraView` | 不要自己写透视校正 |
 | Face ID | LocalAuthentication | |
 | Live Activity | ActivityKit + WidgetExtension | demo 杀手锏,真机才能测 |
@@ -281,7 +282,7 @@ C2 解读 Tab 底部显示一段 diff 文本,**由 `ReportCompareService` 计算
 ## 12. 评委 PPT 卖点排序(写代码时记住为什么这么做)

 1. 影像档案系统(统一 VL 拍照 + 归档) — 核心创意
-2. 100% 本地 + SME2 加速 — 技术亮点
+2. 100% 本地 + **MNN + Arm SME2 端侧 CPU 加速**(挑战赛考核点,MLX/GPU 兜底) — 技术亮点
 3. 本地 RAG 长期记忆 — 端侧不可替代性
 4. 隐私三件套(系统级加密 + Face ID + 永久删除) — 信任建立
 5. AI 趋势解读 — 长期价值
--- a/docs/research/mnn-kv-cache-prefix.md
+++ b/docs/research/mnn-kv-cache-prefix.md
@@ -0,0 +1,41 @@
+# MNN 前缀 KV Cache 调研(2026-06-10)
+
+## 结论
+
+当前打包的 MNN.xcframework 已暴露 prefix cache 能力,技术上可以把每个场景**固定的
+system prompt + few-shot 模板**的 prefill 结果缓存到磁盘,二次调用跳过这部分 prefill。
+**建议 W6 polish 阶段、用性能自检卡量化 prefill 占比之后再决定是否接入**;当前瓶颈在
+decode 而非二次 prefill,优先级低于 C1/C2/Live Activity。
+
+## 依据(`Frameworks/MNN.xcframework/ios-arm64/MNN.framework/Headers/llm/llm.hpp`)
+
+| API | 行号 | 含义 |
+|---|---|---|
+| `bool setPrefixCacheFile(const std::string& filename, int flag = 0)` | :161 | 指定前缀缓存文件;配套私有成员 `mPrefixCacheMode` / `mPrefixLength` / `mIsPrefixFileExist` / `completePrefixWrite()`(:250-255)印证:命中时 prefill 只算增量部分 |
+| `bool reuse_kv()` | :171 | 读 config 开关 `reuse_kv`,多轮对话内复用 KV(同一会话增量 prefill) |
+| `void syncPromptCache(const ChatMessages&)` | :176 | decode 结束后同步缓存文本——注释明确说明 cache 在 generate() 后自更新,此接口供做过后处理(如 deleteThinkPart)的调用方提供更准确版本 |
+| `void setKVCacheInfo(size_t add, size_t remove, ...)` / `eraseHistory(begin, end)` | :158-160 | 更底层的 KV 区间管理,可做部分历史擦除 |
+
+## 对本项目的适用性
+
+- 我们所有调用都是「固定模板前缀 + 可变数据后缀」的单轮 `response()`,与 prefix cache
+  的模型吻合。
+- 模板体量(估):报告识别 ~900 tok、导出报告 ~700 tok、意图抽取 ~300 tok。
+  按性能自检卡实测的 prefill 速率推算,每次调用预计省 **1~3s**。
+- 多场景共用一个 cache 文件是否支持多前缀未知;最坏情况只对单一场景(建议选「报告识别」,
+  模板最长、调用最频繁)生效。
+
+## 风险
+
+1. `flag` 参数语义在头文件无注释,需读 MNN 源码或实验确认。
+2. OMNI(多模态)分支下行为未验证——我们的 MNN 模型是 Omni 构建。
+3. cache 文件与模型权重版本绑定:模型更新/重下载后必须失效,否则可能输出乱码。
+4. `<img>` 标签在 prompt 前部(`analyzeImages` 把图片标签拼在最前),意味着报告识别场景的
+   "固定前缀" 实际不固定 —— **文本场景(导出/意图抽取)才是干净的 prefix cache 候选**。
+
+## 建议的接入步骤(W6,如性能自检显示 prefill 占比 >30%)
+
+1. `MNNLLMBridge` init 后调 `setPrefixCacheFile(<AppSupport>/mnn-prefix.cache)`(仅文本场景)。
+2. 真机 A/B:同一导出报告各跑 3 次,对比 `LlmContext.prefill_us`。
+3. 异常处理:加载失败或输出劣化时删除 cache 文件并禁用,回退现状。
+4. `ModelDownloadService.importModel` / 重下载路径上顺手删除旧 cache 文件。
--- a/docs/superpowers/plans/2026-06-10-competition-optimizations.md
+++ b/docs/superpowers/plans/2026-06-10-competition-optimizations.md
--- a/docs/superpowers/plans/2026-06-10-voice-diary.md
+++ b/docs/superpowers/plans/2026-06-10-voice-diary.md
@@ -0,0 +1,930 @@
+# 语音健康日记 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 在「健康记录」(`DiaryQuickSheet`)加语音输入:iOS 端侧流式语音识别实时转写,停止后由本地 LLM(Qwen3.5-2B,经 AIRuntime)整理成健康日记草稿,追加进输入框,可一键回退原话。
+
+**Architecture:** `DiaryQuickSheet`(mic 按钮 + 状态机)→ `SpeechDictationService`(新,AVAudioEngine + SFSpeechRecognizer 端侧流式转写,不落盘音频)→ `DiaryAssistService.organize(transcript:)`(新方法,经 AIRuntime actor 队列)。Spec:`docs/superpowers/specs/2026-06-10-voice-diary-design.md`。
+
+**Tech Stack:** SwiftUI、Speech framework(`requiresOnDeviceRecognition = true`)、AVFoundation、Swift Testing(`康康Tests`)。
+
+**工程约定(执行前必读):**
+- 工程是 Xcode 16 同步组(`PBXFileSystemSynchronizedRootGroup`):`康康/`、`康康Tests/` 下新建文件**自动入 target,不要改 pbxproj 的文件列表**(权限键除外,见 Task 1)。
+- CLI 编译/测试必须:`export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer`,且加 `-derivedDataPath ./build/cli-dd`(避免和 Xcode 抢 build.db 锁)。
+- 工程 `SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor`:类型默认 MainActor;系统回调闭包(audio tap、recognitionTask handler)是 nonisolated,**闭包内只碰局部捕获变量,回主线程用 `Task { @MainActor in }`**。
+- 用户可见文案用 `String(appLoc: "...")`;字号用 `Font.tjScaled(...)`,禁止裸 `.system(size:)`;颜色只用 `Tj.Palette.*`。**不要手改 `Localizable.xcstrings`**(键缺失时回退键名本身,中文键名即兜底文案)。
+- `git status` 里已有 `康康/Localizable.xcstrings` 的无关改动——**任何 commit 都不要带上它**(逐文件 `git add`)。
+- spec 偏差说明(已确认的两处小调整):① CLAUDE.md 提到的 `DebugAIRunner` 已不在工程中,prompt 自检改为 `康康Tests` 单元测试 + 真机手测清单;② mic 按钮放「内容」section 标签行右侧(而非输入框内右下角 overlay),避免与文字重叠,仍属"输入框旁"。
+
+---
+
+### Task 0: 建独立分支
+
+**Files:** 无(纯 git)
+
+- [x] **Step 1: 从当前分支建 `feat/voice-diary`**
+
+```bash
+cd /Users/xuhuayong/apps/康康
+git checkout -b feat/voice-diary
+```
+
+Expected: `Switched to a new branch 'feat/voice-diary'`(`Localizable.xcstrings` 的本地改动会跟着工作区走,不影响)。
+
+---
+
+### Task 1: 新增麦克风 + 语音识别权限描述(pbxproj)
+
+**Files:**
+- Modify: `康康.xcodeproj/project.pbxproj:430`、`康康.xcodeproj/project.pbxproj:486`(Debug + Release 两个构建配置)
+
+pbxproj 的 `INFOPLIST_KEY_*` 按字母序排列:Microphone 插在 `NSHealthUpdateUsageDescription` 之后,SpeechRecognition 插在 `NSPhotoLibraryUsageDescription` 之后。每个锚点行在文件中出现 **2 次**(Debug/Release),用 replace_all 一次改两处。
+
+- [x] **Step 1: 插入 NSMicrophoneUsageDescription(replace_all)**
+
+用 Edit 工具,`replace_all: true`:
+
+old_string(注意行首是 4 个 tab):
+```
+				INFOPLIST_KEY_NSHealthUpdateUsageDescription = "康康不会写入 Apple 健康数据。此说明用于满足 HealthKit 权限校验,你的健康资料只保留在本机。";
+```
+
+new_string:
+```
+				INFOPLIST_KEY_NSHealthUpdateUsageDescription = "康康不会写入 Apple 健康数据。此说明用于满足 HealthKit 权限校验,你的健康资料只保留在本机。";
+				INFOPLIST_KEY_NSMicrophoneUsageDescription = "康康需要使用麦克风进行语音记录,识别全程在本机完成,声音不会上传。";
+```
+
+- [x] **Step 2: 插入 NSSpeechRecognitionUsageDescription(replace_all)**
+
+old_string:
+```
+				INFOPLIST_KEY_NSPhotoLibraryUsageDescription = "康康需要读取你已有的体检/化验报告照片用于本地识别,不会上传。";
+```
+
+new_string:
+```
+				INFOPLIST_KEY_NSPhotoLibraryUsageDescription = "康康需要读取你已有的体检/化验报告照片用于本地识别,不会上传。";
+				INFOPLIST_KEY_NSSpeechRecognitionUsageDescription = "语音转文字使用 iOS 端侧识别,内容不会发送给 Apple 或任何服务器。";
+```
+
+- [x] **Step 3: 验证两个键各出现 2 次**
+
+```bash
+grep -c "NSMicrophoneUsageDescription\|NSSpeechRecognitionUsageDescription" 康康.xcodeproj/project.pbxproj
+```
+
+Expected: `4`
+
+- [x] **Step 4: Commit**
+
+```bash
+git add 康康.xcodeproj/project.pbxproj
+git commit -m "feat(语音日记): 新增麦克风与语音识别权限描述(端侧识别文案)"
+```
+
+---
+
+### Task 2: organize prompt(TDD)
+
+**Files:**
+- Test: `康康Tests/DiaryOrganizePromptTests.swift`(新建)
+- Modify: `康康/AI/Prompts/DiaryAssistPrompts.swift`(文件末尾 `}` 前加方法)
+
+- [x] **Step 1: 写失败测试**
+
+新建 `康康Tests/DiaryOrganizePromptTests.swift`:
+
+```swift
+import Testing
+@testable import 康康
+
+struct DiaryOrganizePromptTests {
+    @Test func organizePromptContainsTranscriptAndHardRules() {
+        let prompt = DiaryAssistPrompts.organize(transcript: "今天早上头晕量了血压140 90")
+
+        #expect(prompt.contains("今天早上头晕量了血压140 90"))
+        // 健康数据红线:数值/单位/药名/时间不许改,必须写进 prompt
+        #expect(prompt.contains("数值"))
+        #expect(prompt.contains("药名"))
+        // 自适应样式两条规则都在
+        #expect(prompt.contains("一段通顺的话"))
+        #expect(prompt.contains("分行"))
+        // 项目 prompt 规范:禁思考标签
+        #expect(prompt.contains("/no_think"))
+    }
+
+    @Test func organizePromptTruncatesLongTranscript() {
+        let long = String(repeating: "头晕", count: 2000)   // 4000 字符,超过上限
+        let prompt = DiaryAssistPrompts.organize(transcript: long)
+
+        // 整条 prompt 里口述部分被截断到 organizeTranscriptLimit
+        let expectedTail = String(long.prefix(DiaryAssistPrompts.organizeTranscriptLimit))
+        #expect(prompt.contains(expectedTail))
+        #expect(!prompt.contains(String(long.prefix(DiaryAssistPrompts.organizeTranscriptLimit + 2))))
+    }
+}
+```
+
+- [x] **Step 2: 跑测试确认编译失败(方法还不存在)**
+
+```bash
+cd /Users/xuhuayong/apps/康康
+export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
+xcodebuild test -project 康康.xcodeproj -scheme 康康 \
+  -destination 'platform=iOS Simulator,name=iPhone 17' \
+  -only-testing:'康康Tests/DiaryOrganizePromptTests' \
+  -derivedDataPath ./build/cli-dd CODE_SIGNING_ALLOWED=NO 2>&1 | tail -20
+```
+
+Expected: 编译错误 `type 'DiaryAssistPrompts' has no member 'organize'`(TEST FAILED)。
+
+- [x] **Step 3: 实现 organize prompt**
+
+在 `康康/AI/Prompts/DiaryAssistPrompts.swift` 的 enum 末尾(`suggest` 方法后、收尾 `}` 前)加:
+
+```swift
+    // MARK: - 语音口述 → 日记整理
+
+    /// 口述转写稿截断上限(字符)。2B 模型 context 保护:超长口述只取前面部分。
+    static let organizeTranscriptLimit = 1200
+
+    /// 把语音转写稿整理成健康日记草稿。自适应样式:内容少 → 一段通顺的话;
+    /// 多方面 → 按「方面:内容」分行。
+    /// 红线(spec §2):只重组语言,严禁增删改任何数值、单位、药名、时间——
+    /// 2B 模型把 140/90 改成 130/90 即健康数据事故,所以规则放第一条并配 few-shot 强化。
+    static func organize(transcript: String) -> String {
+        let trimmed = String(transcript.prefix(organizeTranscriptLimit))
+        return """
+        你是健康记录助手。下面是用户口述身体状态的语音转写原话,可能口语化、有重复、缺标点。
+        请把它整理成一条清晰的健康日记。
+
+        硬性规则:
+        - 【绝对不许】增加、删除或改动任何数值、单位、药名、时间——原话说 140/90 就必须写 140/90。
+        - 只重组语言:去掉口头语和重复;用第一人称;不加入原话没有的事实。
+        - 内容只涉及一两个方面 → 整理成一段通顺的话(2-4 句)。
+        - 内容涉及多个方面(症状/用药/饮食/睡眠/运动等) → 按「方面:内容」分行。
+        - 不诊断、不给用药建议、不写「建议就医」。
+        - 只输出整理后的日记正文,不要解释、不要 markdown 围栏、不要 <think> 标签。
+
+        示例 1(口述:那个今天早上起来有点头晕然后我量了下血压140 90比平时高一点没吃早饭就出门了):
+        今天早上起来有点头晕,量了血压 140/90,比平时高一点。没吃早饭就出门了。
+
+        示例 2(口述:今天头晕了一上午下午好点了血压早上量的140 90嗯缬沙坦吃了降脂药忘了吃早饭没吃中午吃的清淡晚上散步了半小时):
+        症状:头晕了一上午,下午好转。
+        血压:早上 140/90。
+        用药:缬沙坦已服,降脂药忘服。
+        饮食:早饭未吃,午餐清淡。
+        运动:晚上散步半小时。
+
+        【口述原话】:
+        \(trimmed)
+
+        Output: /no_think
+        """
+    }
+```
+
+- [x] **Step 4: 跑测试确认通过**
+
+同 Step 2 命令。Expected: `** TEST SUCCEEDED **`,2 个用例通过。
+
+- [x] **Step 5: Commit**
+
+```bash
+git add 康康Tests/DiaryOrganizePromptTests.swift 康康/AI/Prompts/DiaryAssistPrompts.swift
+git commit -m "feat(语音日记): organize prompt(自适应样式 + 数值不可改红线)"
+```
+
+---
+
+### Task 3: DiaryAssistService.organize
+
+**Files:**
+- Modify: `康康/Services/DiaryAssistService.swift:99` 之后(`suggest` 方法后、struct 收尾 `}` 前)
+
+无新单测(纯转发 AIRuntime,LLM 行为靠真机手测;解析逻辑只有 strip + trim,复用已测过的 `stripThinkBlocks`)。
+
+- [x] **Step 1: 加 organize 方法**
+
+在 `suggest` 方法的收尾 `}` 之后、struct 收尾 `}` 之前加:
+
+```swift
+    /// 把语音转写稿整理成健康日记草稿(spec 2026-06-10-voice-diary)。
+    /// 失败(模型未就绪 / 输出为空)抛错,调用方回退为直接使用原话,不卡死。
+    /// 与 suggest 同样走 AIRuntime actor 队列,自然与追问/拍照串行。
+    func organize(transcript: String) async throws -> (text: String, decodeRate: Double) {
+        do {
+            try await AIRuntime.shared.prepare()
+        } catch {
+            throw AssistError.modelNotReady
+        }
+
+        let prompt = DiaryAssistPrompts.organize(transcript: transcript)
+        var collected = ""
+        var lastRate: Double = 0
+        let stream = await AIRuntime.shared.generate(prompt: prompt, maxTokens: 400)
+        for try await chunk in stream {
+            collected += chunk.text
+            if chunk.decodeRate > 0 { lastRate = chunk.decodeRate }
+        }
+
+        let text = HealthExportService.stripThinkBlocks(collected)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty else { throw AssistError.empty }
+        return (text, lastRate)
+    }
+```
+
+- [x] **Step 2: 编译验证**
+
+```bash
+cd /Users/xuhuayong/apps/康康
+export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
+xcodebuild -project 康康.xcodeproj -scheme 康康 \
+  -destination 'platform=iOS Simulator,name=iPhone 17' \
+  -configuration Debug build -derivedDataPath ./build/cli-dd \
+  CODE_SIGNING_ALLOWED=NO 2>&1 | grep -E "\.swift:[0-9]+:[0-9]+: (error|warning):|BUILD (SUCCEEDED|FAILED)"
+```
+
+Expected: `BUILD SUCCEEDED`,无新增 warning。
+
+- [x] **Step 3: Commit**
+
+```bash
+git add 康康/Services/DiaryAssistService.swift
+git commit -m "feat(语音日记): DiaryAssistService.organize 转写稿整理"
+```
+
+---
+
+### Task 4: SpeechDictationService(端侧流式转写)
+
+**Files:**
+- Create: `康康/Services/SpeechDictationService.swift`
+
+硬件绑定,无单测;模拟器路径(`isAvailable == false`)与真机路径在 Task 7 手测。
+
+- [x] **Step 1: 新建 SpeechDictationService.swift**
+
+```swift
+import Foundation
+import Speech
+import AVFoundation
+
+/// 端侧流式语音转写(spec 2026-06-10-voice-diary)。
+/// AVAudioEngine 麦克风 buffer → SFSpeechAudioBufferRecognitionRequest,
+/// `requiresOnDeviceRecognition = true` 硬性端侧,识别内容不出设备;**不落盘任何音频**。
+///
+/// 生命周期:start(onPartial:) 开始录音并实时回调 partial;stop() 结束并返回最终稿。
+/// 调用方:DiaryQuickSheet。工程默认 MainActor 隔离,本类型即 MainActor;
+/// audio tap 与识别回调在系统线程,闭包内只碰局部捕获对象,回主线程统一走 Task { @MainActor }。
+final class SpeechDictationService {
+
+    enum DictationError: Error, LocalizedError {
+        case unavailable
+        case audioEngineStartFailed(String)
+
+        var errorDescription: String? {
+            switch self {
+            case .unavailable:
+                return String(appLoc: "本机不支持端侧语音识别")
+            case .audioEngineStartFailed(let m):
+                return String(appLoc: "录音启动失败:\(m)")
+            }
+        }
+    }
+
+    /// 优先系统语言;系统语言不支持端侧时兜底中文(demo 机即使系统是英文也能用)。
+    private static func makeRecognizer() -> SFSpeechRecognizer? {
+        if let r = SFSpeechRecognizer(locale: .current), r.supportsOnDeviceRecognition {
+            return r
+        }
+        if let r = SFSpeechRecognizer(locale: Locale(identifier: "zh-CN")),
+           r.supportsOnDeviceRecognition {
+            return r
+        }
+        return nil
+    }
+
+    /// 本机是否支持端侧识别。false(模拟器/老机型)时 UI 隐藏 mic 入口,静默降级。
+    static var isAvailable: Bool { makeRecognizer() != nil }
+
+    private let audioEngine = AVAudioEngine()
+    private var request: SFSpeechAudioBufferRecognitionRequest?
+    private var task: SFSpeechRecognitionTask?
+    /// 识别回调持续刷新;isFinal 或出错时置 didFinish。stop() 用「final 优先、partial 兜底」。
+    private var latestText = ""
+    private var didFinish = false
+
+    private(set) var isRecording = false
+
+    /// 麦克风 + 语音识别两个权限一起申请。任一被拒返回 false。
+    func requestAuthorization() async -> Bool {
+        let speech = await withCheckedContinuation { (c: CheckedContinuation<SFSpeechRecognizerAuthorizationStatus, Never>) in
+            SFSpeechRecognizer.requestAuthorization { c.resume(returning: $0) }
+        }
+        guard speech == .authorized else { return false }
+        return await AVAudioApplication.requestRecordPermission()
+    }
+
+    /// 开始录音 + 流式识别。partial 结果在主线程回调(录音面板实时字幕)。
+    func start(onPartial: @escaping (String) -> Void) throws {
+        guard !isRecording else { return }
+        guard let recognizer = Self.makeRecognizer(), recognizer.isAvailable else {
+            throw DictationError.unavailable
+        }
+
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setCategory(.record, mode: .measurement, options: .duckOthers)
+            try session.setActive(true, options: .notifyOthersOnDeactivation)
+        } catch {
+            throw DictationError.audioEngineStartFailed(error.localizedDescription)
+        }
+
+        let request = SFSpeechAudioBufferRecognitionRequest()
+        request.requiresOnDeviceRecognition = true   // 红线:识别不出设备
+        request.shouldReportPartialResults = true
+        request.addsPunctuation = true
+        self.request = request
+        latestText = ""
+        didFinish = false
+
+        let input = audioEngine.inputNode
+        let format = input.outputFormat(forBus: 0)
+        // tap 在音频线程跑:只碰局部捕获的 request,不碰 self
+        input.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, _ in
+            request.append(buffer)
+        }
+        audioEngine.prepare()
+        do {
+            try audioEngine.start()
+        } catch {
+            input.removeTap(onBus: 0)
+            deactivateSession()
+            throw DictationError.audioEngineStartFailed(error.localizedDescription)
+        }
+
+        task = recognizer.recognitionTask(with: request) { [weak self] result, error in
+            // 系统线程 → 主线程
+            Task { @MainActor in
+                guard let self else { return }
+                if let result {
+                    self.latestText = result.bestTranscription.formattedString
+                    onPartial(self.latestText)
+                    if result.isFinal { self.didFinish = true }
+                }
+                if error != nil { self.didFinish = true }
+            }
+        }
+        isRecording = true
+    }
+
+    /// 停止录音,等待最终识别结果(最多 1.5s,超时用最新 partial),返回最终稿。
+    /// 中途识别出错时已拿到的 partial 一样返回(spec 错误表:照常进整理流程)。
+    func stop() async -> String {
+        guard isRecording else { return "" }
+        isRecording = false
+
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+        request?.endAudio()
+
+        let deadline = Date().addingTimeInterval(1.5)
+        while !didFinish && Date() < deadline {
+            try? await Task.sleep(nanoseconds: 100_000_000)
+        }
+        task?.cancel()
+        task = nil
+        request = nil
+        deactivateSession()
+        return latestText
+    }
+
+    /// 用户直接关 sheet 时的清理:不关心结果,立即停。
+    func abort() {
+        guard isRecording else { return }
+        isRecording = false
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+        request?.endAudio()
+        task?.cancel()
+        task = nil
+        request = nil
+        deactivateSession()
+    }
+
+    private func deactivateSession() {
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    }
+}
+```
+
+- [x] **Step 2: 编译验证**
+
+同 Task 3 Step 2 命令。Expected: `BUILD SUCCEEDED`。若出现 actor 隔离 warning(标注 error in Swift 6 language mode 的不阻塞),按提示把回调内对 self 的访问收进 `Task { @MainActor in }`,不许用 `nonisolated(unsafe)` 糊。
+
+- [x] **Step 3: Commit**
+
+```bash
+git add 康康/Services/SpeechDictationService.swift
+git commit -m "feat(语音日记): SpeechDictationService 端侧流式转写(不落盘音频)"
+```
+
+---
+
+### Task 5: DiaryVoicePanel(录音/整理面板视图)
+
+**Files:**
+- Create: `康康/Features/Diary/DiaryVoicePanel.swift`
+
+纯展示组件,状态全部外部传入,DiaryQuickSheet(已 600+ 行)不再膨胀。
+
+- [x] **Step 1: 新建 DiaryVoicePanel.swift**
+
+```swift
+import SwiftUI
+
+/// 「健康记录」语音输入面板(spec 2026-06-10-voice-diary)。
+/// 两种模式:recording(实时字幕 + 计时 + 停止)/ organizing(AI 整理中,可取消)。
+/// 纯展示:状态由 DiaryQuickSheet 持有并传入。
+struct DiaryVoicePanel: View {
+    enum Mode: Equatable {
+        case recording(elapsedSeconds: Int)
+        case organizing
+    }
+
+    let mode: Mode
+    /// recording 时为实时字幕;organizing 时为已定稿的转写稿(置灰展示)。
+    let transcript: String
+    let onStop: () -> Void
+    let onCancelOrganize: () -> Void
+
+    /// 录音上限 3 分钟(超时由 DiaryQuickSheet 的看门狗触发 onStop)。
+    static let maxRecordingSeconds = 180
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            header
+            transcriptArea
+            if case .recording = mode {
+                stopButton
+            }
+        }
+        .padding(12)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .fill(Tj.Palette.paper)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+        )
+        .overlay(alignment: .bottom) {
+            if mode == .organizing {
+                AIFlowBar().padding(.horizontal, 1)
+            }
+        }
+        .clipShape(RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous))
+    }
+
+    @ViewBuilder
+    private var header: some View {
+        switch mode {
+        case .recording(let elapsed):
+            HStack(spacing: 8) {
+                Image(systemName: "waveform")
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.brick)
+                    .symbolEffect(.variableColor.iterative, options: .repeating)
+                Text("正在听 · 识别在本机完成")
+                    .font(.tjScaled(13, weight: .medium))
+                    .foregroundStyle(Tj.Palette.text2)
+                Spacer(minLength: 0)
+                Text(Self.format(elapsed))
+                    .font(.tjScaled(12, design: .monospaced))
+                    .foregroundStyle(elapsed >= Self.maxRecordingSeconds - 30
+                                     ? Tj.Palette.brick : Tj.Palette.text3)
+            }
+        case .organizing:
+            HStack(spacing: 8) {
+                Image(systemName: "sparkles")
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.brick)
+                    .symbolEffect(.pulse, options: .repeating)
+                Text("AI 整理中 · 本地推理")
+                    .font(.tjScaled(13, weight: .medium))
+                    .foregroundStyle(Tj.Palette.text2)
+                Spacer(minLength: 0)
+                Button("取消") { onCancelOrganize() }
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.text3)
+            }
+        }
+    }
+
+    @ViewBuilder
+    private var transcriptArea: some View {
+        ScrollViewReader { proxy in
+            ScrollView(showsIndicators: false) {
+                Text(transcript.isEmpty ? String(appLoc: "开始说话…") : transcript)
+                    .font(.tjScaled(14))
+                    .foregroundStyle(transcriptColor)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .fixedSize(horizontal: false, vertical: true)
+                Color.clear.frame(height: 1).id("tail")
+            }
+            .frame(maxHeight: 120)
+            .onChange(of: transcript) { _, _ in
+                proxy.scrollTo("tail", anchor: .bottom)
+            }
+        }
+    }
+
+    private var transcriptColor: Color {
+        if transcript.isEmpty { return Tj.Palette.text3 }
+        return mode == .organizing ? Tj.Palette.text3 : Tj.Palette.text
+    }
+
+    private var stopButton: some View {
+        Button(action: onStop) {
+            HStack(spacing: 8) {
+                Image(systemName: "stop.circle.fill")
+                Text("说完了,整理成日记")
+            }
+            .font(.tjScaled(14, weight: .semibold))
+            .foregroundStyle(Tj.Palette.paper)
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, 12)
+            .background(
+                RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                    .fill(Tj.Palette.brick)
+            )
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+
+    private static func format(_ seconds: Int) -> String {
+        String(format: "%d:%02d", seconds / 60, seconds % 60)
+    }
+}
+
+#Preview("录音中") {
+    DiaryVoicePanel(mode: .recording(elapsedSeconds: 23),
+                    transcript: "今天早上起来有点头晕,量了血压一百四九十",
+                    onStop: {}, onCancelOrganize: {})
+        .padding()
+}
+
+#Preview("整理中") {
+    DiaryVoicePanel(mode: .organizing,
+                    transcript: "今天早上起来有点头晕,量了血压一百四九十",
+                    onStop: {}, onCancelOrganize: {})
+        .padding()
+}
+```
+
+- [x] **Step 2: 编译验证**
+
+同 Task 3 Step 2 命令。Expected: `BUILD SUCCEEDED`。
+
+- [x] **Step 3: Commit**
+
+```bash
+git add 康康/Features/Diary/DiaryVoicePanel.swift
+git commit -m "feat(语音日记): DiaryVoicePanel 录音/整理面板"
+```
+
+---
+
+### Task 6: DiaryQuickSheet 接入(mic 按钮 + 状态机 + 回退 pill)
+
+**Files:**
+- Modify: `康康/Features/Diary/DiaryQuickSheet.swift`
+
+改 5 处:① 状态 + 录音流程函数;② 「内容」标签行加 mic 按钮;③ 输入框下方挂面板 / 提示条 / 回退 pill;④ `canRequestSuggest` 把 organizing 排除;⑤ onDisappear 清理。
+
+- [x] **Step 1: 加语音状态(`@FocusState` 行之后、`hasContent` 之前)**
+
+在 `DiaryQuickSheet.swift:38`(`@FocusState private var contentFocused: Bool`)之后插入:
+
+```swift
+
+    // MARK: 语音输入状态(spec 2026-06-10-voice-diary)
+
+    enum VoicePhase: Equatable { case idle, recording, organizing }
+    @State private var voicePhase: VoicePhase = .idle
+    @State private var liveTranscript = ""
+    @State private var recordingSeconds = 0
+    /// 最近一次最终转写稿,「改用原话」回退用;再次录音时覆盖。
+    @State private var rawTranscript: String?
+    /// 刚追加进正文的整理稿,用于「改用原话」时在正文中定位替换。
+    /// 用户手动编辑掉该段(正文中找不到了)时 pill 自然消失。
+    @State private var organizedAppended: String?
+    /// 一次性提示条文案(整理失败已填原话 / 没听清等),开始新录音时清掉。
+    @State private var voiceNote: String?
+    @State private var voiceDeniedAlert = false
+    @State private var voiceFlowTask: Task<Void, Never>?
+    @State private var recordingWatchdog: Task<Void, Never>?
+    private let dictation = SpeechDictationService()
+```
+
+- [x] **Step 2: 「内容」标签行加 mic 按钮**
+
+把(`DiaryQuickSheet.swift:79-80` 附近):
+
+```swift
+                        VStack(alignment: .leading, spacing: 8) {
+                            sectionLabel(String(appLoc: "内容"))
+```
+
+改为:
+
+```swift
+                        VStack(alignment: .leading, spacing: 8) {
+                            HStack {
+                                sectionLabel(String(appLoc: "内容"))
+                                Spacer()
+                                if SpeechDictationService.isAvailable, voicePhase == .idle {
+                                    Button(action: startVoice) {
+                                        HStack(spacing: 4) {
+                                            Image(systemName: "mic.fill")
+                                                .font(.tjScaled(11, weight: .semibold))
+                                            Text("说一段")
+                                                .font(.tjScaled(12, weight: .semibold))
+                                        }
+                                        .foregroundStyle(isLoading ? Tj.Palette.text3 : Tj.Palette.brick)
+                                        .padding(.horizontal, 10)
+                                        .padding(.vertical, 5)
+                                        .background(Capsule().strokeBorder(
+                                            isLoading ? Tj.Palette.line : Tj.Palette.brick.opacity(0.5),
+                                            lineWidth: 1))
+                                        .contentShape(Capsule())
+                                    }
+                                    .buttonStyle(.plain)
+                                    .disabled(isLoading)   // AI 追问生成中不抢 AIRuntime 队列
+                                }
+                            }
+```
+
+(`TextField` 那段不动,仍在该 VStack 内。)
+
+- [x] **Step 3: 输入框下方挂面板 / 提示条 / 回退 pill**
+
+在 TextField 的 `.overlay(...)` 闭合后、该 VStack 的收尾 `}` 之前(即原 `DiaryQuickSheet.swift:95` `)` 与 `:96` `}` 之间)插入:
+
+```swift
+
+                            if voicePhase != .idle {
+                                DiaryVoicePanel(
+                                    mode: voicePhase == .organizing
+                                        ? .organizing
+                                        : .recording(elapsedSeconds: recordingSeconds),
+                                    transcript: liveTranscript,
+                                    onStop: stopVoiceAndOrganize,
+                                    onCancelOrganize: cancelOrganize
+                                )
+                            }
+
+                            if let note = voiceNote {
+                                HStack(spacing: 6) {
+                                    Image(systemName: "info.circle")
+                                        .font(.tjScaled(11))
+                                        .foregroundStyle(Tj.Palette.text3)
+                                    Text(note)
+                                        .font(.tjScaled(11))
+                                        .foregroundStyle(Tj.Palette.text3)
+                                    Spacer(minLength: 0)
+                                }
+                            }
+
+                            if let organized = organizedAppended,
+                               rawTranscript != nil,
+                               content.range(of: organized) != nil {
+                                Button(action: revertToRawTranscript) {
+                                    HStack(spacing: 4) {
+                                        Image(systemName: "arrow.uturn.backward")
+                                            .font(.tjScaled(10, weight: .semibold))
+                                        Text("改用原话")
+                                            .font(.tjScaled(11, weight: .semibold))
+                                    }
+                                    .foregroundStyle(Tj.Palette.ink)
+                                    .padding(.horizontal, 10)
+                                    .padding(.vertical, 5)
+                                    .background(Capsule().strokeBorder(Tj.Palette.line, lineWidth: 1))
+                                    .contentShape(Capsule())
+                                }
+                                .buttonStyle(.plain)
+                            }
+```
+
+- [x] **Step 4: organizing 期间禁用「AI 追问」+ 关 sheet 清理 + 权限 alert**
+
+把 `DiaryQuickSheet.swift:48`:
+
+```swift
+    private var canRequestSuggest: Bool { hasContent && !isLoading }
+```
+
+改为:
+
+```swift
+    private var canRequestSuggest: Bool { hasContent && !isLoading && voicePhase == .idle }
+```
+
+把 `DiaryQuickSheet.swift:146`:
+
+```swift
+        .onDisappear { suggestTask?.cancel() }
+```
+
+改为:
+
+```swift
+        .onDisappear {
+            suggestTask?.cancel()
+            voiceFlowTask?.cancel()
+            recordingWatchdog?.cancel()
+            dictation.abort()
+        }
+        .alert(String(appLoc: "需要麦克风与语音识别权限"), isPresented: $voiceDeniedAlert) {
+            Button(String(appLoc: "前往设置")) {
+                if let url = URL(string: UIApplication.openSettingsURLString) {
+                    UIApplication.shared.open(url)
+                }
+            }
+            Button(String(appLoc: "取消"), role: .cancel) {}
+        } message: {
+            Text("语音记录全程在本机完成,声音和文字都不会上传。请在设置中允许麦克风和语音识别。")
+        }
+```
+
+- [x] **Step 5: 加流程函数(`// MARK: - Actions` 区,`requestSuggestions` 之前)**
+
+在 `DiaryQuickSheet.swift` 的 `sectionLabel` 函数后插入:
+
+```swift
+
+    // MARK: 语音输入流程
+
+    private func startVoice() {
+        contentFocused = false
+        voiceNote = nil
+        voiceFlowTask = Task { @MainActor in
+            guard await dictation.requestAuthorization() else {
+                voiceDeniedAlert = true
+                return
+            }
+            do {
+                liveTranscript = ""
+                recordingSeconds = 0
+                try dictation.start { partial in liveTranscript = partial }
+                withAnimation(.snappy(duration: 0.2)) { voicePhase = .recording }
+                // 计时 + 3 分钟看门狗(到点自动停,行为与点「停止」一致)
+                recordingWatchdog = Task { @MainActor in
+                    while !Task.isCancelled {
+                        try? await Task.sleep(nanoseconds: 1_000_000_000)
+                        guard !Task.isCancelled, voicePhase == .recording else { return }
+                        recordingSeconds += 1
+                        if recordingSeconds >= DiaryVoicePanel.maxRecordingSeconds {
+                            stopVoiceAndOrganize()
+                            return
+                        }
+                    }
+                }
+            } catch {
+                voiceNote = error.localizedDescription
+                voicePhase = .idle
+            }
+        }
+    }
+
+    private func stopVoiceAndOrganize() {
+        guard voicePhase == .recording else { return }
+        recordingWatchdog?.cancel()
+        voiceFlowTask = Task { @MainActor in
+            let transcript = (await dictation.stop())
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            liveTranscript = transcript
+            guard !transcript.isEmpty else {
+                withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+                voiceNote = String(appLoc: "没听清,再试一次")
+                return
+            }
+            rawTranscript = transcript
+            withAnimation(.snappy(duration: 0.2)) { voicePhase = .organizing }
+            do {
+                let result = try await DiaryAssistService.shared.organize(transcript: transcript)
+                guard !Task.isCancelled else { return }
+                appendToContent(result.text)
+                organizedAppended = result.text
+                lastRate = result.decodeRate
+            } catch is CancellationError {
+                // cancelOrganize 已处理回退,这里只收尾
+            } catch {
+                guard !Task.isCancelled else { return }
+                appendToContent(transcript)   // 红线 #5:整理失败回退原话,不卡死
+                organizedAppended = nil
+                voiceNote = String(appLoc: "AI 整理失败,已填入原话")
+            }
+            withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+        }
+    }
+
+    /// 取消整理:中断 LLM,直接填原话(与失败回退同路径)。
+    private func cancelOrganize() {
+        guard voicePhase == .organizing else { return }
+        voiceFlowTask?.cancel()
+        if let raw = rawTranscript {
+            appendToContent(raw)
+            organizedAppended = nil
+            voiceNote = String(appLoc: "已取消整理,填入原话")
+        }
+        withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+    }
+
+    /// 「改用原话」:把刚追加的整理稿替换为原始转写稿(spec §2:LLM 改数兜底)。
+    private func revertToRawTranscript() {
+        guard let raw = rawTranscript,
+              let organized = organizedAppended,
+              let range = content.range(of: organized, options: .backwards) else { return }
+        withAnimation(.snappy(duration: 0.18)) {
+            content = content.replacingCharacters(in: range, with: raw)
+            organizedAppended = nil
+        }
+    }
+```
+
+- [x] **Step 6: 编译验证(touch 强制重编拿全量警告)**
+
+```bash
+cd /Users/xuhuayong/apps/康康
+touch 康康/Features/Diary/DiaryQuickSheet.swift
+export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
+xcodebuild -project 康康.xcodeproj -scheme 康康 \
+  -destination 'platform=iOS Simulator,name=iPhone 17' \
+  -configuration Debug build -derivedDataPath ./build/cli-dd \
+  CODE_SIGNING_ALLOWED=NO 2>&1 | grep -E "\.swift:[0-9]+:[0-9]+: (error|warning):|BUILD (SUCCEEDED|FAILED)"
+```
+
+Expected: `BUILD SUCCEEDED`,无新增 warning。
+
+- [x] **Step 7: 跑全量单测(确认没碰坏别的)**
+
+```bash
+xcodebuild test -project 康康.xcodeproj -scheme 康康 \
+  -destination 'platform=iOS Simulator,name=iPhone 17' \
+  -derivedDataPath ./build/cli-dd CODE_SIGNING_ALLOWED=NO 2>&1 | tail -5
+```
+
+Expected: `** TEST SUCCEEDED **`。
+
+- [x] **Step 8: Commit**
+
+```bash
+git add 康康/Features/Diary/DiaryQuickSheet.swift
+git commit -m "feat(语音日记): DiaryQuickSheet 接入语音输入(录音→整理→回退原话)"
+```
+
+---
+
+### Task 7: 验证与手测清单
+
+**Files:** 无新增代码
+
+- [x] **Step 1: 模拟器降级路径验证**
+
+模拟器跑 App(或 Xcode Preview `DiaryQuickSheet`),打开「+ 新建 → 写日记」:
+- `SpeechDictationService.isAvailable` 在模拟器多半为 false → 「说一段」按钮应**整体不显示**,其余功能照旧。
+- 若模拟器恰好支持端侧识别(部分 macOS/Xcode 组合会),按钮出现也算通过——继续验证录音面板出现、无崩溃即可。
+
+- [ ] **Step 2: 真机手测清单(连 iPhone 跑,逐项确认)**
+
+1. 首次点「说一段」→ 依次弹语音识别 + 麦克风两个系统权限框,文案是 Task 1 写的端侧说明
+2. 拒绝权限 → 再点按钮弹「前往设置」alert,能跳系统设置
+3. 录音中:实时字幕逐字上屏、计时走动、说话时 waveform 动画
+4. 点「说完了,整理成日记」→ 面板转「AI 整理中」(AIFlowBar 流动)→ 整理稿**追加**进输入框(已有手打内容不被覆盖)
+5. 口述含数值(如"血压一百四九十")→ 整理稿数值未被改动(说 3 条不同口述各验一次)
+6. 「改用原话」pill 出现;点击 → 整理稿被替换为原始转写稿;再手动编辑正文该段 → pill 消失
+7. 飞行模式(模型已下载)→ 全流程照常,验证 100% 本地
+8. 一个字不说就点停止 → 「没听清,再试一次」,回 idle 不卡死
+9. 模型未下载(或长按删除模型后)→ 整理失败 → 原话直接入框 + 提示
+10. 录音中直接下滑关 sheet → 无崩溃,再次打开正常
+11. 「AI 整理中」点取消 → 原话入框 + 「已取消整理,填入原话」
+
+- [ ] **Step 3: 把手测结果记进 commit(若有 fix,随 fix 一起提)**
+
+```bash
+git commit --allow-empty -m "test(语音日记): 真机手测清单通过(见 plan Task 7)"
+```
+
+---
+
+## Self-Review 记录
+
+- **Spec 覆盖**:权限(T1)、organize prompt + 自适应 + 数值红线(T2)、Service(T3)、端侧转写不落盘 + 3 分钟上限 + zh 兜底(T4)、面板 + 实时字幕(T5)、mic 入口 + 状态机 + 追加不覆盖 + 改用原话 + 全部错误回退 + organizing 禁用追问(T6)、手测含飞行模式/空转写/取消(T7)。spec 各节均有对应任务。
+- **占位符**:无 TBD/TODO;所有代码步骤给了完整代码。
+- **类型一致性**:`SpeechDictationService.isAvailable/requestAuthorization/start(onPartial:)/stop()/abort()` 在 T4 定义、T6 使用一致;`DiaryVoicePanel.Mode`/`maxRecordingSeconds` T5 定义、T6 使用一致;`organize(transcript:) -> (text:, decodeRate:)` T3 定义、T6 解构一致;`AssistError` 复用现有定义。
--- a/docs/superpowers/specs/2026-06-10-voice-diary-design.md
+++ b/docs/superpowers/specs/2026-06-10-voice-diary-design.md
@@ -0,0 +1,121 @@
+# 语音健康日记(语音转文字 + AI 整理)设计
+
+> 2026-06-10 · 在「健康记录」(`DiaryQuickSheet`)里加语音输入:iOS 端侧语音识别实时转写,停止后由本地 LLM 整理成健康日记草稿,可编辑后保存。
+
+## 背景
+
+「健康记录」目前只能手打文字(`DiaryQuickSheet` → `DiaryEntry`),已有「AI 医生角度多轮追问」辅助。口述比打字门槛低得多,尤其适合身体不适时记录。
+
+现有两个本地模型(Qwen3.5-2B 文本、Qwen3-VL 视觉)都没有音频编码器,无法做 ASR;引入 Whisper 类模型要 +0.5~1.5GB 体积和一条新推理链路,不可接受。`SFSpeechRecognizer` 支持强制端侧识别(`requiresOnDeviceRecognition = true`),中文质量够用、零体积,与「100% 本地」卖点完全一致。
+
+## 决策(已与用户确认)
+
+| 维度 | 决定 |
+|---|---|
+| 交互形态 | 说完 → 自动调 LLM 整理成日记草稿(非纯听写) |
+| 整理样式 | 自适应:口述短 → 一段通顺的话;口述长且多方面 → 自动分点 |
+| 入口 | `DiaryQuickSheet` 输入框旁麦克风按钮(不动 RecordSheet 骨架) |
+| 转写链路 | 流式实时转写(AVAudioEngine buffer → 实时字幕),不落盘音频 |
+| ASR 引擎 | `SFSpeechRecognizer` 端侧;不引入 Whisper;不做云端回退 |
+
+## 架构
+
+```
+DiaryQuickSheet(mic 按钮 + 录音面板)
+   ├─► SpeechDictationService(新)── AVAudioEngine + SFSpeechRecognizer(端侧)
+   └─► DiaryAssistService.organize(transcript:)(新方法)──► AIRuntime ──► MNN/MLX
+```
+
+符合模块边界:UI 不直接碰 AIRuntime;语音采集是系统能力,封装成独立 Service。
+
+## 组件
+
+### 1. `SpeechDictationService`(新,`Services/`,`@MainActor`)
+
+封装 AVAudioEngine 麦克风采集 + `SFSpeechAudioBufferRecognitionRequest` 流式识别。
+
+接口:
+
+- `static var isAvailable: Bool` — 本机是否支持**端侧**中文识别(`supportsOnDeviceRecognition` + locale 检查;模拟器/老机型为 false)
+- `func requestAuthorization() async -> Bool` — 麦克风 + 语音识别两个权限一起申请
+- `func start(onPartial: @escaping (String) -> Void) throws` — 开始录音,partial 结果实时回调(录音面板字幕)
+- `func stop() async -> String` — 停止并返回最终转写稿
+
+实现要点:
+
+- `requiresOnDeviceRecognition = true`(硬性,识别内容不出设备)
+- `addsPunctuation = true`(自动标点)
+- locale 跟随系统,不支持端侧时 `isAvailable = false`
+- **不写任何音频文件**,buffer 即用即弃
+- 录音上限 3 分钟,到点自动 stop
+
+### 2. `DiaryAssistService.organize(transcript:)`(新方法)
+
+```swift
+func organize(transcript: String) async throws -> (text: String, decodeRate: Double)
+```
+
+- prompt 加在 `AI/Prompts/DiaryAssistPrompts.swift`:`organizePrompt(transcript:)`
+- few-shot 两例:短口述 → 一段第一人称通顺文本;长口述(症状/用药/饮食多方面)→ 分点
+- **硬性约束写进 prompt:只重组语言,不得增删改任何数值、单位、药名、时间**(健康数据,2B 模型改数即事故)
+- 转写稿超长先截断(保护 context),非流式,await 完整结果
+- 走 AIRuntime actor 队列,与「多轮追问」「拍照识别」自然串行
+
+### 3. `DiaryQuickSheet` UI 改动
+
+- 内容输入框 trailing 加 mic 按钮(`isAvailable == false` 时整个隐藏)
+- 录音态:输入框下方展开录音面板 —— 实时字幕区 + 脉冲动画(sparkles/waveform `symbolEffect`)+「停止」按钮
+- 整理态:面板转「AI 整理中」(复用 `AIFlowBar` + tok/s),可取消
+- 完成:整理稿**追加**进输入框(沿用 `appendToContent`,不覆盖已写内容);面板收起
+- 完成后显示一次性「改用原话」pill:点击把刚追加的整理稿替换为原始转写稿(原始稿在本次 sheet 生命周期内持有;再次录音或手动编辑该段后 pill 消失)
+- 整理稿入框后,既有「AI 多轮追问」功能照常可用,无需特殊处理
+
+## 状态机
+
+```
+idle ──(点 mic,权限 OK)──► recording ──(停止/3min 到点)──► organizing ──► done(回 idle)
+```
+
+- 实时字幕只显示在录音面板,**停止前不进输入框**
+- `organizing` 期间 mic 按钮与「AI 追问」按钮禁用(AIRuntime 串行,避免排队困惑)
+
+## 错误处理(红线 #5:全部有回退,不卡死)
+
+| 故障 | 行为 |
+|---|---|
+| 权限被拒 | 弹说明 alert + 「前往设置」跳系统设置 |
+| 本机不支持端侧识别(含模拟器) | mic 按钮隐藏,静默降级为纯手打 |
+| 识别中途出错 | 已拿到的 partial 文本照常进 organizing |
+| 转写结果为空 | 提示「没听清,再试一次」,回 idle |
+| LLM 未就绪 / 整理失败 | **原始转写稿直接追加进输入框** + 提示「AI 整理失败,已填入原话」 |
+
+不做云端识别回退(红线 #1:不引入云服务)。
+
+## 权限(project.pbxproj 新增两条 INFOPLIST_KEY)
+
+- `NSMicrophoneUsageDescription`:康康需要使用麦克风进行语音记录,识别全程在本机完成,声音不会上传。
+- `NSSpeechRecognitionUsageDescription`:语音转文字使用 iOS 端侧识别,内容不会发送给 Apple 或任何服务器。
+
+## 测试
+
+- `organize` prompt:`DebugAIRunner` 加自检入口(短/长两条样例口述,肉眼验自适应样式 + 数值不被改动)
+- 录音链路:真机手测清单(权限首次申请、录音字幕、3 分钟自动停、整理失败回退、「改用原话」)
+- 模拟器:验证 `isAvailable == false` 时 mic 按钮隐藏
+
+## 范围边界(不做)
+
+- 症状 / AI 问答的语音入口
+- 音频文件保存或回放
+- Whisper / 任何新模型
+- Live Activity 集成(前台短流程,无必要)
+- 多语言听写优化(locale 跟系统,不支持即降级)
+
+## 卖点映射(§12)
+
+1. 降低记录门槛 → 卖点 1(影像档案之外的日常记录闭环)
+2. 「系统端侧 ASR + 本地 LLM 整理」全链路不出设备 → 卖点 2(100% 本地)
+3. 日记语料变多 → 卖点 3(本地 RAG 长期记忆)
+
+## 排期
+
+清单外新功能(红线 #6),本设计即立项讨论结论。工作量约 1~1.5 天,独立小分支插队,不挤占 C1/VL 主线。
--- a/docs/踩坑与排查记录.md
+++ b/docs/踩坑与排查记录.md
@@ -0,0 +1,210 @@
+# 康康 · 踩坑与排查记录
+
+> 本地推理 / SwiftData / 端侧模型这类问题不好复现也不好搜,踩过的坑按统一模板记在这里,方便回查。
+> 新增条目往最上面加(倒序),模板见文末。
+
+---
+
+## 2026-06-09 · 生成身体档案报告时,LLM 逐行复读死循环
+
+### 现象
+多轮「身体档案」对话点生成报告后,「## 关键指标」整段陷入死循环:同一行
+`⚠️ 收缩压 (107 mmHg)` 连续重复几十遍,最后被 maxTokens 截断成半行「⚠️ 收缩」。
+(本质是小模型 **repetition / degeneration loop**,不是数据真有几十条。)
+
+### 根因(确认)
+采样器**完全没有重复惩罚**,叠加低温 → 几乎必然复读。两个后端都有问题:
+
+| 后端 | 位置 | 原配置 | 问题 |
+|---|---|---|---|
+| MNN(主) | `MNNLLMBridge.mm` `initWithConfigPath` 的 `set_config` | `temperature 0.3, topP 0.85` | 无 `penalty` |
+| MLX(兜底) | `LLMSession.swift` `GenerateParameters` | `temperature 0.3, topP 0.85` | 无 `repetitionPenalty` |
+
+关键细节(读 MNN 源码 `transformers/llm/engine/src/`):
+- `llmconfig.hpp`:`mixed_samplers` 默认 `{topK, tfs, typical, topP, min_p, temperature}` —— **不含 `penalty`**;
+  `penalty` / `ngram_factor` 默认 `1.0`(=全关)。
+- `sampler.cpp` `configMixed`:只会把 `penalty`「**移到链首(如果存在)**」,**不会自动插入**。
+  所以光设 `"penalty":1.1` 没用,必须把 `"penalty"` 显式写进 `mixed_samplers`。
+- `sampler.cpp` `stepPenalty`:`repetition_penalty` 对 logits 乘法惩罚;**n-gram 命中整段重复时惩罚直接升到 `max_penalty`** —— 这正是掐断「整行复读」最有效的开关。
+
+**为什么低温反而更糟**:temperature 0.3 接近贪心,一旦吐出 `收缩压 (107 mmHg)\n`,
+最高概率的后续就是再吐一遍同样的行,无惩罚就永远出不来。
+
+### 排查过程(可复用思路)
+1. 看现象先判定是「数据重复」还是「生成复读」—— 被截断成半行 `收缩` 说明是 token 级复读,不是数据。
+2. `grep -niE "penalty|temperature|top_?p|sampler" 康康/AI/` 一把定位两个后端的采样配置 → 都没 penalty。
+3. 不猜 MNN 配置键,直接读构建用的源码 `MNN_SRC=/Users/xuhuayong/apps/MNN-src`
+   的 `llmconfig.hpp` / `sampler.cpp`,确认键名、默认值、`mixed_samplers` 不自动插 penalty。
+4. MLX 侧读 SPM checkout 的 `MLXLMCommon/Evaluate.swift`,确认 `GenerateParameters` 有
+   `repetitionPenalty: Float?` + `repetitionContextSize: Int`。
+
+### 修复
+- **MNN** `MNNLLMBridge.mm`:`set_config` 显式开重复惩罚 +
+  把 `penalty` 放进 mixed 链首:
+  ```jsonc
+  {
+    "jinja":{"context":{"enable_thinking":false}},
+    "sampler_type":"mixed",
+    "mixed_samplers":["penalty","topK","topP","temperature"],
+    "temperature":0.3,"topP":0.85,"topK":40,
+    "penalty":1.1,"n_gram":8,"ngram_factor":1.05
+  }
+  ```
+  (注意:JSON merge-patch 对数组是**整体替换**,所以这里会覆盖掉默认 `mixed_samplers`,符合预期。)
+- **MLX** `LLMSession.swift`:`GenerateParameters(..., repetitionPenalty: 1.1, repetitionContextSize: 64)`。
+
+取值都偏保守:`penalty 1.1` / `ngram_factor 1.05` 是业界常用档(MNN 自带 omni 默认 1.05),
+低温 + 轻惩罚既能掐复读,又不破坏 JSON / 结构化输出的稳定性。
+
+### 验证
+- `xcodebuild ... -destination generic/platform=iOS` 编译通过(两个后端均编进)。
+- ⚠️ **真机/模拟器跑一遍多轮导出生成报告**,确认不再复读 —— 复读属推理期行为,单测覆盖不到,必须实跑。
+
+### 预防 / 相关注意
+- 任何新增的「长文本生成」(非 JSON 抽取)都走同一套带惩罚的采样参数,别再裸 temperature。
+- **相关隐患(未修,留观)**:`HealthExportService.retrieveDialogueSnapshot` 取指标时
+  **没有 `prefix` 截断**(窗口检索版 `retrieve` 截了 `prefix(20)`)。指标极多时 prompt 会膨胀、
+  也更易诱发复读。若复发,优先给 dialogue snapshot 也加上限。
+
+---
+
+> 以下几条据 W1–W2(2026-05~06)记忆补记,细节以代码/提交为准。
+
+## 2026-06-09 · MNN 路径 Qwen3.5 强制思考,只吐 `<think>` / JSON 解析失败
+
+### 现象
+MNN 真机路径上模型自检只显示 `<think>` 思考过程,AI 辅助拿不到 JSON(解析失败);
+同样的 prompt 走 MLX 兜底却正常。
+
+### 根因
+模型自带 `config.json`(taobao-mnn 预转换件)写死 `"jinja":{"context":{"enable_thinking":true}}`,
+Qwen3.5 聊天模板据此每个 assistant 回合硬塞 `<think>\n` 开思考,吞掉 token 预算。
+**prompt 里的 `/no_think` 对 MNN 无效** —— 模板只读 `enable_thinking`,不看文本软开关。
+只在真机爆是因为 MLX 经 swift-transformers 套模板时不传 `enable_thinking` → 走 else 空 think 块,天然不思考。
+(这点从仓库代码看不出来,config.json 是下载/旁路导入的模型产物,不在 git 里。)
+
+### 修复
+`MNNLLMBridge.mm` 在 `createLLM` 后、`load()` 前 merge-patch 关闭:
+`set_config("{\"jinja\":{\"context\":{\"enable_thinking\":false}}}")`。不改模型文件、不动字节校验。`stripThink` 保留兜底。
+
+### 预防
+再遇 MNN 只出思考 / JSON 解析失败,先查 `config.json` 的 `enable_thinking`,别去调 `/no_think` 或加大预算。
+
+---
+
+## 2026-06-07 · 「记录指标·拍照识别」VL 直读化验单不稳 → 改 Vision OCR + LLM
+
+### 现象
+Qwen-VL 直读密集小字化验单经常返回 `{"indicators":[]}`(读不出指标)。
+
+### 根因 / 决策
+小模型 VL 对密集中文小字不稳。改链路:`DocumentScanner 整页扫描 → Apple Vision OCR(zh-Hans/Hant/en)
+→ Qwen3 LLM 解析(VLPrompts.indicatorsFromText)→ stripThink → parseIndicatorsJSON → 确认页人工校对 → 存`。
+Vision OCR 是系统框架、100% 本地,不违反隐私红线。
+
+### 预防
+这条路**不要改回 VL 直读**。VL 仍只用于「体检报告归档」整份解读,两者分开。OCR 行分组偶有错位,靠确认页人工校正兜底。
+
+---
+
+## 2026-06-01 · git 全量 push 撞 HTTP 413(历史里有 165MB 构建产物)
+
+### 现象
+`git push` 到 myv0(Gitea 反代有上传体积限制)报 **HTTP 413**。
+
+### 根因
+旧 commit 误把 `build/` 构建产物提交进库(最大单文件 xcarchive DWARF **165MB**),后来虽 `git rm --cached` + `.gitignore`,
+但对象仍留在历史 → `.git` 87MB,全量 push 超反代上限。
+
+### 修复
+对主仓库 `git filter-repo --path build/ --invert-paths --force` 从全历史剥离 → `.git` 87M→2.9M,不再 413。
+注意:① 重写了所有 commit hash(内容不变),旧克隆需重新 clone;② filter-repo 会移除所有 remote,事后须重新 `git remote add origin`;③ 凭证不写入 `.git/config`。
+
+### 预防
+`build/` 必须在 `.gitignore`;别把构建产物 / 大二进制提交进库。
+
+---
+
+## 2026-05-31 · 快拍 VL 识别时 App 自动退出(jetsam OOM,非崩溃)
+
+### 现象
+iPhone 15 Pro Max 上 VL 识别时 App 直接退出。
+
+### 根因
+不是代码崩溃(catch 只切 warning 屏,Swift 报错不会杀进程),是 **OS 内存超限 jetsam kill**。三因叠加:
+① 无 entitlement(8GB 设备默认单 App 上限 ~3GB,VL ~3GB 常驻冲过);② 从不卸载模型(LLM ~1GB + VL ~3GB 同驻 → 4GB+);③ 没设 MLX cache 上限。
+
+### 修复
+① 新建 `康康.entitlements` 加 `com.apple.developer.kernel.increased-memory-limit=true`;
+② `AIRuntime` 加 `unloadLLM/unloadVL` 做**常驻互斥**(两大模型永不同时驻留)+ actor 内**串行推理闸门**(GPU 同一时刻只一个解码/加载);
+③ `GPU.set(cacheLimit: 256MB)`,启动调一次。
+
+### 验证
+编译 + 单测通过。⚠️ **真机 OOM 是否真消失仍需 iPhone 15 Pro Max 实测**(本机无法跑真机)。
+
+---
+
+## 2026-05-30 · 每次重打包 SwiftData 数据被清空
+
+### 现象
+W2 期每次重新打包安装,本地数据全没了。
+
+### 根因
+`KangkangApp.swift` 里 `ModelContainer` 创建失败的 catch 块原本**直接删 store 文件**。
+SwiftData 只对纯增量改动自动轻量迁移;一旦 schema 改动超纲(最常见:**给已存在 `@Model` 新增「非可选且无内联默认值」属性**)→ 迁移抛错 → 进 catch → 删库。
+
+### 修复
+catch 改为把旧 store(含 `-wal`/`-shm`)挪到 `Application Support/StoreBackups/<时间戳>/` 再重建,不删除。
+
+### 预防
+给已存在 `@Model` 加属性**一律给可选或内联默认值**(如 `var x: String = "daily"`),才走轻量迁移。正式发布前升级为 `VersionedSchema` + `SchemaMigrationPlan`。
+
+---
+
+## (无明确日期)· 编辑 Localizable.xcstrings 炸出上万行噪声 diff
+
+### 现象
+改 `Localizable.xcstrings` 新增 3 个 key,却产生 ~15000 行 diff。
+
+### 根因
+仓库里该文件是 **Xcode 规范格式**(`"key" : {` 冒号两侧带空格、2 空格缩进、key 按 Xcode 排序、结尾无换行);
+用 `python json.dump(indent=2)` 重写会把分隔符变成 `": "` 且顺序不同 → 几乎每行都 diff。
+
+### 修复 / 正确做法
+基于 HEAD 原始文本做**文本插入**:把新 key 块按 Xcode 格式(`    "<key>" : ` + `separators=(',', ' : ')` 的 value)拼到 strings 段末尾,保持结尾无换行。**不要整文件 json.dump 回写**。
+
+---
+
+## 附:命令行编译方式(排查时拿真实错误/警告)
+
+- 系统默认是 Command Line Tools,裸 `xcodebuild` 不可用,需显式指向完整 Xcode:
+  `export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer`
+- **必须用独立 derivedDataPath**(如 `-derivedDataPath /tmp/kk-derived-xxx`),否则和 Xcode 抢同一把 `build.db` 锁报 `database is locked`(不是代码错)。
+- 增量编译会吞警告:要看某文件警告先 `touch` 它强制重编,再 grep `error:|warning:|BUILD (SUCCEEDED|FAILED)`。
+- 工程是 Swift 5 + `SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor`;跨到 `nonisolated` 调 MainActor 成员的隔离警告(标 "error in Swift 6 mode")在 Swift 5 下不阻塞构建。
+
+---
+
+## 模板(复制下面这段新增条目)
+
+```markdown
+## YYYY-MM-DD · 一句话标题
+
+### 现象
+（用户看到什么 / 怎么触发）
+
+### 根因(确认)
+（定位到的真正原因,不是猜测;贴关键文件:行)
+
+### 排查过程
+（怎么一步步定位的,方便下次复用思路)
+
+### 修复
+（改了什么,贴 diff 要点或配置)
+
+### 验证
+（怎么确认修好了;不能单测的要写明需实跑)
+
+### 预防 / 相关注意
+（怎么避免再犯;顺带发现的隐患)
+```
--- a/scripts/build-mnn-xcframework.sh
+++ b/scripts/build-mnn-xcframework.sh
@@ -0,0 +1,51 @@
+#!/bin/sh
+# 构建 MNN.xcframework(device arm64 + simulator arm64),含 LLM 引擎 + SME2。
+# 产物输出到 康康/../Frameworks/MNN.xcframework(被 .gitignore,不入库,防历史膨胀)。
+#
+# 用法:
+#   MNN_SRC=/path/to/MNN  sh scripts/build-mnn-xcframework.sh
+# 需求:CMake 3.14+、Xcode、约 10-40 分钟。
+#
+# 关键 flag:
+#   MNN_BUILD_LLM=ON       —— 编入 llm 引擎(并导出 llm/llm.hpp),自动开 MNN_LOW_MEMORY
+#   MNN_BUILD_LLM_OMNI=ON  —— VL(图→文)所需:多模态 Omni + OpenCV 图像解码。
+#                            统一模型(Qwen3.5-2B-MNN 一肩挑文本+视觉)必须开。
+#   MNN_SME2=ON            —— CMake 默认 ON,A19/iPhone17 运行时经 KleidiAI 自动启用,A17 回退 NEON
+#   MNN_METAL=OFF          —— 考核走 CPU+SME2,关 Metal 保持精简
+set -e
+
+MNN_SRC="${MNN_SRC:-/Users/xuhuayong/apps/MNN-src}"
+OUT_DIR="$(cd "$(dirname "$0")/.." && pwd)/Frameworks"
+TOOLCHAIN_NEW="${MNN_SRC}/cmake/ios.toolchain.new.cmake"
+EXTRA="-DMNN_BUILD_LLM=ON -DMNN_BUILD_LLM_OMNI=ON -DMNN_METAL=OFF -DMNN_ARM82=true -DMNN_SME2=ON"
+COMMON="-DCMAKE_BUILD_TYPE=Release -DENABLE_BITCODE=0 -DMNN_AAPL_FMWK=1 -DMNN_SEP_BUILD=0 -DMNN_BUILD_SHARED_LIBS=false -DMNN_USE_THREAD_POOL=OFF"
+
+export DEVELOPER_DIR="/Applications/Xcode.app/Contents/Developer"
+cd "$MNN_SRC"
+
+# 新版 ios-cmake toolchain(支持 SIMULATORARM64;MNN 自带的旧版只支持 x86_64 模拟器)
+if [ ! -f "$TOOLCHAIN_NEW" ]; then
+  curl -sL "https://raw.githubusercontent.com/leetal/ios-cmake/master/ios.toolchain.cmake" -o "$TOOLCHAIN_NEW"
+fi
+
+# device arm64
+rm -rf build-dev-arm64 && mkdir build-dev-arm64 && cd build-dev-arm64
+cmake .. $COMMON $EXTRA -DCMAKE_TOOLCHAIN_FILE="$TOOLCHAIN_NEW" -DPLATFORM=OS64 -DDEPLOYMENT_TARGET=17.0
+make MNN -j16
+cd ..
+
+# simulator arm64
+rm -rf build-sim-arm64 && mkdir build-sim-arm64 && cd build-sim-arm64
+cmake .. $COMMON $EXTRA -DCMAKE_TOOLCHAIN_FILE="$TOOLCHAIN_NEW" -DPLATFORM=SIMULATORARM64 -DDEPLOYMENT_TARGET=17.0
+make MNN -j16
+cd ..
+
+# 合成 xcframework
+rm -rf "$OUT_DIR/MNN.xcframework"
+mkdir -p "$OUT_DIR"
+xcrun xcodebuild -create-xcframework \
+  -framework build-dev-arm64/MNN.framework \
+  -framework build-sim-arm64/MNN.framework \
+  -output "$OUT_DIR/MNN.xcframework"
+
+echo "✅ 输出: $OUT_DIR/MNN.xcframework"
--- a/康康.xcodeproj/project.pbxproj
+++ b/康康.xcodeproj/project.pbxproj
@@ -10,6 +10,7 @@
 		FEED000000000000DEAD0001 /* MLXLLM in Frameworks */ = {isa = PBXBuildFile; productRef = FEED000000000000DEAD0003 /* MLXLLM */; };
 		FEED000000000000DEAD0002 /* MLXLMCommon in Frameworks */ = {isa = PBXBuildFile; productRef = FEED000000000000DEAD0004 /* MLXLMCommon */; };
 		FEED000000000000DEAD0005 /* MLXVLM in Frameworks */ = {isa = PBXBuildFile; productRef = FEED000000000000DEAD0006 /* MLXVLM */; };
+		FEEDFACE000000000000F002 /* MNN.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = FEEDFACE000000000000F001 /* MNN.xcframework */; };
 /* End PBXBuildFile section */

 /* Begin PBXContainerItemProxy section */
@@ -33,6 +34,7 @@
 		5E463CF92FC403BB0089145B /* 康康.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "康康.app"; sourceTree = BUILT_PRODUCTS_DIR; };
 		5E463D082FC403BC0089145B /* 康康Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "康康Tests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
 		5E463D122FC403BC0089145B /* 康康UITests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "康康UITests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
+		FEEDFACE000000000000F001 /* MNN.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = MNN.xcframework; path = Frameworks/MNN.xcframework; sourceTree = "<group>"; };
 /* End PBXFileReference section */

 /* Begin PBXFileSystemSynchronizedRootGroup section */
@@ -61,6 +63,7 @@
 				FEED000000000000DEAD0001 /* MLXLLM in Frameworks */,
 				FEED000000000000DEAD0002 /* MLXLMCommon in Frameworks */,
 				FEED000000000000DEAD0005 /* MLXVLM in Frameworks */,
+				FEEDFACE000000000000F002 /* MNN.xcframework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -88,6 +91,7 @@
 				5E463D0B2FC403BC0089145B /* 康康Tests */,
 				5E463D152FC403BC0089145B /* 康康UITests */,
 				5E463CFA2FC403BB0089145B /* Products */,
+				FEEDFACE000000000000F001 /* MNN.xcframework */,
 			);
 			sourceTree = "<group>";
 		};
@@ -211,7 +215,7 @@
 			mainGroup = 5E463CF02FC403BB0089145B;
 			minimizedProjectReferenceProxies = 1;
 			packageReferences = (
-				5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-examples" */,
+				5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-lm" */,
 			);
 			preferredProjectObjectVersion = 77;
 			productRefGroup = 5E463CFA2FC403BB0089145B /* Products */;
@@ -416,6 +420,7 @@
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SELECTED_FILES = readonly;
+				FRAMEWORK_SEARCH_PATHS = "$(PROJECT_DIR)/Frameworks";
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_KEY_CFBundleDisplayName = "康康";
 				INFOPLIST_KEY_ITSAppUsesNonExemptEncryption = NO;
@@ -423,8 +428,10 @@
 				INFOPLIST_KEY_NSFaceIDUsageDescription = "用于解锁你的健康档案,数据始终保留在本机。";
 				INFOPLIST_KEY_NSHealthShareUsageDescription = "康康会读取 Apple 健康中的生日、性别、身高和血型,用于本地填充个人资料,不会上传。";
 				INFOPLIST_KEY_NSHealthUpdateUsageDescription = "康康不会写入 Apple 健康数据。此说明用于满足 HealthKit 权限校验,你的健康资料只保留在本机。";
+				INFOPLIST_KEY_NSMicrophoneUsageDescription = "康康需要使用麦克风进行语音记录,识别全程在本机完成,声音不会上传。";
 				INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "康康会把识别后的报告原图加密保存到 App 沙盒,不会写入你的相册。";
 				INFOPLIST_KEY_NSPhotoLibraryUsageDescription = "康康需要读取你已有的体检/化验报告照片用于本地识别,不会上传。";
+				INFOPLIST_KEY_NSSpeechRecognitionUsageDescription = "语音转文字使用 iOS 端侧识别,内容不会发送给 Apple 或任何服务器。";
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphonesimulator*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents[sdk=iphoneos*]" = YES;
@@ -450,6 +457,7 @@
 				SWIFT_APPROACHABLE_CONCURRENCY = YES;
 				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
 				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_OBJC_BRIDGING_HEADER = "康康/康康-Bridging-Header.h";
 				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
@@ -470,6 +478,7 @@
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SELECTED_FILES = readonly;
+				FRAMEWORK_SEARCH_PATHS = "$(PROJECT_DIR)/Frameworks";
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_KEY_CFBundleDisplayName = "康康";
 				INFOPLIST_KEY_ITSAppUsesNonExemptEncryption = NO;
@@ -477,8 +486,10 @@
 				INFOPLIST_KEY_NSFaceIDUsageDescription = "用于解锁你的健康档案,数据始终保留在本机。";
 				INFOPLIST_KEY_NSHealthShareUsageDescription = "康康会读取 Apple 健康中的生日、性别、身高和血型,用于本地填充个人资料,不会上传。";
 				INFOPLIST_KEY_NSHealthUpdateUsageDescription = "康康不会写入 Apple 健康数据。此说明用于满足 HealthKit 权限校验,你的健康资料只保留在本机。";
+				INFOPLIST_KEY_NSMicrophoneUsageDescription = "康康需要使用麦克风进行语音记录,识别全程在本机完成,声音不会上传。";
 				INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "康康会把识别后的报告原图加密保存到 App 沙盒,不会写入你的相册。";
 				INFOPLIST_KEY_NSPhotoLibraryUsageDescription = "康康需要读取你已有的体检/化验报告照片用于本地识别,不会上传。";
+				INFOPLIST_KEY_NSSpeechRecognitionUsageDescription = "语音转文字使用 iOS 端侧识别,内容不会发送给 Apple 或任何服务器。";
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphonesimulator*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents[sdk=iphoneos*]" = YES;
@@ -504,6 +515,7 @@
 				SWIFT_APPROACHABLE_CONCURRENCY = YES;
 				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
 				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_OBJC_BRIDGING_HEADER = "康康/康康-Bridging-Header.h";
 				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
@@ -659,12 +671,12 @@
 /* End XCConfigurationList section */

 /* Begin XCRemoteSwiftPackageReference section */
-		5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-examples" */ = {
+		5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-lm" */ = {
 			isa = XCRemoteSwiftPackageReference;
-			repositoryURL = "https://github.com/ml-explore/mlx-swift-examples";
+			repositoryURL = "https://github.com/ml-explore/mlx-swift-lm";
 			requirement = {
-				kind = upToNextMajorVersion;
-				minimumVersion = 2.29.1;
+				kind = exactVersion;
+				version = 2.31.3;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */
@@ -672,17 +684,17 @@
 /* Begin XCSwiftPackageProductDependency section */
 		FEED000000000000DEAD0003 /* MLXLLM */ = {
 			isa = XCSwiftPackageProductDependency;
-			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-examples" */;
+			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-lm" */;
 			productName = MLXLLM;
 		};
 		FEED000000000000DEAD0004 /* MLXLMCommon */ = {
 			isa = XCSwiftPackageProductDependency;
-			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-examples" */;
+			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-lm" */;
 			productName = MLXLMCommon;
 		};
 		FEED000000000000DEAD0006 /* MLXVLM */ = {
 			isa = XCSwiftPackageProductDependency;
-			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-examples" */;
+			package = 5E9A1F872FC43C9A0097DD29 /* XCRemoteSwiftPackageReference "mlx-swift-lm" */;
 			productName = MLXVLM;
 		};
 /* End XCSwiftPackageProductDependency section */
--- a/康康.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/康康.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -1,13 +1,13 @@
 {
-  "originHash" : "6b8265ebd61c6fdfca835dd1f90f17439ca9abc5c11a8b7b5db8790be0349e4d",
+  "originHash" : "facc0ac7c70363ea20f6cd1235de91dea6b06f0d00190946045a6c8ae753abc2",
  "pins" : [
    {
-      "identity" : "gzipswift",
+      "identity" : "eventsource",
      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/1024jp/GzipSwift",
+      "location" : "https://github.com/mattt/EventSource.git",
      "state" : {
-        "revision" : "731037f6cc2be2ec01562f6597c1d0aa3fe6fd05",
-        "version" : "6.0.1"
+        "revision" : "a3a85a85214caf642abaa96ae664e4c772a59f6e",
+        "version" : "1.4.1"
      }
    },
    {
@@ -15,17 +15,35 @@
      "kind" : "remoteSourceControl",
      "location" : "https://github.com/ml-explore/mlx-swift",
      "state" : {
-        "revision" : "072b684acaae80b6a463abab3a103732f33774bf",
-        "version" : "0.29.1"
+        "revision" : "dc43e62d7055353c7f99fa071a4e71d29dfddc44",
+        "version" : "0.31.4"
      }
    },
    {
-      "identity" : "mlx-swift-examples",
+      "identity" : "mlx-swift-lm",
      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/ml-explore/mlx-swift-examples",
+      "location" : "https://github.com/ml-explore/mlx-swift-lm",
      "state" : {
-        "revision" : "9bff95ca5f0b9e8c021acc4d71a2bbe4a7441631",
-        "version" : "2.29.1"
+        "revision" : "25b00d4e22e61ec9c41efda47990cd2084ec87ff",
+        "version" : "2.31.3"
+      }
+    },
+    {
+      "identity" : "swift-asn1",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-asn1.git",
+      "state" : {
+        "revision" : "eb50cbd14606a9161cbc5d452f18797c90ef0bab",
+        "version" : "1.7.0"
+      }
+    },
+    {
+      "identity" : "swift-atomics",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-atomics.git",
+      "state" : {
+        "revision" : "b601256eab081c0f92f059e12818ac1d4f178ff7",
+        "version" : "1.3.0"
      }
    },
    {
@@ -37,6 +55,24 @@
        "version" : "1.5.1"
      }
    },
+    {
+      "identity" : "swift-crypto",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-crypto.git",
+      "state" : {
+        "revision" : "1b6b2e274e85105bfa155183145a1dcfd63331f1",
+        "version" : "4.5.0"
+      }
+    },
+    {
+      "identity" : "swift-huggingface",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/huggingface/swift-huggingface.git",
+      "state" : {
+        "revision" : "b721959445b617d0bf03910b2b4aced345fd93bf",
+        "version" : "0.9.0"
+      }
+    },
    {
      "identity" : "swift-jinja",
      "kind" : "remoteSourceControl",
@@ -46,6 +82,15 @@
        "version" : "2.3.6"
      }
    },
+    {
+      "identity" : "swift-nio",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-nio.git",
+      "state" : {
+        "revision" : "57c0a08a331aaea9f5d7a932ad94ef43be942a95",
+        "version" : "2.100.0"
+      }
+    },
    {
      "identity" : "swift-numerics",
      "kind" : "remoteSourceControl",
@@ -55,13 +100,31 @@
        "version" : "1.1.1"
      }
    },
+    {
+      "identity" : "swift-system",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-system.git",
+      "state" : {
+        "revision" : "669763cfd5806a67e21972d7e5e2d6b80b1ea985",
+        "version" : "1.6.5"
+      }
+    },
    {
      "identity" : "swift-transformers",
      "kind" : "remoteSourceControl",
      "location" : "https://github.com/huggingface/swift-transformers",
      "state" : {
-        "revision" : "a2e184dddb4757bc943e77fbe99ac6786c53f0b2",
-        "version" : "1.0.0"
+        "revision" : "58c4bc11963a140358d791f678a60a2745a23146",
+        "version" : "1.2.1"
+      }
+    },
+    {
+      "identity" : "yyjson",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/ibireme/yyjson.git",
+      "state" : {
+        "revision" : "8b4a38dc994a110abaec8a400615567bd996105f",
+        "version" : "0.12.0"
      }
    }
  ],
--- a/康康/AI/AIRuntime.swift
+++ b/康康/AI/AIRuntime.swift
@@ -15,6 +15,13 @@ enum AIRuntimeError: Error, LocalizedError {
    }
 }

+/// 推理优先级。interactive = 用户正在屏幕前等(识别/问答/自检);
+/// background = 预生成(报告摘要等),排队让行、解码中可被协作式抢占。
+nonisolated enum InferencePriority: Sendable, Equatable {
+    case interactive
+    case background
+}
+
 actor AIRuntime {
    static let shared = AIRuntime()

@@ -29,9 +36,34 @@ actor AIRuntime {
    private(set) var vlStatus: Status = .notReady
    private(set) var lastDecodeRate: Double = 0

+    /// 末次文本生成的性能统计(性能自检页消费;两后端归一)。
+    private(set) var lastGenerateStats: GenerateStats?
+
+    /// 当前实际生效的后端标签(性能自检 / PPT 截图用)。
+    var activeBackendLabel: String {
+        if InferenceEngine.current == .mnn, mnnStatus == .ready {
+            return InferenceEngine.cpuSupportsSME2 ? "MNN · SME2" : "MNN · NEON"
+        }
+        #if targetEnvironment(simulator)
+        return "MLX · CPU(模拟器)"
+        #else
+        return "MLX · GPU"
+        #endif
+    }
+
    private var llmSession: LLMSession?
    private var vlSession: VLSession?

+    // MARK: - MNN 后端(CPU/SME2,挑战赛考核路径)
+    // .mnn 引擎下,文本生成与 VL(图→文)由同一个 Qwen3.5-2B 多模态 MNN 模型全包(已实测)。
+    // 模拟器无 MNN,VL 回退 MLX 的 Qwen3-VL-4B。
+    private let mnn = MNNBackend()
+    private(set) var mnnStatus: Status = .notReady
+    /// MNN 模型目录(下载/旁路导入到 Models/Qwen3.5-2B-MNN)。
+    nonisolated static var mnnModelFolder: URL {
+        ModelStore.shared.localURL(for: .mnnLLM)
+    }
+
    // MARK: - 串行推理闸门(§3.1 OOM 防护的真正落地)
    //
    // actor 只串行化「方法入口」,但 generate() 同步返回流、真正解码在内部 Task;
@@ -42,30 +74,56 @@ actor AIRuntime {
    // 这里用 actor 内信号量(count = 1):所有「会占显存的重活」(解码 + 模型加载)
    // 进入前先 await acquireGate(),结束后 releaseGate()。actor 串行执行保证
    // gateBusy / gateWaiters 的读写天然无并发。
+    private struct GateWaiter {
+        let priority: InferencePriority
+        let cont: CheckedContinuation<Void, Never>
+    }
    private var gateBusy = false
-    private var gateWaiters: [CheckedContinuation<Void, Never>] = []
+    private var gateHolderPriority: InferencePriority = .interactive
+    private var preemptRequested = false
+    private var gateWaiters: [GateWaiter] = []

-    private func acquireGate() async {
+    /// interactive 排到所有 background 等待者之前;同优先级保持 FIFO。纯函数,单测覆盖。
+    nonisolated static func gateInsertionIndex(of priority: InferencePriority,
+                                               in waiting: [InferencePriority]) -> Int {
+        guard priority == .interactive else { return waiting.count }
+        return waiting.firstIndex(of: .background) ?? waiting.count
+    }
+
+    private func acquireGate(_ priority: InferencePriority = .interactive) async {
        if !gateBusy {
            gateBusy = true
+            gateHolderPriority = priority
            return
        }
+        // 前台请求撞上后台持有者:请其让位 —— 后台解码循环在下一个 token 抛 CancellationError。
+        if priority == .interactive, gateHolderPriority == .background {
+            preemptRequested = true
+        }
        await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
-            gateWaiters.append(cont)
+            let idx = Self.gateInsertionIndex(of: priority, in: gateWaiters.map(\.priority))
+            gateWaiters.insert(GateWaiter(priority: priority, cont: cont), at: idx)
        }
        // 被 releaseGate 唤醒时即已持有闸门(gateBusy 保持 true)。
    }

    private func releaseGate() {
+        preemptRequested = false
        if gateWaiters.isEmpty {
            gateBusy = false
        } else {
            // 把闸门直接交给队首等待者,gateBusy 维持 true,不留空窗。
            let next = gateWaiters.removeFirst()
-            next.resume()
+            gateHolderPriority = next.priority
+            next.cont.resume()
        }
    }

+    /// 后台持有者每收到一个 token 查一次:前台在排队就让位。
+    private func shouldPreempt(_ priority: InferencePriority) -> Bool {
+        priority == .background && preemptRequested
+    }
+
    private init() {}

    /// App 启动时调用一次:给 MLX 的 GPU 缓冲池设上限,避免 reuse cache 在大模型常驻之上
@@ -74,12 +132,22 @@ actor AIRuntime {
    nonisolated static func configureMLXMemory() {
        #if !targetEnvironment(simulator)
        // 256MB cache 上限:够复用、不至于在 3GB 模型之上再囤几百 MB 空闲缓冲。
-        MLX.GPU.set(cacheLimit: 256 * 1024 * 1024)
+        MLX.Memory.cacheLimit = 256 * 1024 * 1024
        #endif
    }

-    /// 加载模型。首次调用会真正加载,后续幂等。
+    /// 加载文本模型。首次调用会真正加载,后续幂等。
+    /// 按当前引擎路由:.mnn → MNN(CPU/SME2);.mlx → 现有 MLX(GPU)。
    func prepare() async throws {
+        // 选了 MNN 且模型已就绪才走 MNN;否则(选 MLX,或 MNN 模型尚未下载)回退 MLX,
+        // 保证过渡期 App 始终可用。引擎指示器(Phase 5)展示实际生效后端。
+        let mnnReady = ModelStore.shared.isComplete(for: .mnnLLM)
+        if InferenceEngine.current == .mnn, mnnReady {
+            try await prepareMNN()
+            return
+        }
+        // 走 MLX:先卸 MNN 释放内存(单模型常驻策略)。
+        await unloadMNN()
        // 已有其他调用方在加载时,轮询等其结束再判定结果。
        // 不能像旧实现那样裸 return:那会让调用方误以为已 ready,随后 generate 的
        // `guard status == .ready` 失败 → 用户撞上「假错误屏」(模型其实正常加载中)。
@@ -119,9 +187,54 @@ actor AIRuntime {
        }
    }

+    /// 加载 MNN 文本模型。幂等。单模型常驻:载入前卸掉 MLX 的 LLM/VL 释放内存。
+    private func prepareMNN() async throws {
+        while mnnStatus == .loading {
+            try await Task.sleep(nanoseconds: 80_000_000)
+        }
+        if mnnStatus == .ready { return }
+
+        let folder = Self.mnnModelFolder
+        guard ModelStore.shared.isComplete(for: .mnnLLM) else {
+            mnnStatus = .error("MNN 模型未就绪")
+            throw AIRuntimeError.notReady
+        }
+
+        await acquireGate()
+        defer { releaseGate() }
+        if mnnStatus == .ready { return }
+
+        // 单模型常驻:卸 MLX LLM/VL,避免与 MNN 模型叠加占内存。
+        unloadLLM()
+        unloadVL()
+
+        mnnStatus = .loading
+        do {
+            try await mnn.load(folderURL: folder)
+            mnnStatus = .ready
+        } catch {
+            mnnStatus = .error("\(error)")
+            throw AIRuntimeError.modelLoadFailed("\(error)")
+        }
+    }
+
+    /// 卸载 MNN,释放桥与权重。幂等。
+    private func unloadMNN() async {
+        guard mnnStatus != .notReady else { return }
+        await mnn.unload()
+        mnnStatus = .notReady
+        MLX.Memory.clearCache()
+    }
+
    /// 流式生成。调用前应先 await prepare()。
    /// 注意:返回流是同步创建的,但跨 actor 调用 LLMSession 需要 await。
-    func generate(prompt: String, maxTokens: Int = 256) -> AsyncThrowingStream<TokenChunk, Error> {
+    /// priority = .background 时排队让行、解码中可被前台请求按 token 抢占(CancellationError 透传)。
+    func generate(prompt: String,
+                  maxTokens: Int = 256,
+                  priority: InferencePriority = .interactive) -> AsyncThrowingStream<TokenChunk, Error> {
+        if InferenceEngine.current == .mnn, mnnStatus == .ready {
+            return mnnGenerate(prompt: prompt, maxTokens: maxTokens, priority: priority)
+        }
        // 在 actor 隔离上下文中捕获快照,Task 内不再访问 self.status / self.llmSession
        let snapshotStatus = status
        let snapshotSession = llmSession
@@ -133,7 +246,7 @@ actor AIRuntime {
                    return
                }
                // 进闸门:保证本次 LLM 解码与任何 VL 解码 / 模型加载串行,绝不并发占显存。
-                await self.acquireGate()
+                await self.acquireGate(priority)
                do {
                    // session.generate 跨 actor 边界,需要 await
                    let stream = await session.generate(prompt: prompt, maxTokens: maxTokens)
@@ -141,12 +254,18 @@ actor AIRuntime {
                        // 消费者(UI)提前关闭/取消时,下面的 checkCancellation 让本 Task 尽快退出,
                        // 连带丢弃 session 流并触发其 onTermination,停止底层 MLX 解码,不空耗 GPU。
                        try Task.checkCancellation()
+                        // 后台任务让位:前台请求在排队时,下一个 token 处主动退出。
+                        if self.shouldPreempt(priority) { throw CancellationError() }
                        // Task 闭包在 generate() 内启动,继承 AIRuntime 的 actor 隔离;
                        // 调用同 actor 的 recordRate 不需要 await
                        self.recordRate(chunk.decodeRate)
                        continuation.yield(chunk)
                    }
+                    self.lastGenerateStats = await session.lastStats
                    continuation.finish()
+                } catch is CancellationError {
+                    // 取消/抢占以 CancellationError 透传,调用方据此区分「让位」与「真失败」。
+                    continuation.finish(throwing: CancellationError())
                } catch {
                    continuation.finish(throwing: AIRuntimeError.inferenceFailed("\(error)"))
                }
@@ -159,6 +278,41 @@ actor AIRuntime {
        }
    }

+    /// MNN(CPU/SME2)文本流式生成。结构与 MLX 分支一致:进闸门、串行解码、记录速率。
+    private func mnnGenerate(prompt: String,
+                             maxTokens: Int,
+                             priority: InferencePriority) -> AsyncThrowingStream<TokenChunk, Error> {
+        let ready = (mnnStatus == .ready)
+        return AsyncThrowingStream { continuation in
+            let task = Task {
+                guard ready else {
+                    continuation.finish(throwing: AIRuntimeError.notReady)
+                    return
+                }
+                await self.acquireGate(priority)
+                do {
+                    let stream = await self.mnn.generate(prompt: prompt, maxTokens: maxTokens)
+                    for try await chunk in stream {
+                        try Task.checkCancellation()
+                        // 后台任务让位:前台请求在排队时,下一个 token 处主动退出
+                        //(流终止触发 MNNBackend.onTermination → bridge.cancel())。
+                        if self.shouldPreempt(priority) { throw CancellationError() }
+                        self.recordRate(chunk.decodeRate)
+                        continuation.yield(chunk)
+                    }
+                    self.lastGenerateStats = await self.mnn.lastStats
+                    continuation.finish()
+                } catch is CancellationError {
+                    continuation.finish(throwing: CancellationError())
+                } catch {
+                    continuation.finish(throwing: AIRuntimeError.inferenceFailed("\(error)"))
+                }
+                self.releaseGate()
+            }
+            continuation.onTermination = { _ in task.cancel() }
+        }
+    }
+
    private func recordRate(_ rate: Double) {
        if rate > 0 { lastDecodeRate = rate }
    }
@@ -167,30 +321,37 @@ actor AIRuntime {

    /// 加载 VL 模型。幂等,首调真正 load。
    func prepareVL() async throws {
+        // 选了 MNN 且多模态模型就绪:VL 复用同一个 MNN 模型(文本+视觉一肩挑),走 prepareMNN。
+        if InferenceEngine.current == .mnn, ModelStore.shared.isComplete(for: .mnnLLM) {
+            try await prepareMNN()
+            return
+        }
        while vlStatus == .loading {
            try await Task.sleep(nanoseconds: 80_000_000)
        }
        if vlStatus == .ready { return }

-        // 同 prepare():用 isComplete 排除半下载(避免在残缺权重上崩溃),与下载服务判据一致。
-        guard ModelStore.shared.isComplete(for: .vl) else {
+        // MLX VL 改用 .llm 的 Qwen3.5-2B 多模态(VLMModelFactory 走 qwen3_5 视觉路径),
+        // 不再单独需要 Qwen3-VL-4B。用 isComplete 排除半下载,与下载服务判据一致。
+        guard ModelStore.shared.isComplete(for: .llm) else {
            vlStatus = .error("VL 模型未就绪")
            throw AIRuntimeError.notReady
        }

        // 进闸门:等所有在跑的推理(可能是 LLM 文本流)结束,再卸 LLM + 载 VL。
-        // —— 这正是「异常项快拍识别时 App 自动退出」的主因防护。
+        // —— 这正是「指标速记识别时 App 自动退出」的主因防护。
        await acquireGate()
        defer { releaseGate() }
        if vlStatus == .ready { return }

        // OOM 闸门(§3.1):加载 VL(~3GB)前先卸 LLM(~1GB),否则两者常驻叠加冲过内存上限被 jetsam 杀。
        unloadLLM()
+        await unloadMNN()

        vlStatus = .loading
        do {
            let session = try await VLSession.load(
-                folderURL: ModelStore.shared.localURL(for: .vl)
+                folderURL: ModelStore.shared.localURL(for: .llm)
            )
            self.vlSession = session
            vlStatus = .ready
@@ -208,7 +369,7 @@ actor AIRuntime {
        guard llmSession != nil else { return }
        llmSession = nil
        status = .notReady
-        MLX.GPU.clearCache()
+        MLX.Memory.clearCache()
    }

    /// 卸载 VL,释放 ModelContainer 引用并清 MLX 显存缓存。幂等。
@@ -216,7 +377,7 @@ actor AIRuntime {
        guard vlSession != nil else { return }
        vlSession = nil
        vlStatus = .notReady
-        MLX.GPU.clearCache()
+        MLX.Memory.clearCache()
    }

    /// 图像 → JSON 字符串(由 VLPrompts.reportExtraction 引导)。
@@ -225,6 +386,16 @@ actor AIRuntime {
    func analyzeReport(imageURLs: [URL],
                       prompt: String,
                       maxTokens: Int = 512) async throws -> String {
+        // 选了 MNN 且就绪:图→文走同一个 MNN 多模态模型。
+        if InferenceEngine.current == .mnn, mnnStatus == .ready {
+            await acquireGate()
+            defer { releaseGate() }
+            do {
+                return try await mnn.analyze(imageURLs: imageURLs, prompt: prompt, maxTokens: maxTokens)
+            } catch {
+                throw AIRuntimeError.inferenceFailed("\(error)")
+            }
+        }
        guard vlStatus == .ready, let session = vlSession else {
            throw AIRuntimeError.notReady
        }
--- a/康康/AI/GenerateStats.swift
+++ b/康康/AI/GenerateStats.swift
@@ -0,0 +1,19 @@
+import Foundation
+
+/// 单次生成的性能统计,两后端(MNN / MLX)归一。
+/// MNN 取自 LlmContext(prefill_us / decode_us);MLX 取自 GenerateCompletionInfo。
+struct GenerateStats: Sendable, Equatable {
+    var promptTokens: Int
+    var genTokens: Int
+    /// prefill(读入 prompt)耗时,秒。
+    var prefillSeconds: Double
+    /// decode(逐 token 生成)耗时,秒。
+    var decodeSeconds: Double
+
+    var prefillTokensPerSecond: Double {
+        prefillSeconds > 0 ? Double(promptTokens) / prefillSeconds : 0
+    }
+    var decodeTokensPerSecond: Double {
+        decodeSeconds > 0 ? Double(genTokens) / decodeSeconds : 0
+    }
+}
--- a/康康/AI/InferenceEngine.swift
+++ b/康康/AI/InferenceEngine.swift
@@ -0,0 +1,77 @@
+import Foundation
+
+/// 端侧推理引擎选择。
+/// - mnn:Qwen + MNN + SME2(CPU),挑战赛考核路径,真机默认。
+/// - mlx:Qwen + MLX(Metal GPU),兜底 / 对照。模拟器只有它可用。
+nonisolated enum InferenceEngine: String, CaseIterable, Sendable {
+    case mnn
+    case mlx
+
+    var displayName: String {
+        switch self {
+        case .mnn: return "MNN · CPU/SME2"
+        case .mlx: return "MLX · GPU"
+        }
+    }
+
+    /// 本构建/设备是否可用。MNN 仅 device 切片有真实内核,模拟器回退 MLX。
+    var isAvailable: Bool {
+        switch self {
+        case .mlx: return true
+        case .mnn: return MNNLLMBridge.isAvailable()
+        }
+    }
+
+    // MARK: - 持久化(UserDefaults,跨 actor 安全)
+
+    private static let key = "kk.inferenceEngine"
+
+    /// 由偏好(可能是 .auto)解析出的、本次调用实际使用的具体引擎。
+    /// AIRuntime / MeView 等消费方只看这个,永远拿到 .mnn 或 .mlx。
+    /// 解析后仍做一次可用性兜底,保证总有可用引擎。
+    static var current: InferenceEngine {
+        let resolved = preference.resolved
+        return resolved.isAvailable ? resolved : .mlx
+    }
+
+    /// 运行时探测:CPU 是否支持 SME2(A19/iPhone17+)。用于 UI 展示加速状态。
+    static var cpuSupportsSME2: Bool { MNNLLMBridge.cpuSupportsSME2() }
+
+    // MARK: - 用户偏好(auto / mnn / mlx)
+
+    /// 用户在设置页的选择。默认 .auto:按本机配置自动择优。
+    /// 与具体引擎共用同一 UserDefaults key——历史写入的 "mnn"/"mlx" 仍兼容。
+    static var preference: EnginePreference {
+        get {
+            let raw = UserDefaults.standard.string(forKey: key)
+            return raw.flatMap(EnginePreference.init(rawValue:)) ?? .auto
+        }
+        set { UserDefaults.standard.set(newValue.rawValue, forKey: key) }
+    }
+}
+
+/// 推理引擎的「用户偏好」,比具体引擎多一个 .auto。
+/// - auto:按本机配置自动选——真机优先 MNN(考核路径,含 SME2/NEON),
+///         MNN 不可用(模拟器)时回退 MLX。
+nonisolated enum EnginePreference: String, CaseIterable, Sendable {
+    case auto
+    case mnn
+    case mlx
+
+    var displayName: String {
+        switch self {
+        case .auto: return "自动"
+        case .mnn:  return InferenceEngine.mnn.displayName
+        case .mlx:  return InferenceEngine.mlx.displayName
+        }
+    }
+
+    /// 把偏好解析成具体引擎(不做可用性兜底,那一步留给 `InferenceEngine.current`)。
+    var resolved: InferenceEngine {
+        switch self {
+        case .mnn:  return .mnn
+        case .mlx:  return .mlx
+        case .auto: return InferenceEngine.mnn.isAvailable ? .mnn : .mlx
+        }
+    }
+}
--- a/康康/AI/LLMSession.swift
+++ b/康康/AI/LLMSession.swift
@@ -8,6 +8,11 @@ import MLXLMCommon
 actor LLMSession {
    let container: ModelContainer

+    /// 末次生成统计(取自流末尾的 .info 完成事件,性能自检用)。
+    private(set) var lastStats: GenerateStats?
+
+    private func record(_ s: GenerateStats) { lastStats = s }
+
    init(container: ModelContainer) {
        self.container = container
    }
@@ -45,10 +50,16 @@ actor LLMSession {
            let task = Task {
                do {
                    try await Self.withDeviceOverride {
+                        // 低温:本 App 文本任务多为"直答/JSON 抽取",高温随机性会经常吐成非 JSON。
+                        // 0.3 + topP 0.85 让输出更确定、JSON 更稳(与 MNN set_config 降温对齐)。
+                        // repetitionPenalty:低温 + 无惩罚时,长文本(如「关键指标」列表)会逐行复读
+                        // 进入死循环;1.1 的重复惩罚 + 64 token 上下文窗口掐断复读(与 MNN penalty 对齐)。
                        let parameters = GenerateParameters(
                            maxTokens: maxTokens,
-                            temperature: Float(0.6),
-                            topP: Float(0.9)
+                            temperature: Float(0.3),
+                            topP: Float(0.85),
+                            repetitionPenalty: Float(1.1),
+                            repetitionContextSize: 64
                        )

                        try await container.perform { (context: ModelContext) in
@@ -72,9 +83,14 @@ actor LLMSession {
                                    let rate = elapsed > 0 ? Double(produced) / elapsed : 0
                                    continuation.yield(TokenChunk(text: text, decodeRate: rate))

-                                case .info:
+                                case .info(let info):
                                    // 生成完成统计,是流的最后一个事件
-                                    break
+                                    await self.record(GenerateStats(
+                                        promptTokens: info.promptTokenCount,
+                                        genTokens: info.generationTokenCount,
+                                        prefillSeconds: info.promptTime,
+                                        decodeSeconds: info.generateTime
+                                    ))

                                case .toolCall:
                                    // 纯文本生成不会触发,switch 穷举
--- a/康康/AI/MNN/MNNLLMBridge.h
+++ b/康康/AI/MNN/MNNLLMBridge.h
@@ -0,0 +1,55 @@
+//
+//  MNNLLMBridge.h
+//  康康
+//
+//  Objective-C 接口,封装 MNN-LLM(Qwen)的加载与流式推理。
+//  真实实现在 .mm 中以 ObjC++ 调用 <MNN/llm/llm.hpp>;模拟器下编为可用性返回 NO 的桩
+//  (MNN.framework 仅 device arm64 切片有真实 CPU/SME2 内核,模拟器走 MLX 兜底)。
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// 末次生成的性能统计(取自 MNN LlmContext)。
+@interface MNNGenerateStats : NSObject
+@property (nonatomic, readonly) int promptTokens;
+@property (nonatomic, readonly) int genTokens;
+@property (nonatomic, readonly) double prefillMs;
+@property (nonatomic, readonly) double decodeMs;
+/// 解码速率 tok/s = genTokens / (decodeMs/1000)。demo 卖点 #6 / Live Activity 用。
+@property (nonatomic, readonly) double decodeTokensPerSecond;
+@end
+
+@interface MNNLLMBridge : NSObject
+
+/// 本构建是否含真实 MNN 运行时(device=YES,simulator 桩=NO)。
+ (BOOL)isAvailable;
+/// CPU 是否支持 SME2(运行时探测);A19/iPhone17 YES,A17/iPhone15Pro NO。仅用于 UI 展示加速状态。
+ (BOOL)cpuSupportsSME2;
+
+/// 用 MNN llm 的 config.json 路径加载模型(目录含 llm.mnn / 权重 / tokenizer)。失败返回 nil。
+- (nullable instancetype)initWithConfigPath:(NSString *)configPath;
+
+@property (nonatomic, readonly) BOOL isLoaded;
+
+/// 纯文本流式生成。onToken 每解码出一段文本回调一次(在调用线程,同步阻塞直到生成结束)。
+/// 返回末次统计。
+- (MNNGenerateStats *)generateText:(NSString *)prompt
+                         maxTokens:(int)maxTokens
+                           onToken:(void (^)(NSString *piece))onToken;
+
+/// 图→文(VL,需 MNN_BUILD_LLM_OMNI 构建)。imagePaths 为本地文件路径。
+/// 当前文本构建未含 OMNI 时返回 nil 并置 error。
+- (nullable MNNGenerateStats *)analyzeImages:(NSArray<NSString *> *)imagePaths
+                                      prompt:(NSString *)prompt
+                                   maxTokens:(int)maxTokens
+                                     onToken:(void (^)(NSString *piece))onToken
+                                       error:(NSError *_Nullable *_Nullable)error;
+
+/// 请求取消当前生成(best-effort:置标志,后续 token 不再回调)。
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END
--- a/康康/AI/MNN/MNNLLMBridge.mm
+++ b/康康/AI/MNN/MNNLLMBridge.mm
@@ -0,0 +1,210 @@
+//
+//  MNNLLMBridge.mm
+//  康康
+//
+//  ObjC++ 实现。device 真机用 <MNN/llm/llm.hpp>;模拟器编为桩(返回不可用,上层回退 MLX)。
+//
+
+#import "MNNLLMBridge.h"
+#include <sys/sysctl.h>
+
+// MARK: - 性能统计(私有 readwrite 重声明)
+@interface MNNGenerateStats ()
+@property (nonatomic, readwrite) int promptTokens;
+@property (nonatomic, readwrite) int genTokens;
+@property (nonatomic, readwrite) double prefillMs;
+@property (nonatomic, readwrite) double decodeMs;
+@end
+
+@implementation MNNGenerateStats
+- (double)decodeTokensPerSecond {
+    return self.decodeMs > 0 ? (self.genTokens / (self.decodeMs / 1000.0)) : 0;
+}
+@end
+
+// MARK: - SME2 / 可用性探测(device + simulator 都可编)
+
+static BOOL kk_sysctlFlag(const char *name) {
+    int64_t v = 0; size_t sz = sizeof(v);
+    if (sysctlbyname(name, &v, &sz, NULL, 0) != 0) return NO;
+    return v != 0;
+}
+
+#if TARGET_OS_SIMULATOR
+
+// ============ 模拟器桩:无真实 MNN ============
+@implementation MNNLLMBridge
+ (BOOL)isAvailable { return NO; }
+ (BOOL)cpuSupportsSME2 { return NO; }
+- (nullable instancetype)initWithConfigPath:(NSString *)configPath { return nil; }
+- (BOOL)isLoaded { return NO; }
+- (MNNGenerateStats *)generateText:(NSString *)prompt maxTokens:(int)maxTokens
+                           onToken:(void (^)(NSString *))onToken { return [MNNGenerateStats new]; }
+- (nullable MNNGenerateStats *)analyzeImages:(NSArray<NSString *> *)imagePaths prompt:(NSString *)prompt
+                                   maxTokens:(int)maxTokens onToken:(void (^)(NSString *))onToken
+                                       error:(NSError **)error {
+    if (error) *error = [NSError errorWithDomain:@"MNN" code:-1
+                          userInfo:@{NSLocalizedDescriptionKey: @"MNN 在模拟器不可用"}];
+    return nil;
+}
+- (void)cancel {}
+@end
+
+#else
+
+// ============ 真机:真实 MNN-LLM ============
+// MNN 第三方头文件的文档注释不规范,会触发一堆 -Wdocumentation 警告(Executor/
+// Tensor/Interpreter/ImageProcess.hpp)。只在解析 MNN 头时关掉该警告,不影响本项目。
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include <MNN/llm/llm.hpp>
+#pragma clang diagnostic pop
+#include <string>
+#include <ostream>
+#include <streambuf>
+#include <atomic>
+
+using MNN::Transformer::Llm;
+
+namespace {
+/// 把 MNN 写入 ostream 的解码文本转成 NSString 回调;按 UTF-8 完整边界聚合,避免截断多字节。
+class TokenStreamBuf : public std::streambuf {
+public:
+    TokenStreamBuf(void (^onToken)(NSString *), std::atomic<bool> *cancel)
+        : _onToken(onToken), _cancel(cancel) {}
+    void flush() {
+        if (_pending.empty()) return;
+        emitPending(); // 末尾尽力 emit(即便非完整 UTF-8 也交出去)
+        _pending.clear();
+    }
+protected:
+    std::streamsize xsputn(const char *s, std::streamsize n) override {
+        append(s, (size_t)n);
+        return n;
+    }
+    int overflow(int c) override {
+        if (c != EOF) { char ch = (char)c; append(&ch, 1); }
+        return c;
+    }
+private:
+    void append(const char *s, size_t n) {
+        if (_cancel && _cancel->load()) return; // 已取消,吞掉不回调
+        _pending.append(s, n);
+        // 仅当整个 pending 是合法 UTF-8 才 emit(token 通常是完整字/词,边界自然对齐)
+        NSString *str = [[NSString alloc] initWithBytes:_pending.data()
+                                                 length:_pending.size()
+                                               encoding:NSUTF8StringEncoding];
+        if (str) { if (_onToken) _onToken(str); _pending.clear(); }
+    }
+    void emitPending() {
+        NSString *str = [[NSString alloc] initWithBytes:_pending.data()
+                                                 length:_pending.size()
+                                               encoding:NSUTF8StringEncoding];
+        if (str && _onToken) _onToken(str);
+    }
+    void (^_onToken)(NSString *);
+    std::atomic<bool> *_cancel;
+    std::string _pending;
+};
+} // namespace
+
+@implementation MNNLLMBridge {
+    Llm *_llm;
+    std::atomic<bool> _cancel;
+    BOOL _loaded;
+}
+
+ (BOOL)isAvailable { return YES; }
+
+ (BOOL)cpuSupportsSME2 {
+    // Apple 通过 sysctl 暴露 ARM 特性位:FEAT_SME2(A19/iPhone17+)。
+    return kk_sysctlFlag("hw.optional.arm.FEAT_SME2");
+}
+
+- (nullable instancetype)initWithConfigPath:(NSString *)configPath {
+    self = [super init];
+    if (!self) return nil;
+    _cancel = false;
+    _llm = Llm::createLLM(std::string(configPath.UTF8String));
+    if (_llm == nullptr) return nil;
+    // load 前以 merge-patch 调三件事(只翻这几个叶子,保留 chat_template 等其余配置):
+    // ① enable_thinking=false:config.json 默认 true,模板会给每个 assistant 回合硬塞
+    //    <think>\n 开启思考,吞掉 token 预算并污染 JSON(prompt 里的 /no_think 对此模板无效)。
+    // ② 降温:config.json 默认 temperature=1.0 对结构化 JSON 太高,随机性大→经常吐成非 JSON。
+    //    本 App 所有任务都是"直答/JSON",压到 0.3 + topP 0.85 让输出更确定、JSON 更稳。
+    // ③ 重复惩罚:MNN 默认 mixed_samplers 不含 "penalty"、penalty/ngram_factor=1.0(全关),
+    //    叠加低温 → 长文本(如「关键指标」列表)会陷入逐行复读死循环(收缩压 107 mmHg ×N)。
+    //    显式把 "penalty" 放进 mixed 链首,开 repetition penalty(1.1)+ n-gram 惩罚(ngram_factor 1.05):
+    //    n-gram 命中整段重复时惩罚升到 max_penalty,直接掐断逐行复读。
+    _llm->set_config("{"
+                     "\"jinja\":{\"context\":{\"enable_thinking\":false}},"
+                     "\"sampler_type\":\"mixed\","
+                     "\"mixed_samplers\":[\"penalty\",\"topK\",\"topP\",\"temperature\"],"
+                     "\"temperature\":0.3,\"topP\":0.85,\"topK\":40,"
+                     "\"penalty\":1.1,\"n_gram\":8,\"ngram_factor\":1.05"
+                     "}");
+    _loaded = _llm->load();
+    if (!_loaded) { Llm::destroy(_llm); _llm = nullptr; return nil; }
+    return self;
+}
+
+- (void)dealloc {
+    if (_llm) { Llm::destroy(_llm); _llm = nullptr; }
+}
+
+- (BOOL)isLoaded { return _loaded; }
+
+- (void)cancel { _cancel = true; }
+
+// 统一生成:full 已是最终 prompt(文本,或含 <img>路径</img> 标签)。
+// 多模态模型 createLLM 返回 Omni,response 解析 <img> 标签并对路径 CV::imread(OMNI 框架内)。
+- (MNNGenerateStats *)runResponse:(NSString *)full
+                        maxTokens:(int)maxTokens
+                          onToken:(void (^)(NSString *))onToken {
+    _cancel = false;
+    TokenStreamBuf buf(onToken, &_cancel);
+    std::ostream os(&buf);
+    if (_llm) {
+        _llm->response(std::string(full.UTF8String), &os, nullptr, maxTokens);
+    }
+    buf.flush();
+    return [self statsFromContext];
+}
+
+- (MNNGenerateStats *)generateText:(NSString *)prompt
+                         maxTokens:(int)maxTokens
+                           onToken:(void (^)(NSString *))onToken {
+    return [self runResponse:prompt maxTokens:maxTokens onToken:onToken];
+}
+
+- (nullable MNNGenerateStats *)analyzeImages:(NSArray<NSString *> *)imagePaths
+                                      prompt:(NSString *)prompt
+                                   maxTokens:(int)maxTokens
+                                     onToken:(void (^)(NSString *))onToken
+                                       error:(NSError **)error {
+    // 在 prompt 前拼 <img>本地路径</img>;Omni 解析标签并对路径 imread(需 OMNI 框架)。
+    NSMutableString *full = [NSMutableString string];
+    for (NSString *p in imagePaths) {
+        [full appendFormat:@"<img>%@</img>", p];
+    }
+    [full appendString:prompt];
+    return [self runResponse:full maxTokens:maxTokens onToken:onToken];
+}
+
+- (MNNGenerateStats *)statsFromContext {
+    MNNGenerateStats *s = [MNNGenerateStats new];
+    if (_llm) {
+        const MNN::Transformer::LlmContext *ctx = _llm->getContext();
+        if (ctx) {
+            s.promptTokens = ctx->prompt_len;
+            s.genTokens = ctx->gen_seq_len;
+            s.prefillMs = ctx->prefill_us / 1000.0;
+            s.decodeMs = ctx->decode_us / 1000.0;
+        }
+    }
+    return s;
+}
+
+@end
+
+#endif
--- a/康康/AI/MNNBackend.swift
+++ b/康康/AI/MNNBackend.swift
@@ -0,0 +1,113 @@
+import Foundation
+
+/// MNN(CPU / SME2)推理后端,封装 `MNNLLMBridge` 的文本流式生成。
+/// 与 `LLMSession`/`VLSession` 同款 actor 隔离;跨调用的串行化由上游 `AIRuntime` 闸门保证。
+///
+/// 文本与视觉(图→文)由同一个 Qwen3.5-2B 多模态 MNN 模型承担:`generate` 走文本,
+/// `analyze` 把图片拼成 <img> 标签交给 Omni 内核 imread 解码(需 OMNI 构建,xcframework 已含)。
+/// 已实测可用,真机走此单模型全包路径;模拟器无 MNN,VL 仍回退 MLX(见 `AIRuntime`)。
+actor MNNBackend {
+    private var bridge: MNNLLMBridge?
+
+    /// 末次生成统计(供 AIRuntime 在流结束后取走,性能自检用)。
+    private(set) var lastStats: GenerateStats?
+
+    private func record(_ s: GenerateStats) { lastStats = s }
+
+    var isLoaded: Bool { bridge?.isLoaded ?? false }
+
+    /// 从 MNN 模型目录加载(目录含 MNN llm 的 config.json + llm.mnn + 权重 + tokenizer)。
+    func load(folderURL: URL) throws {
+        let configPath = folderURL.appendingPathComponent("config.json").path
+        guard FileManager.default.fileExists(atPath: configPath) else {
+            throw AIRuntimeError.notReady
+        }
+        guard let b = MNNLLMBridge(configPath: configPath) else {
+            throw AIRuntimeError.modelLoadFailed("MNN createLLM/load 失败")
+        }
+        bridge = b
+    }
+
+    func unload() { bridge = nil }
+
+    /// 文本流式生成。`bridge.generateText` 同步阻塞、逐段回调,放在 detached 线程跑,
+    /// 把每段文本 yield 成 `TokenChunk`(含即时 tok/s)。流被取消时调用 `bridge.cancel()`。
+    func generate(prompt: String, maxTokens: Int) -> AsyncThrowingStream<TokenChunk, Error> {
+        guard let bridge else {
+            return AsyncThrowingStream { $0.finish(throwing: AIRuntimeError.notReady) }
+        }
+        let box = MNNUncheckedBox(bridge)
+        return AsyncThrowingStream { continuation in
+            let meter = MNNRateMeter()
+            let task = Task.detached(priority: .userInitiated) {
+                let stats = box.value.generateText(prompt, maxTokens: Int32(maxTokens)) { piece in
+                    let rate = meter.tick()
+                    continuation.yield(TokenChunk(text: piece, decodeRate: rate))
+                }
+                // ObjC 统计对象先抽成 Sendable 的 GenerateStats 再跨 actor 记录。
+                await self.record(GenerateStats(
+                    promptTokens: Int(stats.promptTokens),
+                    genTokens: Int(stats.genTokens),
+                    prefillSeconds: stats.prefillMs / 1000.0,
+                    decodeSeconds: stats.decodeMs / 1000.0
+                ))
+                continuation.finish()
+            }
+            continuation.onTermination = { _ in
+                box.value.cancel()
+                task.cancel()
+            }
+        }
+    }
+
+    /// 图→文(VL)。一次性收集(JSON 抽取不需流式)。桥接里把图片路径拼成 <img> 标签,
+    /// MNN Omni 内部 imread 加载(需 OMNI 框架);blocking 调用放 detached 线程。
+    func analyze(imageURLs: [URL], prompt: String, maxTokens: Int) async throws -> String {
+        guard let bridge else { throw AIRuntimeError.notReady }
+        let paths = imageURLs.map(\.path)
+        let box = MNNUncheckedBox(bridge)
+        return try await withCheckedThrowingContinuation { cont in
+            Task.detached(priority: .userInitiated) {
+                let sink = MNNTextSink()
+                do {
+                    let stats = try box.value.analyzeImages(paths, prompt: prompt, maxTokens: Int32(maxTokens)) { piece in
+                        sink.append(piece)
+                    }
+                    await self.record(GenerateStats(
+                        promptTokens: Int(stats.promptTokens),
+                        genTokens: Int(stats.genTokens),
+                        prefillSeconds: stats.prefillMs / 1000.0,
+                        decodeSeconds: stats.decodeMs / 1000.0
+                    ))
+                    cont.resume(returning: sink.text)
+                } catch {
+                    cont.resume(throwing: AIRuntimeError.inferenceFailed(error.localizedDescription))
+                }
+            }
+        }
+    }
+}
+
+/// 单线程串行回调聚合文本,无竞争。
+private nonisolated final class MNNTextSink: @unchecked Sendable {
+    private(set) var text = ""
+    func append(_ s: String) { text += s }
+}
+
+/// 把非 Sendable 的 ObjC 桥对象安全带过 detached 边界。
+/// 安全性来自 `AIRuntime` 闸门:同一时刻只有一个生成在跑,桥不会被并发访问。
+private nonisolated struct MNNUncheckedBox<T>: @unchecked Sendable {
+    let value: T
+    init(_ value: T) { self.value = value }
+}
+
+/// 即时解码速率计:回调在单线程串行调用,内部计数无竞争。
+private nonisolated final class MNNRateMeter: @unchecked Sendable {
+    private let start = Date()
+    private var produced = 0
+    func tick() -> Double {
+        produced += 1
+        let elapsed = Date().timeIntervalSince(start)
+        return elapsed > 0 ? Double(produced) / elapsed : 0
+    }
+}
--- a/康康/AI/ModelManifest.swift
+++ b/康康/AI/ModelManifest.swift
@@ -18,16 +18,23 @@ nonisolated enum ModelManifest {
    static func files(for kind: ModelKind) -> [ModelFile] {
        switch kind {
        case .llm:
+            // Qwen3.5-2B-4bit:多模态仓库,但走 LLMModelFactory 的 qwen3_5 文本路径加载。
+            // 字节数取自 mlx-community/Qwen3.5-2B-4bit 仓库实际 blob 大小(HF API,2026-06 核对)。
+            // 该仓库 tokenizer 体系为 vocab.json + tokenizer.json(无 merges.txt /
+            // special_tokens_map.json / added_tokens.json),chat_template 改为 .jinja。
+            // 一并镜像视觉预处理配置(preprocessor / processor / video_preprocessor),
+            // 文本加载用不到但体积可忽略,保持与仓库一致避免漏文件。
            return [
-                ModelFile(path: "config.json", bytes: 937),
-                ModelFile(path: "model.safetensors", bytes: 968_080_210),
-                ModelFile(path: "model.safetensors.index.json", bytes: 49_731),
-                ModelFile(path: "tokenizer.json", bytes: 11_422_654),
-                ModelFile(path: "tokenizer_config.json", bytes: 9_706),
-                ModelFile(path: "vocab.json", bytes: 2_776_833),
-                ModelFile(path: "merges.txt", bytes: 1_671_853),
-                ModelFile(path: "special_tokens_map.json", bytes: 613),
-                ModelFile(path: "added_tokens.json", bytes: 707),
+                ModelFile(path: "config.json", bytes: 3_113),
+                ModelFile(path: "model.safetensors", bytes: 1_722_271_785),
+                ModelFile(path: "model.safetensors.index.json", bytes: 81_722),
+                ModelFile(path: "tokenizer.json", bytes: 19_989_343),
+                ModelFile(path: "tokenizer_config.json", bytes: 1_139),
+                ModelFile(path: "vocab.json", bytes: 6_722_759),
+                ModelFile(path: "chat_template.jinja", bytes: 7_755),
+                ModelFile(path: "preprocessor_config.json", bytes: 390),
+                ModelFile(path: "processor_config.json", bytes: 1_300),
+                ModelFile(path: "video_preprocessor_config.json", bytes: 385),
            ]
        case .vl:
            // Qwen3-VL-4B-Instruct-4bit:字节数取自 mlx-community 仓库实际 blob 大小
@@ -52,6 +59,19 @@ nonisolated enum ModelManifest {
                ModelFile(path: "preprocessor_config.json", bytes: 782),
                ModelFile(path: "video_preprocessor_config.json", bytes: 817),
            ]
+        case .mnnLLM:
+            // taobao-mnn/Qwen3.5-2B-MNN 预转换 MNN 格式(HF API 实测,2026-06)。
+            // 运行时必需:config.json(MNN llm 配置)+ llm_config.json(超参)+ llm.mnn(图)
+            // + llm.mnn.weight(量化权重 ~1.1GB)+ tokenizer.txt + visual.mnn(多模态,文本路径不用但配置含 mllm)。
+            // 排除 README/.gitattributes 与可读 dump(llm.mnn.json / export_args.json)。
+            return [
+                ModelFile(path: "config.json", bytes: 652),
+                ModelFile(path: "llm_config.json", bytes: 8_692),
+                ModelFile(path: "llm.mnn", bytes: 2_148_136),
+                ModelFile(path: "llm.mnn.weight", bytes: 1_176_647_702),
+                ModelFile(path: "tokenizer.txt", bytes: 6_465_727),
+                ModelFile(path: "visual.mnn", bytes: 488_096),
+            ]
        }
    }

--- a/康康/AI/ModelStore.swift
+++ b/康康/AI/ModelStore.swift
@@ -1,14 +1,20 @@
 import Foundation

 nonisolated enum ModelKind: String, CaseIterable {
-    /// 与 HuggingFace mlx-community 仓库名一一对应,也是沙盒 Models/ 下的子目录名。
-    case llm = "Qwen3-1.7B-4bit"
-    case vl  = "Qwen3-VL-4B-Instruct-4bit"
+    /// 也是沙盒 Models/ 下的子目录名 / CDN 路径段。
+    /// 同一个 Qwen3.5-2B,两种格式两种引擎:
+    /// - mnnLLM:MNN(CPU/SME2,考核路径)文本+视觉一肩挑,taobao-mnn 预转换。iPhone17+(A19/SME2)主用,只露它。
+    /// - llm:MLX(GPU)兜底,Qwen3.5-2B-4bit 多模态(同时兜底文本与视觉,走 qwen3_5)。
+    /// - vl:已废弃(MLX VL 改走 .llm 多模态),保留枚举避免动一圈穷举 switch,不再下载/展示。
+    case llm    = "Qwen3.5-2B-4bit"
+    case vl     = "Qwen3-VL-4B-Instruct-4bit"
+    case mnnLLM = "Qwen3.5-2B-MNN"

    var displayName: String {
        switch self {
-        case .llm: return "Qwen3-1.7B"
-        case .vl:  return "Qwen3-VL-4B"
+        case .llm:    return "Qwen3.5-2B (MLX)"
+        case .vl:     return "Qwen3-VL-4B"
+        case .mnnLLM: return "Qwen3.5-2B (MNN/SME2)"
        }
    }

@@ -17,6 +23,12 @@ nonisolated enum ModelKind: String, CaseIterable {

    /// 用于判定该模型是否已就绪的最小标志文件
    var sentinelFilename: String { "config.json" }
+
+    /// 面向用户的模型集合:模型管理页 / 下载全部 / 就绪计数对外只暴露统一的
+    /// Qwen3.5-2B(MNN,文本+视觉全包,iPhone17+ 走它)。
+    /// MLX 的 .llm/.vl 仅作模拟器与兜底路径,保留枚举与下载能力(旁路导入仍可单独导),
+    /// 但不在「我的 · 模型管理」展示,也不计入「下载全部」与就绪计数。
+    static let userFacing: [ModelKind] = [.mnnLLM]
 }

 /// `@unchecked Sendable`:rootURL 是 let,方法只读 filesystem(线程安全),
--- a/康康/AI/Prompts/DiaryAssistPrompts.swift
+++ b/康康/AI/Prompts/DiaryAssistPrompts.swift
@@ -16,7 +16,7 @@ enum DiaryAssistPrompts {
        "持续频率", "既往家族史", "用药过敏", "生活方式",
    ]

-    /// - content: 患者当前全文。
+    /// - content: 用户当前全文。
    /// - coveredDimensions: 之前各轮已经问过(或记录里已写明)的维度名,本轮必须避开。
    ///   第一轮传空数组。
    static func suggest(content: String, coveredDimensions: [String] = []) -> String {
@@ -30,8 +30,8 @@ enum DiaryAssistPrompts {
            : "\n- 已问过的维度【不要再问】:\(covered.joined(separator: "、"))。本轮只能从这些还没问的维度里挑:\(allowedLine)。"

        return """
-        你是社区医生的小助手。患者写了一段身体状态的健康记录,信息可能不够完整。
-        请从医生问诊角度提出 3-4 个最值得追问的问题,帮患者把这条记录补全。
+        你是社区医生的小助手。用户写了一段身体状态的健康记录,信息可能不够完整。
+        请从医生问诊角度提出 3-4 个最值得追问的问题,帮用户把这条记录补全。

        【问诊维度清单】每个问题必须正好归属其中一个,并用 dim 标注:
        1. 起病诱因 —— 何时开始、有无诱因
@@ -76,4 +76,44 @@ enum DiaryAssistPrompts {
        Output: /no_think
        """
    }
+
+    // MARK: - 语音口述 → 日记整理
+
+    /// 口述转写稿截断上限(字符)。2B 模型 context 保护:超长口述只取前面部分。
+    static let organizeTranscriptLimit = 1200
+
+    /// 把语音转写稿整理成健康日记草稿。自适应样式:内容少 → 一段通顺的话;
+    /// 多方面 → 按「方面:内容」分行。
+    /// 红线(spec 2026-06-10-voice-diary §2):只重组语言,严禁增删改任何数值、单位、药名、时间——
+    /// 2B 模型把 140/90 改成 130/90 即健康数据事故,所以规则放第一条并配 few-shot 强化。
+    static func organize(transcript: String) -> String {
+        let trimmed = String(transcript.prefix(organizeTranscriptLimit))
+        return """
+        你是健康记录助手。下面是用户口述身体状态的语音转写原话,可能口语化、有重复、缺标点。
+        请把它整理成一条清晰的健康日记。
+
+        硬性规则:
+        - 【绝对不许】增加、删除或改动任何数值、单位、药名、时间——原话说 140/90 就必须写 140/90。
+        - 只重组语言:去掉口头语和重复;用第一人称;不加入原话没有的事实。
+        - 内容只涉及一两个方面 → 整理成一段通顺的话(2-4 句)。
+        - 内容涉及多个方面(症状/用药/饮食/睡眠/运动等) → 按「方面:内容」分行。
+        - 不诊断、不给用药建议、不写「建议就医」。
+        - 只输出整理后的日记正文,不要解释、不要 markdown 围栏、不要 <think> 标签。
+
+        示例 1(口述:那个今天早上起来有点头晕然后我量了下血压140 90比平时高一点没吃早饭就出门了):
+        今天早上起来有点头晕,量了血压 140/90,比平时高一点。没吃早饭就出门了。
+
+        示例 2(口述:今天头晕了一上午下午好点了血压早上量的140 90嗯缬沙坦吃了降脂药忘了吃早饭没吃中午吃的清淡晚上散步了半小时):
+        症状:头晕了一上午,下午好转。
+        血压:早上 140/90。
+        用药:缬沙坦已服,降脂药忘服。
+        饮食:早饭未吃,午餐清淡。
+        运动:晚上散步半小时。
+
+        【口述原话】:
+        \(trimmed)
+
+        Output: /no_think
+        """
+    }
 }
--- a/康康/AI/Prompts/HealthExportPrompts.swift
+++ b/康康/AI/Prompts/HealthExportPrompts.swift
@@ -70,7 +70,7 @@ enum HealthExportPrompts {
        - 严禁编造或推测任何数字、日期、症状、药物、检查结果、诊断,哪怕看起来很合理。
        - JSON 里没有的信息,对应小节一律写「无记录」,不要补全、不要举例、不要套用常见病例模板。
        - 数值必须原样照搬(含单位与参考范围);status 为 high/low/abnormal 的指标前加 ⚠️。
-        - 「主诉」「患者疑问」可参考【患者原话】,但不得加入原话与数据里都没有的症状。
+        - 「主诉」「本人疑问」可参考【本人原话】,但不得加入原话与数据里都没有的症状。

        输出格式:
        - 严格 Markdown,标题用 # / ##,不要 markdown 围栏,不要输出 JSON,不写「数据」二字。
@@ -78,11 +78,11 @@ enum HealthExportPrompts {
        - 严格按以下 6 段(顺序与标题固定):
        \(labelLine)
        ## 主诉
-        ## 患者背景
+        ## 本人背景
        ## 近期症状(按时间倒序)
        ## 关键指标(异常项优先)
        ## 在服药与过敏
-        ## 患者疑问
+        ## 本人疑问

        —— 格式示例(只示范「无记录」与数值写法,内容请勿照抄)——
        真实数据:{"profile":{},"symptoms":[],"indicators":[{"name":"体温","value":"38.5","unit":"℃","range":"36-37.2","status":"high","date":"2026-05-01"}],"reports":[],"diaries":[],"time_window":{"from":"2026-04-02","to":"2026-05-02"}}
@@ -90,7 +90,7 @@ enum HealthExportPrompts {
        # 就诊摘要 — 近期健康摘要
        ## 主诉
        无记录
-        ## 患者背景
+        ## 本人背景
        无记录
        ## 近期症状(按时间倒序)
        无记录
@@ -98,7 +98,7 @@ enum HealthExportPrompts {
        ⚠️ 体温 38.5 ℃(参考 36-37.2,2026-05-01)
        ## 在服药与过敏
        无记录
-        ## 患者疑问
+        ## 本人疑问
        无记录
        —— 示例结束(以上咳嗽/体温等仅示范格式,切勿出现在你的输出里)——

@@ -107,7 +107,7 @@ enum HealthExportPrompts {
        【真实数据】:
        \(dataJSON)

-        【患者原话】:\(userPrompt)
+        【本人原话】:\(userPrompt)

        再次强调:只整理上面【真实数据】里真实出现过的内容,禁止编造任何数字/日期/症状/药物。
        直接输出 Markdown,不要思考过程,不要 <think> 标签:
@@ -169,7 +169,7 @@ enum HealthExportPrompts {
        ## 相关健康日记
        ## 相关指标
        ## 已知背景
-        ## 患者关心的问题
+        ## 本人关心的问题
        ## 可带给医生确认的要点

        【本地健康记录】:
--- a/康康/AI/Prompts/InsightPrompts.swift
+++ b/康康/AI/Prompts/InsightPrompts.swift
@@ -0,0 +1,44 @@
+import Foundation
+
+/// 本地解读类 prompt:报告大白话摘要 + 趋势一句话解读。
+/// 红线:不诊断、不荐药;称呼「你」,不出现「患者」(产品定位:自我健康记录)。
+nonisolated enum InsightPrompts {
+
+    /// 报告整体大白话摘要(归档后台预生成,写回 Report.summary)。
+    static func reportPlainSummary(title: String, typeLabel: String, indicatorLines: String) -> String {
+        """
+        你是健康档案助手。下面是一份报告的指标列表,请用大白话给本人(称「你」)写 2~3 句整体解读:
+        - 第 1 句:总体情况(共几项、几项异常)。
+        - 之后:点名最值得留意的异常项,用生活化语言说明偏高/偏低意味着什么方向。
+        - 不诊断疾病、不推荐药物或剂量;异常较多时建议「带上报告咨询医生」。
+        - 只输出正文文字,不要标题、列表、JSON、markdown。
+
+        示例:
+        输入:血常规(化验单),指标:白细胞 5.2 (3.5-9.5) normal;血红蛋白 118 (130-175) low;血小板 210 (125-350) normal
+        输出:这份血常规共 3 项,2 项正常,血红蛋白略低于参考范围。血红蛋白偏低通常与贫血方向有关,平时可以多补充含铁食物;如果还伴随乏力头晕,建议带上报告咨询医生。
+
+        现在的报告:\(title)(\(typeLabel))
+        指标:
+        \(indicatorLines)
+        只输出 2~3 句正文。/no_think
+        """
+    }
+
+    /// 趋势一句话解读(TrendDetailView,按数据指纹缓存)。
+    static func trendInsight(title: String, unit: String, rangeText: String, dataLines: String) -> String {
+        """
+        你是健康档案助手。下面是「\(title)」的历史记录(单位 \(unit)\(rangeText)),请用大白话给本人(称「你」)写 1~2 句趋势解读:
+        - 说清整体走向(上升/下降/平稳/波动)和当前值与参考范围的关系。
+        - 不诊断疾病、不推荐药物;持续异常时温和建议「复查或咨询医生」。
+        - 只输出正文文字,不要标题、列表、JSON。
+
+        示例:
+        输入:体重,单位 kg,记录:2026-04-01 72.5 / 2026-04-15 71.8 / 2026-05-01 71.2
+        输出:近一个月你的体重稳步下降了约 1.3kg,节奏平缓,继续保持现在的习惯就好。
+
+        现在的记录:
+        \(dataLines)
+        只输出 1~2 句正文。/no_think
+        """
+    }
+}
--- a/康康/AI/Prompts/VLPrompts.swift
+++ b/康康/AI/Prompts/VLPrompts.swift
@@ -3,7 +3,7 @@ import Foundation
 /// VL 模型(Qwen3-VL)用于体检 / 化验单识别的 prompt 模板。
 /// 输出契约:严格 JSON,无任何解释文字、markdown 围栏或前后缀。
 /// 解析失败 → CaptureService 回退到手动录入(§3.2 失败回退红线)。
-enum VLPrompts {
+nonisolated enum VLPrompts {

    /// 输出 JSON 的字段定义(写进 prompt 里教模型):
    /// ```
@@ -31,12 +31,38 @@ enum VLPrompts {

    /// VL 模型不知"今天"是哪天,且 few-shot 示例里写死了日期,
    /// 必须把当天日期显式注入 prompt,模型在无报告日期时才会用对正确的回退值。
-    static func reportExtraction(today: Date = .now) -> String {
+    /// ocrText 非空时把 Vision OCR 的结果作为参考文本注入 —— Vision 抄数字比
+    /// 2B 多模态读密集小字稳;版面与表格结构仍以图片为准。
+    static func reportExtraction(today: Date = .now, ocrText: String = "") -> String {
        let f = DateFormatter()
        f.locale = Locale(identifier: "en_US_POSIX")
        f.dateFormat = "yyyy-MM-dd"
        let todayStr = f.string(from: today)
-        return reportExtractionTemplate.replacingOccurrences(of: "{{TODAY}}", with: todayStr)
+        let ocrSection: String
+        if ocrText.isEmpty {
+            ocrSection = ""
+        } else {
+            ocrSection = """
+
+
+            OCR 参考文本(系统对同一报告做文字识别的结果,可能有错字、串行或漏行;版面与表格结构以图片为准,但数值、小数点以 OCR 文字更可靠):
+            \(clipOCR(ocrText))
+
+            """
+        }
+        return reportExtractionTemplate
+            .replacingOccurrences(of: "{{TODAY}}", with: todayStr)
+            .replacingOccurrences(of: "{{OCR_SECTION}}", with: ocrSection)
+    }
+
+    /// OCR 文本截断:限制进入 prompt 的体量(2B 模型上下文有限)。截到最后一个完整行。
+    static func clipOCR(_ text: String, limit: Int = 1800) -> String {
+        guard text.count > limit else { return text }
+        let clipped = String(text.prefix(limit))
+        if let lastNewline = clipped.lastIndex(of: "\n") {
+            return String(clipped[..<lastNewline]) + "\n(后续内容过长已截断)"
+        }
+        return clipped + "\n(后续内容过长已截断)"
    }

    private static let reportExtractionTemplate: String = #"""
@@ -84,13 +110,13 @@ JSON schema(严格):
 输入: 一份春季体检,3 项可读
 输出:
 {"title":"春季年度体检","type":"checkup","report_date":"2026-04-12","institution":"协和医院","page_count":1,"summary":"血脂偏高、其他正常","indicators":[{"name":"低密度脂蛋白","value":"3.84","unit":"mmol/L","range":"< 3.40","status":"high","source_page":1,"source_box":[0.12,0.31,0.76,0.07]},{"name":"谷丙转氨酶","value":"32","unit":"U/L","range":"9 - 50","status":"normal","source_page":1,"source_box":[0.12,0.39,0.76,0.07]},{"name":"空腹血糖","value":"5.2","unit":"mmol/L","range":"3.9 - 6.1","status":"normal","source_page":1,"source_box":[0.12,0.47,0.76,0.07]}]}
-
+{{OCR_SECTION}}
 现在请识别图片并输出 JSON:
 """#

-    // MARK: - 局部小框识别(异常项快拍)
+    // MARK: - 局部小框识别(指标速记)

-    /// 异常项快拍专用:输入是报告/化验单的**局部照片**(常常只有一两行指标)。
+    /// 指标速记专用:输入是报告/化验单的**局部照片**(常常只有一两行指标)。
    /// 只要 indicators 数组,不要报告标题/机构/日期等元信息 —— 这条路径只存数值,不建 Report。
    static func regionExtraction(today: Date = .now) -> String {
        let f = DateFormatter()
--- a/康康/App/KangkangApp.swift
+++ b/康康/App/KangkangApp.swift
@@ -102,6 +102,9 @@ struct KangkangApp: App {
                    // 语言 / 字体档位切换 → 整树重建,即时生效(固定字号经 tjScaled 读新倍率)。
                    .id("\(lang.current.rawValue)-\(fontScale.scale.rawValue)")
            }
+            // 设计系统是纯浅色(背景恒为 sand)。锁定 light:否则系统深色模式下,
+            // 未显式设色的 Text/TextField 走 .primary 变白,在浅背景上看不见(如日记输入框)。
+            .preferredColorScheme(.light)
        }
        .modelContainer(sharedModelContainer)
    }
--- a/康康/DesignSystem/AIDisclaimer.swift
+++ b/康康/DesignSystem/AIDisclaimer.swift
@@ -0,0 +1,34 @@
+import SwiftUI
+
+/// 全 App 统一的 AI 免责声明(上架合规:医疗类内容必须声明不做诊断)。
+/// 任何展示 AI 生成的归纳/解读/建议文本的地方,都应在结果末尾附上 `AIDisclaimerFooter`;
+/// 离开 App 的文本(复制/分享)用 `AIDisclaimer.appended(to:)` 把声明带上。
+enum AIDisclaimer {
+    /// 面向用户展示的完整声明文本。
+    static let text =
+        "本内容由本机本地 AI 依据你录入的健康记录自动归纳整理,仅供个人健康管理与就医沟通参考," +
+        "不构成医学诊断、治疗建议或专业医疗意见;具体健康问题请咨询执业医师。"
+
+    /// 复制/分享时把声明追加到正文末尾(分隔线 + 声明),让文本离开 App 也带着免责。
+    static func appended(to body: String) -> String {
+        let trimmed = body.trimmingCharacters(in: .whitespacesAndNewlines)
+        return "\(trimmed)\n\n———\n\(text)"
+    }
+}
+
+/// AI 结果下方的免责声明脚注:小字、弱色、信息图标。放在任何 AI 生成文本块末尾。
+struct AIDisclaimerFooter: View {
+    var body: some View {
+        HStack(alignment: .top, spacing: 6) {
+            Image(systemName: "info.circle")
+                .font(.tjScaled( 10))
+                .foregroundStyle(Tj.Palette.text3)
+            Text(AIDisclaimer.text)
+                .font(.tjScaled( 10))
+                .lineSpacing(2)
+                .foregroundStyle(Tj.Palette.text3)
+                .fixedSize(horizontal: false, vertical: true)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
--- a/康康/DesignSystem/AIFlowBar.swift
+++ b/康康/DesignSystem/AIFlowBar.swift
@@ -0,0 +1,45 @@
+import SwiftUI
+
+/// Apple Intelligence 式多彩流光线:蓝→紫→粉→橙→青,横向无缝循环流动。
+/// 全 App「AI 计算中」时刻的统一视觉点缀(日记 AI 辅助、身体档案报告生成/检索等待)。
+///
+/// 注意:这条线的颜色是刻意走出 `Tj.Palette` 单色系统的 AI 高光点缀(应产品要求的
+/// Apple 风格),仅此组件如此;其余 UI 仍严格守 §9 单色 token。
+struct AIFlowBar: View {
+    var height: CGFloat = 3
+    /// 流动一整圈的秒数,越小越快。
+    var cycle: Double = 1.0
+
+    @State private var phase: CGFloat = 0
+
+    /// 颜色重复一遍:offset 走完一个整段时首尾同色,循环无缝。
+    private static let flow: [Color] = {
+        let base: [Color] = [
+            Color(red: 0.35, green: 0.47, blue: 0.98),  // 蓝
+            Color(red: 0.62, green: 0.36, blue: 0.92),  // 紫
+            Color(red: 0.96, green: 0.40, blue: 0.62),  // 粉
+            Color(red: 1.00, green: 0.55, blue: 0.30),  // 橙
+            Color(red: 0.30, green: 0.80, blue: 0.92),  // 青
+        ]
+        return base + base
+    }()
+
+    var body: some View {
+        GeometryReader { geo in
+            let w = geo.size.width
+            Capsule()
+                .fill(LinearGradient(colors: Self.flow,
+                                     startPoint: .leading, endPoint: .trailing))
+                .frame(width: w * 2)
+                .offset(x: phase)
+                .onAppear {
+                    phase = 0
+                    withAnimation(.linear(duration: cycle).repeatForever(autoreverses: false)) {
+                        phase = -w
+                    }
+                }
+        }
+        .frame(height: height)
+        .clipShape(Capsule())
+    }
+}
--- a/康康/Features/Archive/ArchiveListView.swift
+++ b/康康/Features/Archive/ArchiveListView.swift
@@ -30,6 +30,7 @@ struct ArchiveListView: View {
    @State private var filter: TimelineKind? = nil
    @State private var endingSymptom: Symptom?
    @State private var selectedEntry: TimelineEntry?
+    @State private var selectedGroup: IndicatorGroup?
    @State private var route: Route?

    @MainActor
@@ -109,6 +110,9 @@ struct ArchiveListView: View {
                TimelineEntryDetailView(detail: d)
            }
        }
+        .sheet(item: $selectedGroup) { group in
+            IndicatorSeriesDetailView(group: group)
+        }
    }

    @ViewBuilder
@@ -123,9 +127,14 @@ struct ArchiveListView: View {
            }
            .buttonStyle(.plain)
        } else {
-            // 其余条目(报告/指标/日记/已结束症状):点 → 只读详情
+            // 其余条目:指标 → 同类聚合详情(横向翻页 + 趋势);报告/日记/已结束症状 → 只读详情
            Button {
-                if detail(for: entry) != nil { selectedEntry = entry }
+                guard let d = detail(for: entry) else { return }
+                switch d {
+                case .indicator(let i):           selectedGroup = IndicatorGroup.of(i)
+                case .bloodPressure(let sys, _):  selectedGroup = IndicatorGroup.of(sys)
+                default:                          selectedEntry = entry
+                }
            } label: {
                TimelineRow(entry: entry)
            }
--- a/康康/Features/Archive/HealthExportDetailView.swift
+++ b/康康/Features/Archive/HealthExportDetailView.swift
@@ -29,6 +29,8 @@ struct HealthExportDetailView: View {
                            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
                                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
                        )
+
+                    AIDisclaimerFooter()
                }
                .padding(.horizontal, 20)
                .padding(.vertical, 16)
@@ -117,7 +119,7 @@ struct HealthExportDetailView: View {
            }
            .buttonStyle(TjGhostButton(height: 44, fontSize: 13, horizontalPadding: 14))

-            ShareLink(item: export.content) {
+            ShareLink(item: AIDisclaimer.appended(to: export.content)) {
                Label("分享", systemImage: "square.and.arrow.up")
                    .font(.tjScaled( 13, weight: .semibold))
                    .tracking(1)
@@ -149,7 +151,7 @@ struct HealthExportDetailView: View {
    }

    private func copy() {
-        UIPasteboard.general.string = export.content
+        UIPasteboard.general.string = AIDisclaimer.appended(to: export.content)
        copiedFlash = true
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.4) {
            copiedFlash = false
@@ -175,9 +177,9 @@ struct HealthExportDetailView: View {
        # 就诊摘要 — 感冒就诊

        ## 主诉
-        患者男,38 岁,感冒 3 天未愈。
+        本人男,38 岁,感冒 3 天未愈。

-        ## 患者背景
+        ## 本人背景
        - 高血压 2 年
        - 在服药:缬沙坦 80mg qd
        """,
--- a/康康/Features/Archive/HealthExportSheet.swift
+++ b/康康/Features/Archive/HealthExportSheet.swift
@@ -20,8 +20,15 @@ struct HealthExportSheet: View {
    @State private var completed: Bool = false
    @State private var copiedFlash: Bool = false
    @State private var answeringTurnID: UUID?
+    @State private var retrieval: HealthExportService.RetrievalSummary?
+    @State private var turnRetrievals: [UUID: HealthExportService.RetrievalSummary] = [:]
    @FocusState private var questionFocused: Bool

+    // 快捷问答
+    @State private var promptStore = QuickPromptStore.shared
+    @State private var showAddPrompt = false
+    @State private var newPromptText = ""
+
    init(initialPrompt: String = "") {
        self.initialPrompt = initialPrompt
    }
@@ -33,10 +40,16 @@ struct HealthExportSheet: View {
        !isGeneratingReport &&
        !draftQuestion.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }
+    /// 已有有效用户对话内容。
+    private var hasUserContent: Bool {
+        turns.contains(where: { $0.role == .user && !$0.text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })
+    }
+
+    /// 可生成报告:有对话内容,或输入框里有文字(允许跳过多轮对话直接生成)。
    private var canGenerateReport: Bool {
        !isAnswering &&
        !isGeneratingReport &&
-        turns.contains(where: { $0.role == .user && !$0.text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })
+        (hasUserContent || !draftQuestion.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
    }

    var body: some View {
@@ -88,6 +101,75 @@ struct HealthExportSheet: View {
            questionFocused = true
        }
        .onDisappear { task?.cancel() }
+        .alert("添加快捷问答", isPresented: $showAddPrompt) {
+            TextField("输入一句常用问题…", text: $newPromptText)
+            Button("取消", role: .cancel) { newPromptText = "" }
+            Button("添加") {
+                promptStore.add(prompt: newPromptText)
+                newPromptText = ""
+            }
+        } message: {
+            Text("保存后点一下,就能把这句话填进输入框")
+        }
+    }
+
+    // MARK: - 快捷问答
+
+    /// 内置 + 自定义快捷问答 chip 行;点 chip 填入输入框,末尾「＋ 自定义」追加,长按自定义删除。
+    private var quickPromptRow: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 8) {
+                ForEach(promptStore.all) { p in
+                    quickPromptChip(p)
+                }
+                addQuickPromptChip
+            }
+            .padding(.vertical, 1)   // 给 chip 描边留出像素,避免被 ScrollView 裁切
+        }
+    }
+
+    private func quickPromptChip(_ p: QuickPrompt) -> some View {
+        Button {
+            draftQuestion = p.prompt
+            questionFocused = true
+        } label: {
+            Text(p.title)
+                .font(.tjScaled( 12, weight: .medium))
+                .foregroundStyle(Tj.Palette.text)
+                .lineLimit(1)
+                .padding(.horizontal, 12)
+                .padding(.vertical, 7)
+                .background(Capsule().fill(Tj.Palette.sand2))
+                .overlay(Capsule().strokeBorder(Tj.Palette.lineSoft, lineWidth: 1))
+        }
+        .buttonStyle(.plain)
+        .contextMenu {
+            if !p.isBuiltin {
+                Button(role: .destructive) {
+                    promptStore.delete(p)
+                } label: {
+                    Label("删除", systemImage: "trash")
+                }
+            }
+        }
+    }
+
+    private var addQuickPromptChip: some View {
+        Button { showAddPrompt = true } label: {
+            Label("自定义", systemImage: "plus")
+                .font(.tjScaled( 12, weight: .medium))
+                .foregroundStyle(Tj.Palette.text2)
+                .padding(.horizontal, 12)
+                .padding(.vertical, 7)
+                .background(Capsule().fill(Tj.Palette.paper))
+                .overlay(
+                    Capsule().strokeBorder(
+                        Tj.Palette.line,
+                        style: StrokeStyle(lineWidth: 1, dash: [3])
+                    )
+                )
+        }
+        .buttonStyle(.plain)
    }

    // MARK: - Header
@@ -128,14 +210,7 @@ struct HealthExportSheet: View {
                .font(.tjScaled( 13, weight: .semibold))
                .foregroundStyle(Tj.Palette.text2)

-            VStack(alignment: .leading, spacing: 6) {
-                Text("例:最近血压波动大吗？")
-                    .font(.tjScaled( 12))
-                    .foregroundStyle(Tj.Palette.text3)
-                Text("例:把我最近头晕、睡眠和指标变化整理给医生")
-                    .font(.tjScaled( 12))
-                    .foregroundStyle(Tj.Palette.text3)
-            }
+            quickPromptRow

            Text("上下文:全部记录指标 + 健康日记 · 本地 RAG · 不上传任何数据")
                .font(.tjScaled( 11))
@@ -161,12 +236,17 @@ struct HealthExportSheet: View {
                Text(turn.role.transcriptLabel)
                    .font(.tjScaled( 11, weight: .semibold))
                    .foregroundStyle(isUser ? Tj.Palette.paper.opacity(0.8) : Tj.Palette.text3)
+                if !isUser, let summary = turnRetrievals[turn.id] {
+                    RetrievalChipsView(summary: summary)
+                }
                if turn.id == answeringTurnID && turn.text.isEmpty {
-                    HStack(spacing: 8) {
-                        ProgressView()
-                        Text("正在查看本地记录…")
+                    VStack(alignment: .leading, spacing: 8) {
+                        Text(turnRetrievals[turn.id] == nil
+                             ? "正在查看本地记录…"
+                             : "正在根据这些记录回答…")
                            .font(.tjScaled( 13))
                            .foregroundStyle(Tj.Palette.text3)
+                        AIFlowBar()
                    }
                } else {
                    Text(turn.text)
@@ -196,6 +276,11 @@ struct HealthExportSheet: View {
                .font(.tjScaled( 13, weight: .semibold))
                .foregroundStyle(Tj.Palette.text2)
            MarkdownView(text: content)
+
+            if completed {
+                Divider().background(Tj.Palette.lineSoft)
+                AIDisclaimerFooter()
+            }
        }
        .padding(16)
        .frame(maxWidth: .infinity, alignment: .leading)
@@ -220,6 +305,9 @@ struct HealthExportSheet: View {
                arrow
                phasePill(.generating)
            }
+            if let retrieval {
+                RetrievalChipsView(summary: retrieval)
+            }
            if phase == .generating && rate > 0 {
                Text(String(format: String(appLoc: "本地推理 · %.1f tok/s"), rate))
                    .font(.tjScaled( 11, design: .monospaced))
@@ -229,6 +317,9 @@ struct HealthExportSheet: View {
                    .font(.tjScaled( 11))
                    .foregroundStyle(Tj.Palette.text3)
            }
+
+            // AI 计算中:多彩流光线(与日记 AI 辅助同一组件)
+            AIFlowBar().padding(.top, 2)
        }
    }

@@ -291,7 +382,7 @@ struct HealthExportSheet: View {
            }
            .buttonStyle(TjGhostButton(height: 44, fontSize: 13, horizontalPadding: 14))

-            ShareLink(item: content) {
+            ShareLink(item: AIDisclaimer.appended(to: content)) {
                Label("分享", systemImage: "square.and.arrow.up")
                    .font(.tjScaled( 13, weight: .semibold))
                    .tracking(1)
@@ -319,7 +410,7 @@ struct HealthExportSheet: View {
    private var composer: some View {
        VStack(spacing: 10) {
            HStack(spacing: 8) {
-                TextField("继续提问或补充情况…", text: $draftQuestion, axis: .vertical)
+                TextField("写下要整理什么,或先提问补充情况…", text: $draftQuestion, axis: .vertical)
                    .font(.tjScaled( 14))
                    .lineLimit(1...4)
                    .padding(.horizontal, 12)
@@ -342,12 +433,28 @@ struct HealthExportSheet: View {
                .accessibilityLabel("发送问题")
            }

-            Button { startReportGeneration() } label: {
-                Label("生成整理报告", systemImage: "doc.text.below.ecg")
+            if isGeneratingReport {
+                Button { stopGeneration() } label: {
+                    Label("停止生成", systemImage: "stop.fill")
+                        .font(.tjScaled( 14, weight: .semibold))
+                        .foregroundStyle(Tj.Palette.brick)
+                        .frame(maxWidth: .infinity)
+                        .frame(height: 44)
+                        .background(
+                            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                                .strokeBorder(Tj.Palette.brick, lineWidth: 1)
+                        )
+                        .contentShape(Rectangle())
+                }
+                .buttonStyle(.plain)
+            } else {
+                Button { startReportGeneration() } label: {
+                    Label("生成整理报告", systemImage: "doc.text.below.ecg")
+                }
+                .buttonStyle(TjPrimaryButton(height: 44, fontSize: 14))
+                .disabled(!canGenerateReport)
+                .opacity(canGenerateReport ? 1 : 0.45)
            }
-            .buttonStyle(TjPrimaryButton(height: 44, fontSize: 14))
-            .disabled(!canGenerateReport)
-            .opacity(canGenerateReport ? 1 : 0.45)
        }
        .padding(.horizontal, 20)
        .padding(.vertical, 12)
@@ -380,9 +487,18 @@ struct HealthExportSheet: View {
        task?.cancel()
        task = Task { @MainActor in
            do {
-                for try await chunk in stream {
-                    appendToTurn(id: assistantTurn.id, text: chunk.text)
-                    if chunk.decodeRate > 0 { rate = chunk.decodeRate }
+                for try await event in stream {
+                    switch event {
+                    case .retrieved(let summary):
+                        withAnimation(.snappy(duration: 0.25)) {
+                            turnRetrievals[assistantTurn.id] = summary
+                        }
+                    case .token(let chunk):
+                        appendToTurn(id: assistantTurn.id, text: chunk.text)
+                        if chunk.decodeRate > 0 { rate = chunk.decodeRate }
+                    case .phaseChanged, .completed:
+                        break
+                    }
                }
                answeringTurnID = nil
                questionFocused = true
@@ -402,10 +518,20 @@ struct HealthExportSheet: View {
    private func startReportGeneration() {
        guard canGenerateReport else { return }
        questionFocused = false
+
+        // 直接生成:输入框里有文字(快捷问答/手输)就把它作为一条诉求追加进对话,
+        // 不必先走多轮问答 —— 用户点一下「生成报告」即可。
+        let draft = draftQuestion.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !draft.isEmpty {
+            turns.append(.user(draft))
+            draftQuestion = ""
+        }
+
        content = ""
        rate = 0                 // 重新生成时清零,避免旧 tok/s 残留显示
        error = nil
        completed = false
+        retrieval = nil
        phase = .retrieving

        let stream = HealthExportService.shared.export(conversation: turns, in: ctx)
@@ -416,6 +542,8 @@ struct HealthExportSheet: View {
                    switch event {
                    case .phaseChanged(let ph):
                        phase = ph
+                    case .retrieved(let summary):
+                        withAnimation(.snappy(duration: 0.25)) { retrieval = summary }
                    case .token(let chunk):
                        content += chunk.text
                        if chunk.decodeRate > 0 { rate = chunk.decodeRate }
@@ -435,6 +563,17 @@ struct HealthExportSheet: View {
        startReportGeneration()
    }

+    /// 停止正在进行的报告生成:取消推理任务,回到可重新生成的干净态(已写的诉求保留在对话里)。
+    private func stopGeneration() {
+        task?.cancel()
+        task = nil
+        phase = nil
+        rate = 0
+        completed = false
+        content = ""
+        retrieval = nil
+    }
+
    private func reset() {
        task?.cancel()
        task = nil
@@ -444,11 +583,13 @@ struct HealthExportSheet: View {
        error = nil
        completed = false
        answeringTurnID = nil
+        retrieval = nil
+        turnRetrievals = [:]
        questionFocused = true
    }

    private func copy() {
-        UIPasteboard.general.string = content
+        UIPasteboard.general.string = AIDisclaimer.appended(to: content)
        copiedFlash = true
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.4) {
            copiedFlash = false
@@ -461,6 +602,44 @@ struct HealthExportSheet: View {
    }
 }

+// MARK: - 检索结果 chips(本地 RAG 可视化)
+
+/// 生成开始前先把「本地 RAG 找到了什么」演出来:N 条记录 + 记录名 chips。
+/// 结构化检索(不用 embedding)的天然优势 —— 每条命中都可解释、可展示(§12 卖点 3)。
+private struct RetrievalChipsView: View {
+    let summary: HealthExportService.RetrievalSummary
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            if summary.totalCount == 0 {
+                Text("本地档案中暂无相关记录,将仅按你的描述整理")
+                    .font(.tjScaled( 11))
+                    .foregroundStyle(Tj.Palette.text3)
+            } else {
+                Text(String(appLoc: "已在本地档案中找到 \(summary.totalCount) 条相关记录"))
+                    .font(.tjScaled( 11, weight: .medium))
+                    .foregroundStyle(Tj.Palette.leaf)
+                ScrollView(.horizontal, showsIndicators: false) {
+                    HStack(spacing: 6) {
+                        ForEach(Array(summary.chips.enumerated()), id: \.offset) { _, chip in
+                            Text(chip)
+                                .font(.tjScaled( 11))
+                                .foregroundStyle(Tj.Palette.text2)
+                                .lineLimit(1)
+                                .padding(.horizontal, 8)
+                                .padding(.vertical, 4)
+                                .background(Capsule().fill(Tj.Palette.sand2))
+                                .overlay(Capsule().strokeBorder(Tj.Palette.lineSoft, lineWidth: 1))
+                        }
+                    }
+                    .padding(.vertical, 1)
+                }
+            }
+        }
+        .transition(.opacity.combined(with: .move(edge: .top)))
+    }
+}
+
 // MARK: - 简易 Markdown 渲染(行级)

 /// 极简 Markdown 渲染器,够给医生看的报告就行。
@@ -641,9 +820,9 @@ struct MarkdownView: View {
        # 就诊摘要 — 感冒就诊

        ## 主诉
-        患者男,38 岁,感冒 3 天未愈,主诉鼻塞、咳嗽、低烧。
+        本人男,38 岁,感冒 3 天未愈,主诉鼻塞、咳嗽、低烧。

-        ## 患者背景
+        ## 本人背景
        - 高血压 2 年
        - 在服药:**缬沙坦 80mg qd**
        - 过敏:青霉素
--- a/康康/Features/Archive/QuickPrompt.swift
+++ b/康康/Features/Archive/QuickPrompt.swift
@@ -0,0 +1,92 @@
+import Foundation
+import Observation
+
+/// 「身体档案」里的快捷问答:点一下把一句常用问题填进输入框。
+/// 内置 3 条(不可删),用户可自定义追加(可删)。
+struct QuickPrompt: Identifiable, Codable, Equatable {
+    let id: UUID
+    var title: String    // chip 上显示的短标签
+    var prompt: String   // 点击后填入输入框的完整问题
+    var isBuiltin: Bool
+
+    init(id: UUID = UUID(), title: String, prompt: String, isBuiltin: Bool) {
+        self.id = id
+        self.title = title
+        self.prompt = prompt
+        self.isBuiltin = isBuiltin
+    }
+}
+
+/// 快捷问答存储:内置常量 + 自定义条目(UserDefaults JSON,无 SwiftData schema 迁移风险)。
+/// 自定义条目只是 UI 便利项、不是健康记录,故不进 SwiftData。
+@Observable
+final class QuickPromptStore {
+    static let shared = QuickPromptStore()
+
+    private let defaults = UserDefaults.standard
+    private let storageKey = "kk.quickPrompts.custom.v1"
+
+    private(set) var custom: [QuickPrompt]
+
+    private init() {
+        if let data = defaults.data(forKey: storageKey),
+           let decoded = try? JSONDecoder().decode([QuickPrompt].self, from: data) {
+            custom = decoded
+        } else {
+            custom = []
+        }
+    }
+
+    /// 内置在前、自定义在后,供 chip 行展示。
+    var all: [QuickPrompt] { Self.builtins + custom }
+
+    /// 追加一条自定义问答。空白忽略;标签自动取问题前几个字。
+    func add(prompt rawPrompt: String) {
+        let trimmed = rawPrompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+        custom.append(QuickPrompt(title: Self.deriveTitle(trimmed),
+                                  prompt: trimmed,
+                                  isBuiltin: false))
+        persist()
+    }
+
+    /// 删除一条自定义问答(内置不可删)。
+    func delete(_ p: QuickPrompt) {
+        guard !p.isBuiltin else { return }
+        custom.removeAll { $0.id == p.id }
+        persist()
+    }
+
+    private func persist() {
+        if let data = try? JSONEncoder().encode(custom) {
+            defaults.set(data, forKey: storageKey)
+        }
+    }
+
+    /// 自定义条目的短标签:压成单行,取前 8 个字,超出补省略号。
+    static func deriveTitle(_ prompt: String) -> String {
+        let oneLine = prompt.replacingOccurrences(of: "\n", with: " ")
+            .trimmingCharacters(in: .whitespaces)
+        let head = oneLine.prefix(8)
+        return oneLine.count > 8 ? "\(head)…" : String(head)
+    }
+
+    /// 内置 3 条(首屏):覆盖「就诊 / 解读 / 速查」三类,数据依赖稳、不碰诊断红线。
+    static let builtins: [QuickPrompt] = [
+        QuickPrompt(
+            title: "就诊摘要",
+            prompt: "根据我最近的身体症状，结合历史指标，整理一份让门诊医生快速了解我情况的就诊摘要。",
+            isBuiltin: true
+        ),
+        QuickPrompt(
+            title: "趋势解读",
+            prompt: "把我血压最近半年的变化讲清楚：是变好还是变差、要注意什么。",
+            isBuiltin: true
+        ),
+        QuickPrompt(
+            title: "速答清单",
+            prompt: "把我的过敏史、正在吃的药、慢性病整理成一句话清单，方便就诊时快速回答医生。",
+            isBuiltin: true
+        ),
+    ]
+}
--- a/康康/Features/Capture/UnifiedCaptureFlow.swift
+++ b/康康/Features/Capture/UnifiedCaptureFlow.swift
@@ -311,6 +311,9 @@ struct UnifiedCaptureFlow: View {
        }

        try? ctx.save()
+        // 后台预生成大白话摘要:用户继续操作,详情页打开时秒开。
+        // 低优先级 —— 任何前台 AI 任务(再次拍照/问答)都会让它在下一个 token 让位。
+        Task { await ReportInsightService.shared.pregenerateIfNeeded(report: report, in: ctx) }
        onClose()
    }
 }
--- a/康康/Features/Diary/DiaryQuickSheet.swift
+++ b/康康/Features/Diary/DiaryQuickSheet.swift
@@ -37,6 +37,27 @@ struct DiaryQuickSheet: View {
    @State private var detent: PresentationDetent = .large
    @FocusState private var contentFocused: Bool

+    // MARK: 语音输入状态(spec 2026-06-10-voice-diary)
+
+    enum VoicePhase: Equatable { case idle, recording, organizing }
+    @State private var voicePhase: VoicePhase = .idle
+    @State private var liveTranscript = ""
+    @State private var recordingSeconds = 0
+    /// 最近一次最终转写稿,「改用原话」回退用;再次录音时覆盖。
+    @State private var rawTranscript: String?
+    /// 刚追加进正文的整理稿,用于「改用原话」时在正文中定位替换。
+    /// 用户手动编辑掉该段(正文中找不到了)时 pill 自然消失。
+    @State private var organizedAppended: String?
+    /// 一次性提示条文案(整理失败已填原话 / 没听清等),开始新录音时清掉。
+    @State private var voiceNote: String?
+    @State private var voiceDeniedAlert = false
+    @State private var voiceFlowTask: Task<Void, Never>?
+    @State private var recordingWatchdog: Task<Void, Never>?
+    /// 必须 @State:struct View 重建(键盘收起/detent 变化都会触发)时普通 let 会换成
+    /// 全新实例,导致 stop() 落在没在录音的新服务上返回空串(「没听清」假错误),
+    /// 且真正在录音的老实例关不掉、麦克风悬挂。@State 保证视图身份期内实例唯一。
+    @State private var dictation = SpeechDictationService()
+
    private var hasContent: Bool {
        !content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }
@@ -45,7 +66,7 @@ struct DiaryQuickSheet: View {
        if case .loading = phase { return true }
        return false
    }
-    private var canRequestSuggest: Bool { hasContent && !isLoading }
+    private var canRequestSuggest: Bool { hasContent && !isLoading && voicePhase == .idle }
    private var canSubmit: Bool { hasContent }

    var body: some View {
@@ -77,7 +98,29 @@ struct DiaryQuickSheet: View {
                ScrollView(showsIndicators: false) {
                    VStack(alignment: .leading, spacing: 16) {
                        VStack(alignment: .leading, spacing: 8) {
-                            sectionLabel(String(appLoc: "内容"))
+                            HStack {
+                                sectionLabel(String(appLoc: "内容"))
+                                Spacer()
+                                if SpeechDictationService.isAvailable, voicePhase == .idle {
+                                    Button(action: startVoice) {
+                                        HStack(spacing: 4) {
+                                            Image(systemName: "mic.fill")
+                                                .font(.tjScaled(11, weight: .semibold))
+                                            Text("说一段")
+                                                .font(.tjScaled(12, weight: .semibold))
+                                        }
+                                        .foregroundStyle(isLoading ? Tj.Palette.text3 : Tj.Palette.brick)
+                                        .padding(.horizontal, 10)
+                                        .padding(.vertical, 5)
+                                        .background(Capsule().strokeBorder(
+                                            isLoading ? Tj.Palette.line : Tj.Palette.brick.opacity(0.5),
+                                            lineWidth: 1))
+                                        .contentShape(Capsule())
+                                    }
+                                    .buttonStyle(.plain)
+                                    .disabled(isLoading)   // AI 追问生成中不抢 AIRuntime 队列
+                                }
+                            }
                            TextField("今天身体怎么样?吃了什么药、有什么感觉?",
                                      text: $content, axis: .vertical)
                                .lineLimit(3...8)
@@ -93,6 +136,48 @@ struct DiaryQuickSheet: View {
                                    RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
                                        .strokeBorder(Tj.Palette.line, lineWidth: 1)
                                )
+
+                            if voicePhase != .idle {
+                                DiaryVoicePanel(
+                                    mode: voicePhase == .organizing
+                                        ? .organizing
+                                        : .recording(elapsedSeconds: recordingSeconds),
+                                    transcript: liveTranscript,
+                                    onStop: stopVoiceAndOrganize,
+                                    onCancelOrganize: cancelOrganize
+                                )
+                            }
+
+                            if let note = voiceNote {
+                                HStack(spacing: 6) {
+                                    Image(systemName: "info.circle")
+                                        .font(.tjScaled(11))
+                                        .foregroundStyle(Tj.Palette.text3)
+                                    Text(note)
+                                        .font(.tjScaled(11))
+                                        .foregroundStyle(Tj.Palette.text3)
+                                    Spacer(minLength: 0)
+                                }
+                            }
+
+                            if let organized = organizedAppended,
+                               rawTranscript != nil,
+                               content.range(of: organized) != nil {
+                                Button(action: revertToRawTranscript) {
+                                    HStack(spacing: 4) {
+                                        Image(systemName: "arrow.uturn.backward")
+                                            .font(.tjScaled(10, weight: .semibold))
+                                        Text("改用原话")
+                                            .font(.tjScaled(11, weight: .semibold))
+                                    }
+                                    .foregroundStyle(Tj.Palette.ink)
+                                    .padding(.horizontal, 10)
+                                    .padding(.vertical, 5)
+                                    .background(Capsule().strokeBorder(Tj.Palette.line, lineWidth: 1))
+                                    .contentShape(Capsule())
+                                }
+                                .buttonStyle(.plain)
+                            }
                        }

                        assistSection
@@ -143,7 +228,22 @@ struct DiaryQuickSheet: View {
        .presentationDragIndicator(.hidden)
        .presentationBackground(Tj.Palette.sand)
        .presentationCornerRadius(Tj.Radius.xl)
-        .onDisappear { suggestTask?.cancel() }
+        .onDisappear {
+            suggestTask?.cancel()
+            voiceFlowTask?.cancel()
+            recordingWatchdog?.cancel()
+            dictation.abort()
+        }
+        .alert(String(appLoc: "需要麦克风与语音识别权限"), isPresented: $voiceDeniedAlert) {
+            Button(String(appLoc: "前往设置")) {
+                if let url = URL(string: UIApplication.openSettingsURLString) {
+                    UIApplication.shared.open(url)
+                }
+            }
+            Button(String(appLoc: "取消"), role: .cancel) {}
+        } message: {
+            Text("语音记录全程在本机完成,声音和文字都不会上传。请在设置中允许麦克风和语音识别。")
+        }
    }

    // MARK: - AI 辅助区
@@ -182,6 +282,7 @@ struct DiaryQuickSheet: View {
                        questionRow(index: roundLocalIndex(at: idx), question: q)
                    }
                }
+                AIDisclaimerFooter()
            }

            if exhaustedNote {
@@ -212,30 +313,12 @@ struct DiaryQuickSheet: View {
                    ? String(appLoc: "让 AI 帮我想想还能记什么")
                    : String(appLoc: "先写几个字,AI 来帮忙补充"),
                enabled: canRequestSuggest,
+                prominent: true,
                action: requestSuggestions
            )

        case .loading:
-            HStack(spacing: 10) {
-                ProgressView().controlSize(.small)
-                Text("AI 思考中…  本地推理,通常 5-10 秒")
-                    .font(.tjScaled( 13))
-                    .foregroundStyle(Tj.Palette.text2)
-                Spacer()
-                Button("取消") { cancelSuggestions() }
-                    .font(.tjScaled( 12, weight: .semibold))
-                    .foregroundStyle(Tj.Palette.text3)
-            }
-            .padding(.vertical, 11)
-            .padding(.horizontal, 12)
-            .background(
-                RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
-                    .fill(Tj.Palette.paper)
-            )
-            .overlay(
-                RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
-                    .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
-            )
+            assistLoadingIndicator

        case .ready:
            assistPrimaryButton(
@@ -273,26 +356,25 @@ struct DiaryQuickSheet: View {
        }
    }

+    /// 辅助主按钮。`prominent` 为真走实心强调样式(填充 brick + 白字 + 轻投影,一眼可点),
+    /// 否则走低调描边样式(用于 .ready 的「再问一轮」)。
    private func assistPrimaryButton(icon: String,
                                     label: String,
                                     enabled: Bool,
+                                     prominent: Bool = false,
                                     action: @escaping () -> Void) -> some View {
        Button(action: action) {
            HStack(spacing: 8) {
                Image(systemName: icon)
                Text(label)
            }
-            .font(.tjScaled( 13, weight: .semibold))
-            .foregroundStyle(enabled ? Tj.Palette.ink : Tj.Palette.text3)
+            .font(.tjScaled( prominent ? 14 : 13, weight: .semibold))
+            .foregroundStyle(prominent
+                ? (enabled ? Tj.Palette.paper : Tj.Palette.text3)
+                : (enabled ? Tj.Palette.ink : Tj.Palette.text3))
            .frame(maxWidth: .infinity)
-            .padding(.vertical, 11)
-            .background(
-                RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
-                    .strokeBorder(
-                        enabled ? Tj.Palette.ink : Tj.Palette.line,
-                        style: StrokeStyle(lineWidth: 1, dash: enabled ? [] : [3, 3])
-                    )
-            )
+            .padding(.vertical, prominent ? 14 : 11)
+            .background(assistButtonBackground(enabled: enabled, prominent: prominent))
            // 纯描边背景、内部透明:补 contentShape 让整框可点(否则只有图标+文字本体能点)。
            .contentShape(Rectangle())
        }
@@ -300,6 +382,58 @@ struct DiaryQuickSheet: View {
        .disabled(!enabled)
    }

+    @ViewBuilder
+    private func assistButtonBackground(enabled: Bool, prominent: Bool) -> some View {
+        let shape = RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+        if prominent {
+            shape
+                .fill(enabled ? Tj.Palette.brick : Tj.Palette.brickSoft)
+                .shadow(color: enabled ? Tj.Palette.brick.opacity(0.30) : .clear,
+                        radius: 8, x: 0, y: 3)
+        } else {
+            shape
+                .strokeBorder(
+                    enabled ? Tj.Palette.ink : Tj.Palette.line,
+                    style: StrokeStyle(lineWidth: 1, dash: enabled ? [] : [3, 3])
+                )
+        }
+    }
+
+    /// .loading 等待态:安静的 paper 卡片,底部一条细窄的不确定进度条来回滑动(Linear/Vercel 式极简)。
+    /// 不用高亮扫光、不填强调色,避免刺眼;只靠细线 + sparkles 轻脉冲传达「在算」。
+    private var assistLoadingIndicator: some View {
+        HStack(spacing: 10) {
+            Image(systemName: "sparkles")
+                .font(.tjScaled( 12, weight: .semibold))
+                .foregroundStyle(Tj.Palette.brick)
+                .symbolEffect(.pulse, options: .repeating)
+            Text(lastRate > 0
+                 ? String(format: String(appLoc: "AI 生成中 · %.1f tok/s"), lastRate)
+                 : String(appLoc: "AI 生成中 · 本地推理"))
+                .font(.tjScaled( 13, weight: .medium))
+                .foregroundStyle(Tj.Palette.text2)
+            Spacer(minLength: 0)
+            Button("取消") { cancelSuggestions() }
+                .font(.tjScaled( 12, weight: .semibold))
+                .foregroundStyle(Tj.Palette.text3)
+        }
+        .padding(.vertical, 11)
+        .padding(.horizontal, 12)
+        .frame(maxWidth: .infinity)
+        .background(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .fill(Tj.Palette.paper)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+        )
+        .overlay(alignment: .bottom) {
+            AIFlowBar().padding(.horizontal, 1)
+        }
+        .clipShape(RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous))
+    }
+
    /// 给定整张 questions list 里 idx 位置的 question,返回它在自己 round 内的序号(1-based)。
    private func roundLocalIndex(at idx: Int) -> Int {
        let target = questions[idx].round
@@ -421,6 +555,100 @@ struct DiaryQuickSheet: View {
            .foregroundStyle(Tj.Palette.text2)
    }

+    // MARK: 语音输入流程
+
+    private func startVoice() {
+        contentFocused = false
+        voiceNote = nil
+        voiceFlowTask = Task { @MainActor in
+            guard await dictation.requestAuthorization() else {
+                voiceDeniedAlert = true
+                return
+            }
+            do {
+                liveTranscript = ""
+                recordingSeconds = 0
+                try dictation.start { partial in liveTranscript = partial }
+                withAnimation(.snappy(duration: 0.2)) { voicePhase = .recording }
+                // 计时 + 3 分钟看门狗(到点自动停,行为与点「停止」一致)
+                recordingWatchdog = Task { @MainActor in
+                    while !Task.isCancelled {
+                        try? await Task.sleep(nanoseconds: 1_000_000_000)
+                        guard !Task.isCancelled, voicePhase == .recording else { return }
+                        recordingSeconds += 1
+                        if recordingSeconds >= DiaryVoicePanel.maxRecordingSeconds {
+                            stopVoiceAndOrganize()
+                            return
+                        }
+                    }
+                }
+            } catch {
+                voiceNote = error.localizedDescription
+                voicePhase = .idle
+            }
+        }
+    }
+
+    private func stopVoiceAndOrganize() {
+        guard voicePhase == .recording else { return }
+        recordingWatchdog?.cancel()
+        voiceFlowTask = Task { @MainActor in
+            // 防御兜底:服务返回空(极端情况下实例丢失/最终结果丢失)时,
+            // 用 @State 里的实时字幕——那就是用户亲眼看到的已识别文字。
+            var transcript = (await dictation.stop())
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if transcript.isEmpty {
+                transcript = liveTranscript.trimmingCharacters(in: .whitespacesAndNewlines)
+            }
+            liveTranscript = transcript
+            guard !transcript.isEmpty else {
+                withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+                voiceNote = String(appLoc: "没听清,再试一次")
+                return
+            }
+            rawTranscript = transcript
+            withAnimation(.snappy(duration: 0.2)) { voicePhase = .organizing }
+            do {
+                let result = try await DiaryAssistService.shared.organize(transcript: transcript)
+                guard !Task.isCancelled else { return }
+                appendToContent(result.text)
+                organizedAppended = result.text
+                lastRate = result.decodeRate
+            } catch is CancellationError {
+                // cancelOrganize 已处理回退,这里只收尾
+            } catch {
+                guard !Task.isCancelled else { return }
+                appendToContent(transcript)   // 红线 #5:整理失败回退原话,不卡死
+                organizedAppended = nil
+                voiceNote = String(appLoc: "AI 整理失败,已填入原话")
+            }
+            withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+        }
+    }
+
+    /// 取消整理:中断 LLM,直接填原话(与失败回退同路径)。
+    private func cancelOrganize() {
+        guard voicePhase == .organizing else { return }
+        voiceFlowTask?.cancel()
+        if let raw = rawTranscript {
+            appendToContent(raw)
+            organizedAppended = nil
+            voiceNote = String(appLoc: "已取消整理,填入原话")
+        }
+        withAnimation(.snappy(duration: 0.2)) { voicePhase = .idle }
+    }
+
+    /// 「改用原话」:把刚追加的整理稿替换为原始转写稿(spec §2:LLM 改数兜底)。
+    private func revertToRawTranscript() {
+        guard let raw = rawTranscript,
+              let organized = organizedAppended,
+              let range = content.range(of: organized, options: .backwards) else { return }
+        withAnimation(.snappy(duration: 0.18)) {
+            content = content.replacingCharacters(in: range, with: raw)
+            organizedAppended = nil
+        }
+    }
+
    /// 触发一轮 AI 辅助。把已覆盖的问诊维度(coveredDims)传给 LLM,
    /// 要求本轮避开这些维度,从结构上压住跨轮换皮重复。
    private func requestSuggestions() {
--- a/康康/Features/Diary/DiaryVoicePanel.swift
+++ b/康康/Features/Diary/DiaryVoicePanel.swift
@@ -0,0 +1,141 @@
+import SwiftUI
+
+/// 「健康记录」语音输入面板(spec 2026-06-10-voice-diary)。
+/// 两种模式:recording(实时字幕 + 计时 + 停止)/ organizing(AI 整理中,可取消)。
+/// 纯展示:状态由 DiaryQuickSheet 持有并传入。
+struct DiaryVoicePanel: View {
+    enum Mode: Equatable {
+        case recording(elapsedSeconds: Int)
+        case organizing
+    }
+
+    let mode: Mode
+    /// recording 时为实时字幕;organizing 时为已定稿的转写稿(置灰展示)。
+    let transcript: String
+    let onStop: () -> Void
+    let onCancelOrganize: () -> Void
+
+    /// 录音上限 3 分钟(超时由 DiaryQuickSheet 的看门狗触发 onStop)。
+    static let maxRecordingSeconds = 180
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            header
+            transcriptArea
+            if case .recording = mode {
+                stopButton
+            }
+        }
+        .padding(12)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .fill(Tj.Palette.paper)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+        )
+        .overlay(alignment: .bottom) {
+            if mode == .organizing {
+                AIFlowBar().padding(.horizontal, 1)
+            }
+        }
+        .clipShape(RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous))
+    }
+
+    @ViewBuilder
+    private var header: some View {
+        switch mode {
+        case .recording(let elapsed):
+            HStack(spacing: 8) {
+                Image(systemName: "waveform")
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.brick)
+                    .symbolEffect(.variableColor.iterative, options: .repeating)
+                Text("正在听 · 识别在本机完成")
+                    .font(.tjScaled(13, weight: .medium))
+                    .foregroundStyle(Tj.Palette.text2)
+                Spacer(minLength: 0)
+                Text(Self.format(elapsed))
+                    .font(.tjScaled(12, design: .monospaced))
+                    .foregroundStyle(elapsed >= Self.maxRecordingSeconds - 30
+                                     ? Tj.Palette.brick : Tj.Palette.text3)
+            }
+        case .organizing:
+            HStack(spacing: 8) {
+                Image(systemName: "sparkles")
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.brick)
+                    .symbolEffect(.pulse, options: .repeating)
+                Text("AI 整理中 · 本地推理")
+                    .font(.tjScaled(13, weight: .medium))
+                    .foregroundStyle(Tj.Palette.text2)
+                Spacer(minLength: 0)
+                Button("取消") { onCancelOrganize() }
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.text3)
+            }
+        }
+    }
+
+    @ViewBuilder
+    private var transcriptArea: some View {
+        ScrollViewReader { proxy in
+            ScrollView(showsIndicators: false) {
+                Text(transcript.isEmpty ? String(appLoc: "开始说话…") : transcript)
+                    .font(.tjScaled(14))
+                    .foregroundStyle(transcriptColor)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .fixedSize(horizontal: false, vertical: true)
+                Color.clear.frame(height: 1).id("tail")
+            }
+            .frame(maxHeight: 120)
+            .onChange(of: transcript) { _, _ in
+                proxy.scrollTo("tail", anchor: .bottom)
+            }
+        }
+    }
+
+    private var transcriptColor: Color {
+        if transcript.isEmpty { return Tj.Palette.text3 }
+        return mode == .organizing ? Tj.Palette.text3 : Tj.Palette.text
+    }
+
+    private var stopButton: some View {
+        Button(action: onStop) {
+            HStack(spacing: 8) {
+                Image(systemName: "stop.circle.fill")
+                Text("说完了,整理成日记")
+            }
+            .font(.tjScaled(14, weight: .semibold))
+            .foregroundStyle(Tj.Palette.paper)
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, 12)
+            .background(
+                RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
+                    .fill(Tj.Palette.brick)
+            )
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+
+    private static func format(_ seconds: Int) -> String {
+        String(format: "%d:%02d", seconds / 60, seconds % 60)
+    }
+}
+
+#Preview("录音中") {
+    DiaryVoicePanel(mode: .recording(elapsedSeconds: 23),
+                    transcript: "今天早上起来有点头晕,量了血压一百四九十",
+                    onStop: {}, onCancelOrganize: {})
+        .padding()
+}
+
+#Preview("整理中") {
+    DiaryVoicePanel(mode: .organizing,
+                    transcript: "今天早上起来有点头晕,量了血压一百四九十",
+                    onStop: {}, onCancelOrganize: {})
+        .padding()
+}
--- a/康康/Features/Indicator/IndicatorQuickSheet.swift
+++ b/康康/Features/Indicator/IndicatorQuickSheet.swift
@@ -143,6 +143,7 @@ struct IndicatorQuickSheet: View {
                .clipShape(RoundedRectangle(cornerRadius: Tj.Radius.xl, style: .continuous))
                .ignoresSafeArea(edges: .bottom)
        )
+        .preferredColorScheme(.light)
        .presentationDetents([.large])
        .presentationDragIndicator(.hidden)
        .presentationBackground(Tj.Palette.sand)
@@ -173,7 +174,7 @@ struct IndicatorQuickSheet: View {
        .padding(.bottom, 16)
    }

-    /// 顶部「拍照识别」入口:并入原「异常项快拍」。点后由 RootView 切到相机 VL 流程。
+    /// 顶部「拍照识别」入口:并入原「指标速记」。点后由 RootView 切到相机 VL 流程。
    @ViewBuilder
    private var cameraEntrySection: some View {
        if let onRequestCamera {
@@ -423,6 +424,8 @@ struct IndicatorQuickSheet: View {
            TextField(placeholder, text: value)
                .keyboardType(.decimalPad)
                .font(.tjScaled( 20, weight: .semibold, design: .monospaced))
+                .foregroundStyle(Tj.Palette.text)
+                .tint(Tj.Palette.ink)
                .multilineTextAlignment(.center)
                .padding(.vertical, 10)
                .frame(width: 90)
@@ -468,6 +471,8 @@ struct IndicatorQuickSheet: View {
            sectionLabel(String(appLoc: "指标名"))
            TextField("例如:血红蛋白", text: $name)
                .textInputAutocapitalization(.never)
+                .foregroundStyle(Tj.Palette.text)
+                .tint(Tj.Palette.ink)
                .padding(.horizontal, 14)
                .padding(.vertical, 12)
                .background(fieldBg)
@@ -489,6 +494,8 @@ struct IndicatorQuickSheet: View {
                TextField(monitorFieldPlaceholder, text: $value)
                    .keyboardType(.decimalPad)
                    .font(.tjScaled( 18, weight: .semibold, design: .monospaced))
+                    .foregroundStyle(Tj.Palette.text)
+                    .tint(Tj.Palette.ink)
                    .padding(.horizontal, 14)
                    .padding(.vertical, 12)
                    .background(fieldBg)
@@ -499,6 +506,8 @@ struct IndicatorQuickSheet: View {
                TextField("mmol/L", text: $unit)
                    .textInputAutocapitalization(.never)
                    .autocorrectionDisabled()
+                    .foregroundStyle(Tj.Palette.text)
+                    .tint(Tj.Palette.ink)
                    .padding(.horizontal, 14)
                    .padding(.vertical, 12)
                    .background(fieldBg)
@@ -522,6 +531,8 @@ struct IndicatorQuickSheet: View {
            TextField("例如:< 3.40 或 3.9 - 6.1", text: $range)
                .textInputAutocapitalization(.never)
                .autocorrectionDisabled()
+                .foregroundStyle(Tj.Palette.text)
+                .tint(Tj.Palette.ink)
                .padding(.horizontal, 14)
                .padding(.vertical, 12)
                .background(fieldBg)
@@ -581,6 +592,8 @@ struct IndicatorQuickSheet: View {
            sectionLabel(String(appLoc: "备注(可选)"))
            TextField("例如:空腹采血", text: $note, axis: .vertical)
                .lineLimit(1...3)
+                .foregroundStyle(Tj.Palette.text)
+                .tint(Tj.Palette.ink)
                .padding(.horizontal, 14)
                .padding(.vertical, 12)
                .background(fieldBg)
--- a/康康/Features/Me/InferenceSettingsView.swift
+++ b/康康/Features/Me/InferenceSettingsView.swift
@@ -0,0 +1,153 @@
+import SwiftUI
+
+/// 推理引擎设置:在 MNN(CPU/SME2,考核路径)与 MLX(GPU,兜底)间切换,并展示 SME2 探测状态。
+/// 切换只改持久化选择;下一次 AI 调用(prepare/generate)按新引擎加载。
+struct InferenceSettingsView: View {
+    @AppStorage("kk.inferenceEngine") private var engineRaw = EnginePreference.auto.rawValue
+
+    private var selected: EnginePreference {
+        EnginePreference(rawValue: engineRaw) ?? .auto
+    }
+
+    var body: some View {
+        ScrollView {
+            VStack(spacing: 12) {
+                HStack {
+                    Text("推理引擎")
+                        .font(.tjTitle())
+                        .foregroundStyle(Tj.Palette.text)
+                    Spacer()
+                }
+                .padding(.top, 4)
+                .padding(.bottom, 6)
+
+                ForEach(EnginePreference.allCases, id: \.self) { engine in
+                    engineRow(engine)
+                }
+
+                sme2Card
+                noteCard
+            }
+            .padding(.horizontal, 16)
+            .padding(.vertical, 20)
+        }
+        .background(Tj.Palette.sand.ignoresSafeArea())
+    }
+
+    private func engineRow(_ engine: EnginePreference) -> some View {
+        let available = isAvailable(engine)
+        let isOn = (selected == engine)
+        return Button {
+            guard available else { return }
+            engineRaw = engine.rawValue
+        } label: {
+            HStack(spacing: 12) {
+                ZStack {
+                    Circle().fill(isOn ? Tj.Palette.amber.opacity(0.25) : Tj.Palette.sand2)
+                    Image(systemName: iconName(engine))
+                        .font(.tjScaled(18))
+                        .foregroundStyle(isOn ? Tj.Palette.ink : Tj.Palette.text2)
+                }
+                .frame(width: 44, height: 44)
+
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(engine.displayName)
+                        .font(.tjScaled(15, weight: .semibold))
+                        .foregroundStyle(Tj.Palette.text)
+                    Text(subtitle(engine, available: available))
+                        .font(.tjScaled(12))
+                        .foregroundStyle(Tj.Palette.text3)
+                        .lineLimit(2)
+                }
+                Spacer()
+                if isOn {
+                    Image(systemName: "checkmark.circle.fill")
+                        .font(.tjScaled(18))
+                        .foregroundStyle(Tj.Palette.leaf)
+                }
+            }
+            .padding(14)
+            .tjCard()
+            .opacity(available ? 1 : 0.45)
+        }
+        .buttonStyle(.plain)
+        .disabled(!available)
+    }
+
+    /// .auto 永远可用;具体引擎看自身可用性。
+    private func isAvailable(_ engine: EnginePreference) -> Bool {
+        switch engine {
+        case .auto: return true
+        case .mnn:  return InferenceEngine.mnn.isAvailable
+        case .mlx:  return InferenceEngine.mlx.isAvailable
+        }
+    }
+
+    private func iconName(_ engine: EnginePreference) -> String {
+        switch engine {
+        case .auto: return "wand.and.stars"
+        case .mnn:  return "cpu.fill"
+        case .mlx:  return "bolt.fill"
+        }
+    }
+
+    private func subtitle(_ engine: EnginePreference, available: Bool) -> String {
+        switch engine {
+        case .auto:
+            // 显示自动解析后实际命中的引擎,让用户看清「这台机选了什么」。
+            let resolved = engine.resolved
+            if resolved == .mnn {
+                return InferenceEngine.cpuSupportsSME2
+                    ? String(appLoc: "按本机配置选择 · 当前 MNN + SME2")
+                    : String(appLoc: "按本机配置选择 · 当前 MNN(NEON)")
+            } else {
+                return String(appLoc: "按本机配置选择 · 当前 MLX(MNN 不可用)")
+            }
+        case .mnn:
+            if !available { return String(appLoc: "本设备/模拟器不可用,自动回退 MLX") }
+            return InferenceEngine.cpuSupportsSME2
+                ? String(appLoc: "端侧 CPU + SME2 加速 · 挑战赛考核路径")
+                : String(appLoc: "端侧 CPU(本机无 SME2,NEON 回退)")
+        case .mlx:
+            return String(appLoc: "Metal GPU · 兜底 / 对照")
+        }
+    }
+
+    private var sme2Card: some View {
+        let sme2 = InferenceEngine.cpuSupportsSME2
+        return HStack(spacing: 12) {
+            ZStack {
+                Circle().fill(sme2 ? Tj.Palette.leafSoft : Tj.Palette.sand2)
+                Image(systemName: sme2 ? "checkmark.seal.fill" : "minus.circle")
+                    .font(.tjScaled(18))
+                    .foregroundStyle(sme2 ? Tj.Palette.ink : Tj.Palette.text2)
+            }
+            .frame(width: 44, height: 44)
+            VStack(alignment: .leading, spacing: 2) {
+                Text("Arm SME2")
+                    .font(.tjScaled(15, weight: .medium))
+                    .foregroundStyle(Tj.Palette.text)
+                Text(sme2 ? String(appLoc: "本设备支持,MNN 已启用 SME2 加速")
+                          : String(appLoc: "本设备不支持(需 A19/iPhone 17+)"))
+                    .font(.tjScaled(12))
+                    .foregroundStyle(Tj.Palette.text3)
+            }
+            Spacer()
+        }
+        .padding(14)
+        .tjCard()
+    }
+
+    private var noteCard: some View {
+        Text("MNN 在端侧 CPU 上以 Arm SME2 指令集加速 Qwen 推理(本地、不上云)。切换后下一次 AI 调用生效。")
+            .font(.tjScaled(12))
+            .foregroundStyle(Tj.Palette.text3)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(14)
+            .tjCard()
+    }
+}
+
+#Preview {
+    InferenceSettingsView()
+}
--- a/康康/Features/Me/MeView.swift
+++ b/康康/Features/Me/MeView.swift
@@ -37,6 +37,7 @@ struct MeView: View {
                    profileCard
                    customMetricsCard
                    modelManagementCard
+                    inferenceEngineCard
                    languageCard
                    fontScaleCard
                    faceIDCard
@@ -151,10 +152,26 @@ struct MeView: View {

    private var modelDetail: String {
        let states = downloadService.states
-        if ModelKind.allCases.allSatisfy({ states[$0]?.phase == .ready }) { return String(appLoc: "已就绪") }
+        if ModelKind.userFacing.allSatisfy({ states[$0]?.phase == .ready }) { return String(appLoc: "已就绪") }
        if downloadService.isAnyDownloading { return String(appLoc: "下载中…") }
-        let readyCount = ModelKind.allCases.filter { states[$0]?.phase == .ready }.count
-        return readyCount == 0 ? String(appLoc: "未下载") : String(appLoc: "\(readyCount)/\(ModelKind.allCases.count) 就绪")
+        let readyCount = ModelKind.userFacing.filter { states[$0]?.phase == .ready }.count
+        return readyCount == 0 ? String(appLoc: "未下载") : String(appLoc: "\(readyCount)/\(ModelKind.userFacing.count) 就绪")
+    }
+
+    private var inferenceEngineCard: some View {
+        NavigationLink {
+            InferenceSettingsView()
+        } label: {
+            settingsCard(title: String(appLoc: "推理引擎"), detail: engineDetail, icon: "cpu.fill")
+        }
+        .buttonStyle(.plain)
+    }
+
+    private var engineDetail: String {
+        switch InferenceEngine.current {
+        case .mnn: return InferenceEngine.cpuSupportsSME2 ? "MNN · SME2" : "MNN · CPU"
+        case .mlx: return "MLX · GPU"
+        }
    }

    private var languageCard: some View {
--- a/康康/Features/Me/ModelManagementView.swift
+++ b/康康/Features/Me/ModelManagementView.swift
@@ -15,26 +15,26 @@ struct ModelManagementView: View {
    private let monitorQueue = DispatchQueue(label: "kk.netmonitor")

    private var allReady: Bool {
-        ModelKind.allCases.allSatisfy { service.states[$0]?.phase == .ready }
+        ModelKind.userFacing.allSatisfy { service.states[$0]?.phase == .ready }
    }

    var body: some View {
        ScrollView {
            VStack(spacing: 14) {
-                ForEach(ModelKind.allCases, id: \.self) { kind in
+                ForEach(ModelKind.userFacing, id: \.self) { kind in
                    modelCard(kind)
                }

                actionButtons
                    .padding(.top, 4)

-                if service.states[.llm]?.phase == .ready {
+                if service.states[.mnnLLM]?.phase == .ready || service.states[.llm]?.phase == .ready {
                    NavigationLink {
                        ModelSelfTestView()
                    } label: {
                        HStack(spacing: 6) {
-                            Image(systemName: "play.circle")
-                            Text("运行推理自检")
+                            Image(systemName: "gauge.with.needle")
+                            Text("性能自检")
                        }
                        .frame(maxWidth: .infinity)
                    }
@@ -146,7 +146,7 @@ struct ModelManagementView: View {
    private var actionButtons: some View {
        if service.isAnyDownloading {
            Button {
-                for kind in ModelKind.allCases { service.cancel(kind) }
+                for kind in ModelKind.userFacing { service.cancel(kind) }
            } label: {
                Text("暂停下载").frame(maxWidth: .infinity)
            }
@@ -154,7 +154,7 @@ struct ModelManagementView: View {
        } else if allReady {
            HStack(spacing: 6) {
                Image(systemName: "checkmark.seal.fill")
-                Text("两个模型都已就绪")
+                Text("Qwen3.5-2B 已就绪")
            }
            .font(.tjScaled( 13, weight: .semibold))
            .foregroundStyle(Tj.Palette.leaf)
@@ -198,8 +198,8 @@ struct ModelManagementView: View {
            defer { if scoped { folder.stopAccessingSecurityScopedResource() } }

            let name = folder.lastPathComponent
-            guard let kind = ModelKind.allCases.first(where: { $0.rawValue == name }) else {
-                let names = ModelKind.allCases.map(\.rawValue).joined(separator: " 或 ")
+            guard let kind = ModelKind.userFacing.first(where: { $0.rawValue == name }) else {
+                let names = ModelKind.userFacing.map(\.rawValue).joined(separator: " 或 ")
                importError = String(appLoc: "请选择名为 \(names) 的文件夹")
                return
            }
@@ -213,13 +213,14 @@ struct ModelManagementView: View {
    // MARK: - 辅助

    private var totalAllBytes: Int {
-        ModelKind.allCases.reduce(0) { $0 + ModelManifest.totalBytes(for: $1) }
+        ModelKind.userFacing.reduce(0) { $0 + ModelManifest.totalBytes(for: $1) }
    }

    private func subtitle(_ kind: ModelKind) -> String {
        switch kind {
-        case .llm: return String(appLoc: "文本解读 · 趋势 / 问答")
-        case .vl:  return String(appLoc: "拍照识别报告 → 结构化指标")
+        case .llm:    return String(appLoc: "文本解读 · 趋势 / 问答(MLX 兜底)")
+        case .vl:     return String(appLoc: "拍照识别报告 → 结构化指标")
+        case .mnnLLM: return String(appLoc: "文本解读 + 拍照识别 · MNN + SME2 端侧加速")
        }
    }

--- a/康康/Features/Me/ModelSelfTestView.swift
+++ b/康康/Features/Me/ModelSelfTestView.swift
@@ -1,11 +1,13 @@
 import SwiftUI

-/// 模型推理自检:加载 LLM 跑一段固定 prompt,流式显示输出 + tok/s。
-/// 模型就绪后从「我的 · 模型管理」进入,用于现场快速验证本地推理是否正常。
+/// 性能自检:跑固定 prompt,展示当前后端(MNN·SME2 / MNN·NEON / MLX·GPU)的
+/// prefill / decode 实测速度,并按后端存档对比 —— 挑战赛考核点的可见证据(§12 卖点 2/6)。
 struct ModelSelfTestView: View {
    @State private var output = ""
    @State private var phase: Phase = .idle
    @State private var rate: Double = 0
+    @State private var lastResult: BenchmarkResult?
+    @State private var history: [String: BenchmarkResult] = [:]

    private enum Phase: Equatable {
        case idle, loading, running, done, failed(String)
@@ -21,8 +23,6 @@ struct ModelSelfTestView: View {
        }
    }

-    private let prompt = "用中文一句话介绍肝功能里 ALT 这个指标。"
-
    private var isBusy: Bool { phase == .loading || phase == .running }

    private var statusColor: Color {
@@ -34,79 +34,162 @@ struct ModelSelfTestView: View {
    }

    var body: some View {
-        VStack(alignment: .leading, spacing: 16) {
-            VStack(alignment: .leading, spacing: 6) {
-                Text("测试 PROMPT")
-                    .font(.tjScaled( 11, weight: .semibold))
-                    .tracking(0.5)
-                    .foregroundStyle(Tj.Palette.text3)
-                Text(prompt)
-                    .font(.tjScaled( 14))
-                    .foregroundStyle(Tj.Palette.text)
-            }
-            .padding(14)
-            .frame(maxWidth: .infinity, alignment: .leading)
-            .tjCard()
+        ScrollView {
+            VStack(alignment: .leading, spacing: 16) {
+                promptCard

+                HStack {
+                    Text(phase.label)
+                        .font(.tjScaled( 13, weight: .medium))
+                        .foregroundStyle(statusColor)
+                        .lineLimit(1)
+                    Spacer()
+                    if rate > 0 {
+                        Text(String(format: "%.1f tok/s", rate))
+                            .font(.tjScaled( 12, design: .monospaced))
+                            .foregroundStyle(Tj.Palette.text3)
+                    }
+                }
+
+                Button {
+                    Task { await run() }
+                } label: {
+                    Text(isBusy ? "运行中…" : "运行性能自检").frame(maxWidth: .infinity)
+                }
+                .buttonStyle(TjPrimaryButton())
+                .disabled(isBusy)
+
+                if isBusy { AIFlowBar() }
+
+                if let r = lastResult { statsCard(r) }
+
+                outputCard
+
+                if !history.isEmpty { historyCard }
+            }
+            .padding(16)
+        }
+        .background(Tj.Palette.sand.ignoresSafeArea())
+        .navigationTitle("性能自检")
+        .navigationBarTitleDisplayMode(.inline)
+        .onAppear { history = BenchmarkService.load() }
+    }
+
+    private var promptCard: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            Text("测试 PROMPT")
+                .font(.tjScaled( 11, weight: .semibold))
+                .tracking(0.5)
+                .foregroundStyle(Tj.Palette.text3)
+            Text(BenchmarkService.fixedPrompt)
+                .font(.tjScaled( 14))
+                .foregroundStyle(Tj.Palette.text)
+        }
+        .padding(14)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .tjCard()
+    }
+
+    private func statsCard(_ r: BenchmarkResult) -> some View {
+        VStack(alignment: .leading, spacing: 10) {
            HStack {
-                Text(phase.label)
-                    .font(.tjScaled( 13, weight: .medium))
-                    .foregroundStyle(statusColor)
-                    .lineLimit(1)
+                Text("本次结果")
+                    .font(.tjScaled( 12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.text2)
                Spacer()
-                if rate > 0 {
-                    Text(String(format: "%.1f tok/s", rate))
-                        .font(.tjScaled( 12, design: .monospaced))
-                        .foregroundStyle(Tj.Palette.text3)
+                TjBadge(text: r.backendLabel, style: .leaf)
+            }
+            HStack(spacing: 0) {
+                metric(String(appLoc: "读入"), r.prefillTokensPerSecond > 0
+                       ? String(format: "%.0f tok/s", r.prefillTokensPerSecond) : "—")
+                metric(String(appLoc: "生成"), String(format: "%.1f tok/s", r.decodeTokensPerSecond))
+                metric(String(appLoc: "总耗时"), String(format: "%.1fs", r.totalSeconds))
+            }
+            Text(String(appLoc: "prompt \(r.promptTokens) tok · 生成 \(r.genTokens) tok · 100% 本地"))
+                .font(.tjScaled( 10, design: .monospaced))
+                .foregroundStyle(Tj.Palette.text3)
+        }
+        .padding(14)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .tjCard()
+    }
+
+    private func metric(_ label: String, _ value: String) -> some View {
+        VStack(spacing: 3) {
+            Text(value)
+                .font(.tjScaled( 15, weight: .semibold, design: .monospaced))
+                .foregroundStyle(Tj.Palette.text)
+            Text(label)
+                .font(.tjScaled( 10))
+                .foregroundStyle(Tj.Palette.text3)
+        }
+        .frame(maxWidth: .infinity)
+    }
+
+    private var outputCard: some View {
+        ScrollView {
+            Text(output.isEmpty ? "(暂无输出)" : output)
+                .font(.system(.footnote, design: .monospaced))
+                .foregroundStyle(Tj.Palette.text)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .textSelection(.enabled)
+                .padding(12)
+        }
+        .frame(maxHeight: 220)
+        .background(
+            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                .fill(Tj.Palette.paper)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+        )
+    }
+
+    private var historyCard: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            Text("各引擎实测对比")
+                .font(.tjScaled( 12, weight: .semibold))
+                .foregroundStyle(Tj.Palette.text2)
+            ForEach(history.keys.sorted(), id: \.self) { key in
+                if let r = history[key] {
+                    HStack {
+                        Text(key)
+                            .font(.tjScaled( 12, weight: .medium))
+                            .foregroundStyle(Tj.Palette.text)
+                        Spacer()
+                        Text(String(format: String(appLoc: "生成 %.1f tok/s"), r.decodeTokensPerSecond))
+                            .font(.tjScaled( 12, design: .monospaced))
+                            .foregroundStyle(Tj.Palette.leaf)
+                        Text(r.date.formatted(.dateTime.month().day()))
+                            .font(.tjScaled( 10))
+                            .foregroundStyle(Tj.Palette.text3)
+                    }
                }
            }
-
-            Button {
-                Task { await run() }
-            } label: {
-                Text(isBusy ? "运行中…" : "运行推理自检").frame(maxWidth: .infinity)
-            }
-            .buttonStyle(TjPrimaryButton())
-            .disabled(isBusy)
-
-            ScrollView {
-                Text(output.isEmpty ? "(暂无输出)" : output)
-                    .font(.system(.footnote, design: .monospaced))
-                    .foregroundStyle(Tj.Palette.text)
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .textSelection(.enabled)
-                    .padding(12)
-            }
-            .frame(maxHeight: 280)
-            .background(
-                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
-                    .fill(Tj.Palette.paper)
-            )
-            .overlay(
-                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
-                    .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
-            )
-
-            Spacer()
+            Text("在「我的 · 推理引擎」切换引擎后再跑一次,即可对比 SME2 与 GPU。")
+                .font(.tjScaled( 10))
+                .foregroundStyle(Tj.Palette.text3)
        }
-        .padding(16)
-        .background(Tj.Palette.sand.ignoresSafeArea())
-        .navigationTitle("推理自检")
-        .navigationBarTitleDisplayMode(.inline)
+        .padding(14)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .tjCard()
    }

    @MainActor
    private func run() async {
        output = ""
        rate = 0
+        lastResult = nil
        phase = .loading
        do {
-            try await AIRuntime.shared.prepare()
-            phase = .running
-            for try await chunk in await AIRuntime.shared.generate(prompt: prompt, maxTokens: 200) {
-                output += chunk.text
-                rate = chunk.decodeRate
+            let result = try await BenchmarkService.shared.run { piece, r in
+                output += piece
+                if r > 0 { rate = r }
+                if phase == .loading { phase = .running }
            }
+            lastResult = result
+            history = BenchmarkService.load()
            phase = .done
        } catch {
            phase = .failed(error.localizedDescription)
--- a/康康/Features/Profile/ProfileEditView.swift
+++ b/康康/Features/Profile/ProfileEditView.swift
@@ -370,17 +370,14 @@ private struct ChronicSection: View {
                }
            }

-            HStack {
-                TextField("自定义慢病", text: $newCustomCondition)
-                Button("加") {
-                    let trimmed = newCustomCondition.trimmingCharacters(in: .whitespaces)
-                    guard !trimmed.isEmpty,
-                          !profile.chronicConditions.contains(trimmed) else { return }
-                    profile.chronicConditions.append(trimmed)
-                    newCustomCondition = ""
-                }
-                .disabled(newCustomCondition.trimmingCharacters(in: .whitespaces).isEmpty)
+            EntryInputField(placeholder: String(appLoc: "自定义慢病"), text: $newCustomCondition) {
+                let trimmed = newCustomCondition.trimmingCharacters(in: .whitespaces)
+                guard !trimmed.isEmpty,
+                      !profile.chronicConditions.contains(trimmed) else { return }
+                profile.chronicConditions.append(trimmed)
+                newCustomCondition = ""
            }
+            .listRowBackground(Color.clear)
        } header: {
            Text("慢病(影响参考范围与 AI 解读)")
        }
@@ -408,6 +405,51 @@ private struct ChronicSection: View {
    }
 }

+// MARK: - 聊天框风格的条目输入(圆角容器 + 多行增长 + 圆形发送按钮)
+
+/// 替代原先单行 `TextField + “加”` 的搜索框观感:文字随内容换行增长(1~4 行),
+/// 右侧圆形发送按钮(内容为空时禁用变灰)。过敏 / 家族史 / 用药 / 自定义慢病共用。
+private struct EntryInputField: View {
+    let placeholder: String
+    @Binding var text: String
+    var onSubmit: () -> Void
+
+    private var canSubmit: Bool {
+        !text.trimmingCharacters(in: .whitespaces).isEmpty
+    }
+
+    var body: some View {
+        HStack(alignment: .bottom, spacing: 8) {
+            TextField(placeholder, text: $text, axis: .vertical)
+                .lineLimit(1...5)
+                .foregroundStyle(Tj.Palette.text)   // 固定深色:避免深色模式下继承系统 .primary 变白看不清
+                .tint(Tj.Palette.ink)
+                .frame(minHeight: 40, alignment: .top)   // 初始就有聊天框体量,内容多了随 axis 增长
+                .padding(.horizontal, 14)
+                .padding(.vertical, 10)
+                .background(
+                    RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                        .fill(Tj.Palette.paper)
+                )
+                .overlay(
+                    RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                        .strokeBorder(Tj.Palette.line, lineWidth: 1)
+                )
+
+            Button {
+                if canSubmit { onSubmit() }
+            } label: {
+                Image(systemName: "arrow.up.circle.fill")
+                    .font(.tjScaled(28))
+                    .foregroundStyle(canSubmit ? Tj.Palette.ink : Tj.Palette.text3)
+            }
+            .buttonStyle(.plain)
+            .disabled(!canSubmit)
+        }
+        .padding(.vertical, 2)
+    }
+}
+
 // MARK: - 过敏 / 家族史 / 用药(每节自带 @State,敲字只重算本节)

 private struct StringListSection: View {
@@ -431,16 +473,13 @@ private struct StringListSection: View {
                    .buttonStyle(.borderless)
                }
            }
-            HStack {
-                TextField(placeholder, text: $newInput)
-                Button("加") {
-                    let trimmed = newInput.trimmingCharacters(in: .whitespaces)
-                    guard !trimmed.isEmpty, !items.contains(trimmed) else { return }
-                    items.append(trimmed)
-                    newInput = ""
-                }
-                .disabled(newInput.trimmingCharacters(in: .whitespaces).isEmpty)
+            EntryInputField(placeholder: placeholder, text: $newInput) {
+                let trimmed = newInput.trimmingCharacters(in: .whitespaces)
+                guard !trimmed.isEmpty, !items.contains(trimmed) else { return }
+                items.append(trimmed)
+                newInput = ""
            }
+            .listRowBackground(Color.clear)
        }
    }
 }
--- a/康康/Features/Quick/QuickRegionCaptureFlow.swift
+++ b/康康/Features/Quick/QuickRegionCaptureFlow.swift
@@ -2,7 +2,7 @@ import SwiftUI
 import SwiftData
 import UIKit

-/// 异常项快拍 · 统一流程。
+/// 指标速记 · 统一流程。
 /// 整幅单拍(真机)/ 相册(模拟器)→ 静态图手动框选 → 框内 OCR+LLM 抽指标 → 核对 → 存独立 Indicator。
 ///
 /// 状态机:
@@ -57,7 +57,7 @@ struct QuickRegionCaptureFlow: View {
                    onCancel: { onClose() },
                    onRetake: { phase = .idle }
                )
-                .navigationTitle(String(appLoc: "核对异常项"))
+                .navigationTitle(String(appLoc: "核对指标"))
                .navigationBarTitleDisplayMode(.inline)
                .toolbar {
                    ToolbarItem(placement: .topBarLeading) {
@@ -95,17 +95,18 @@ struct QuickRegionCaptureFlow: View {
        }
    }

-    // MARK: - 识别(框内子图 → OCR → LLM)
+    // MARK: - 识别(框内子图 → Vision OCR → Qwen3 整理)

    /// 对已裁好的框内子图跑识别。失败/超时返回提示文案,绝不抛出(由 RegionAdjustView 展示)。
-    /// 链路:Vision 端侧 OCR 取文本 → Qwen3-1.7B 结构化抽指标(对齐 indicator-capture-ocr-llm)。
+    /// 固定链路:Vision 端侧 OCR 出文字 → Qwen3 跑一次结构化整理抽指标。
+    /// (旧的「大模型直读」VL 路径已移除:端侧看图慢且易卡,OCR→整理又快又准。)
    private func recognizeRegion(_ image: UIImage) async -> (items: [QuickRegionItem], warning: String?) {
        do {
            let text = try await OCRService.recognizeText(in: image)
            if Task.isCancelled { return ([], nil) }   // 超时:文案由调用方给
            let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
            #if DEBUG
-            print("🔤 [OCR · region] recognized text:\n\(trimmed)\n--- end OCR ---")
+            NSLog("KKDBG-OCR region text:\n%@\n--- end OCR ---", trimmed)
            #endif
            if trimmed.isEmpty {
                return ([], String(appLoc: "没识别到文字,挪一下框再试"))
--- a/康康/Features/Quick/QuickRegionConfirmView.swift
+++ b/康康/Features/Quick/QuickRegionConfirmView.swift
@@ -1,7 +1,7 @@
 import SwiftUI
 import UIKit

-/// 异常项快拍 · 确认页。VL 识别结果逐项可编辑 + 勾选纳入,确认后只存数值(不留图)。
+/// 指标速记 · 确认页。VL 识别结果逐项可编辑 + 勾选纳入,确认后只存数值(不留图)。
 /// 与「记录指标」自由输入落库一致 —— 每个勾选项 = 一条独立 Indicator。
 struct QuickRegionConfirmView: View {
    let image: UIImage?
--- a/康康/Features/Quick/RegionAdjustView.swift
+++ b/康康/Features/Quick/RegionAdjustView.swift
@@ -2,7 +2,7 @@ import SwiftUI
 import AVFoundation
 import UIKit

-/// 异常项快拍 · 静态图框选识别。
+/// 指标速记 · 静态图框选识别。
 /// 拍/选一张后,在静态照片上手动拖动 + 缩放一个方框,点「识别」只对框内做 OCR+LLM。
 /// 可反复挪框重识别,满意后进入核对页;0 项也能进核对手动补(失败回退红线)。
 struct RegionAdjustView: View {
--- a/康康/Features/Quick/RegionCameraView.swift
+++ b/康康/Features/Quick/RegionCameraView.swift
@@ -3,7 +3,7 @@ import AVFoundation
 import UIKit
 import Combine

-/// 异常项快拍 · 整幅单拍相机。
+/// 指标速记 · 整幅单拍相机。
 /// 全屏实时预览 + 一个快门 → 返回**整幅** upright UIImage(不裁剪)。
 /// 拍完后由 `RegionAdjustView` 在静态图上手动框选识别区域。
 /// 只在真机可用(模拟器无相机,`QuickRegionCaptureFlow` 退化到 PhotoPicker)。
@@ -60,7 +60,7 @@ struct SingleShotCameraView: View {

            Spacer()

-            Text("拍一张含异常指标的照片 · 拍完再框选")
+            Text("拍一张含目标指标的照片 · 拍完再框选")
                .font(.tjScaled( 13, weight: .medium))
                .foregroundStyle(.white)
                .padding(.horizontal, 12)
@@ -97,7 +97,7 @@ struct SingleShotCameraView: View {
            Text("相机权限未开启")
                .font(.tjH2())
                .foregroundStyle(.white)
-            Text("异常项快拍需要相机。去「设置 → 康康 → 相机」打开后再回来。")
+            Text("指标速记需要相机。去「设置 → 康康 → 相机」打开后再回来。")
                .font(.tjScaled( 13))
                .foregroundStyle(.white.opacity(0.7))
                .multilineTextAlignment(.center)
--- a/康康/Features/Record/RecordSheet.swift
+++ b/康康/Features/Record/RecordSheet.swift
@@ -5,12 +5,12 @@ enum RecordKind: String, Identifiable, CaseIterable {
    var id: String { rawValue }

    /// RecordSheet 列表的展示顺序(从上到下)。与 enum 声明序解耦,改顺序只动这里。
-    /// 注:`.quick`(异常项快拍)已并入 `.indicator`(记录指标)内的「拍照识别」,不再单列。
+    /// 注:`.quick`(指标速记)已并入 `.indicator`(记录指标)内的「拍照识别」,不再单列。
    static let displayOrder: [RecordKind] = [.diary, .reminder, .symptom, .indicator, .healthExport, .archive]

    var title: String {
        switch self {
-        case .quick:     return String(appLoc: "异常项快拍")
+        case .quick:     return String(appLoc: "指标速记")
        case .indicator: return String(appLoc: "记录指标")
        case .healthExport: return String(appLoc: "身体档案")
        case .archive:   return String(appLoc: "体检报告归档")
--- a/康康/Features/Timeline/IndicatorSeriesDetailView.swift
+++ b/康康/Features/Timeline/IndicatorSeriesDetailView.swift
@@ -0,0 +1,457 @@
+import SwiftUI
+import SwiftData
+
+/// 一个指标的「同类组」标识。决定聚合详情里收哪些历次记录、跳哪个趋势 bucket。
+/// - `.series`:有 seriesKey 的长期监测指标(血糖/体重/...)。
+/// - `.bloodPressure`:血压(bp.systolic + bp.diastolic 合并成一对)。
+/// - `.lab`:无 seriesKey 的化验/手动指标,按 name+unit 归一化 key 聚合。
+enum IndicatorGroup: Identifiable, Hashable {
+    case series(key: String)
+    case bloodPressure
+    case lab(key: String)
+
+    var id: String {
+        switch self {
+        case .series(let k): return "series:\(k)"
+        case .bloodPressure: return "bp"
+        case .lab(let k):    return "lab:\(k)"
+        }
+    }
+
+    /// 从单条指标推断其所属同类组(与趋势页 SeriesBucket 的分组语义一致)。
+    static func of(_ i: Indicator) -> IndicatorGroup {
+        if let key = i.seriesKey, !key.isEmpty {
+            return key.hasPrefix("bp.") ? .bloodPressure : .series(key: key)
+        }
+        return .lab(key: SeriesBucket.normalizedKey(name: i.name, unit: i.unit))
+    }
+}
+
+/// 同类指标聚合详情:横向翻页看该指标的历次记录,底部可跳趋势图。
+/// 从「记录」页点指标条目进入。数据全部 @Query 实时,删除后翻页列表自动更新。
+struct IndicatorSeriesDetailView: View {
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.modelContext) private var ctx
+
+    let group: IndicatorGroup
+
+    @Query(sort: \Indicator.capturedAt, order: .reverse)
+    private var indicators: [Indicator]
+    @Query private var profiles: [UserProfile]
+    @Query private var customMetrics: [CustomMonitorMetric]
+
+    @State private var selection: String?
+    @State private var showTrend = false
+    @State private var showDeleteConfirm = false
+    @State private var evidenceTarget: Indicator?
+
+    // MARK: - 数据
+
+    /// 聚合详情里的一页:单值指标一条;血压一对。
+    private enum Record: Identifiable {
+        case single(Indicator)
+        case bp(sys: Indicator, dia: Indicator?)
+
+        var id: String {
+            switch self {
+            case .single(let i): return "\(i.persistentModelID)"
+            case .bp(let s, _):  return "bp-\(s.persistentModelID)"
+            }
+        }
+    }
+
+    /// 历次血压对:以 bp.systolic 为锚,按 ±5s 配 bp.diastolic(同 TimelineEntry 合并规则)。
+    private var bloodPressureRecords: [Record] {
+        let sysList = indicators
+            .filter { $0.seriesKey == "bp.systolic" }
+            .sorted { $0.capturedAt > $1.capturedAt }
+        var usedDia = Set<PersistentIdentifier>()
+        return sysList.map { sys in
+            let dia = indicators.first {
+                $0.seriesKey == "bp.diastolic" &&
+                !usedDia.contains($0.persistentModelID) &&
+                abs($0.capturedAt.timeIntervalSince(sys.capturedAt)) <= 5
+            }
+            if let dia { usedDia.insert(dia.persistentModelID) }
+            return .bp(sys: sys, dia: dia)
+        }
+    }
+
+    private var records: [Record] {
+        switch group {
+        case .bloodPressure:
+            return bloodPressureRecords
+        case .series(let key):
+            return indicators
+                .filter { $0.seriesKey == key }
+                .sorted { $0.capturedAt > $1.capturedAt }
+                .map(Record.single)
+        case .lab(let nk):
+            return indicators
+                .filter {
+                    ($0.seriesKey ?? "").isEmpty &&
+                    SeriesBucket.normalizedKey(name: $0.name, unit: $0.unit) == nk
+                }
+                .sorted { $0.capturedAt > $1.capturedAt }
+                .map(Record.single)
+        }
+    }
+
+    private var title: String {
+        switch group {
+        case .bloodPressure:
+            return String(appLoc: "血压")
+        case .series, .lab:
+            if case let .single(i)? = records.first { return i.name }
+            return String(appLoc: "指标详情")
+        }
+    }
+
+    /// 对应的趋势 bucket(需 ≥2 个可解析数值点才存在);nil 时隐藏「查看趋势图」。
+    private var bucket: SeriesBucket? {
+        let all = SeriesBucket.build(from: indicators,
+                                     profile: profiles.first,
+                                     customMetrics: customMetrics)
+        switch group {
+        case .bloodPressure:
+            return all.first { $0.id == "bp" }
+        case .series(let key):
+            return all.first { b in b.lines.contains { $0.seriesKey == key } }
+        case .lab(let nk):
+            return all.first { $0.kind == .lab && $0.id == "lab:\(nk)" }
+        }
+    }
+
+    private var currentIndex: Int {
+        records.firstIndex { $0.id == selection } ?? 0
+    }
+
+    // MARK: - Body
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 0) {
+                header
+                if records.isEmpty {
+                    Spacer()
+                    TjPlaceholder(label: String(appLoc: "记录已不存在"))
+                        .frame(width: 200, height: 120)
+                    Spacer()
+                } else {
+                    pages
+                    pager
+                    if bucket != nil { trendButton }
+                }
+            }
+            .background(Tj.Palette.sand.ignoresSafeArea())
+            .navigationDestination(isPresented: $showTrend) {
+                if let bucket { TrendDetailView(bucket: bucket) }
+            }
+        }
+        .presentationDetents([.medium, .large])
+        .presentationDragIndicator(.visible)
+        .presentationBackground(Tj.Palette.sand)
+        .presentationCornerRadius(Tj.Radius.xl)
+        .onAppear { if selection == nil { selection = records.first?.id } }
+        .alert(String(appLoc: "永久删除这条记录?"), isPresented: $showDeleteConfirm) {
+            Button(String(appLoc: "删除"), role: .destructive) { deleteCurrent() }
+            Button(String(appLoc: "取消"), role: .cancel) { }
+        } message: {
+            Text("删除后无法恢复。")
+        }
+        .sheet(item: $evidenceTarget) { indicator in
+            if let report = indicator.report {
+                EvidenceImagePreview(report: report, indicator: indicator)
+            }
+        }
+    }
+
+    // MARK: - Header
+
+    private var header: some View {
+        HStack(spacing: 12) {
+            Button { dismiss() } label: {
+                Image(systemName: "xmark")
+                    .font(.tjScaled(16, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.text)
+                    .frame(width: 32, height: 32)
+                    .background(Circle().fill(Tj.Palette.sand2))
+            }
+            Text(title)
+                .font(.tjH2())
+                .foregroundStyle(Tj.Palette.text)
+                .lineLimit(1)
+            if records.count > 1 {
+                Text("\(records.count) 条")
+                    .font(.tjScaled(12))
+                    .foregroundStyle(Tj.Palette.text3)
+            }
+            Spacer()
+            TjLockChip()
+        }
+        .padding(.horizontal, 20)
+        .padding(.vertical, 14)
+        .background(Tj.Palette.sand)
+        .overlay(alignment: .bottom) {
+            Rectangle().fill(Tj.Palette.lineSoft).frame(height: 1)
+        }
+    }
+
+    // MARK: - 翻页内容
+
+    private var pages: some View {
+        TabView(selection: $selection) {
+            ForEach(records) { rec in
+                ScrollView {
+                    VStack(alignment: .leading, spacing: 16) {
+                        recordCard(rec)
+                        deleteButton
+                    }
+                    .padding(.horizontal, 20)
+                    .padding(.vertical, 16)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                }
+                .tag(Optional(rec.id))
+            }
+        }
+        .tabViewStyle(.page(indexDisplayMode: .never))
+    }
+
+    @ViewBuilder
+    private func recordCard(_ rec: Record) -> some View {
+        switch rec {
+        case .single(let i):            singleCard(i)
+        case .bp(let sys, let dia):     bpCard(sys: sys, dia: dia)
+        }
+    }
+
+    private func singleCard(_ i: Indicator) -> some View {
+        card {
+            HStack(alignment: .firstTextBaseline) {
+                Text(i.name).font(.tjH2()).foregroundStyle(Tj.Palette.text)
+                Spacer()
+                statusChip(i.status)
+            }
+            HStack(alignment: .firstTextBaseline, spacing: 4) {
+                Text(i.value)
+                    .font(.tjScaled(30, weight: .bold, design: .rounded))
+                    .foregroundStyle(i.status == .normal ? Tj.Palette.text : Tj.Palette.brick)
+                if !i.unit.isEmpty {
+                    Text(i.unit).font(.tjScaled(14)).foregroundStyle(Tj.Palette.text3)
+                }
+            }
+            divider
+            if !i.range.isEmpty { field(String(appLoc: "参考范围"), i.range) }
+            field(String(appLoc: "记录时间"), Self.dateTimeText(i.capturedAt))
+            field(String(appLoc: "来源"), i.report?.title ?? i.source.label)
+            if i.report != nil { evidenceButton(for: i) }
+            if let note = i.note, !note.isEmpty { field(String(appLoc: "备注"), note) }
+        }
+    }
+
+    private func bpCard(sys: Indicator, dia: Indicator?) -> some View {
+        let combined: IndicatorStatus = sys.status != .normal ? sys.status : (dia?.status ?? .normal)
+        return card {
+            HStack(alignment: .firstTextBaseline) {
+                Text(String(appLoc: "血压")).font(.tjH2()).foregroundStyle(Tj.Palette.text)
+                Spacer()
+                statusChip(combined)
+            }
+            HStack(alignment: .firstTextBaseline, spacing: 4) {
+                Text("\(sys.value)/\(dia?.value ?? "—")")
+                    .font(.tjScaled(30, weight: .bold, design: .rounded))
+                    .foregroundStyle(combined == .normal ? Tj.Palette.text : Tj.Palette.brick)
+                Text("mmHg").font(.tjScaled(14)).foregroundStyle(Tj.Palette.text3)
+            }
+            divider
+            if !sys.range.isEmpty { field(String(appLoc: "参考范围"), sys.range) }
+            field(String(appLoc: "记录时间"), Self.dateTimeText(sys.capturedAt))
+        }
+    }
+
+    // MARK: - 翻页器
+
+    private var pager: some View {
+        VStack(spacing: 8) {
+            HStack(spacing: 20) {
+                pagerArrow("chevron.left", enabled: currentIndex > 0) {
+                    if currentIndex > 0 { selection = records[currentIndex - 1].id }
+                }
+                if records.count <= 7 {
+                    HStack(spacing: 6) {
+                        ForEach(Array(records.enumerated()), id: \.offset) { idx, _ in
+                            Circle()
+                                .fill(idx == currentIndex ? Tj.Palette.ink : Tj.Palette.line)
+                                .frame(width: 6, height: 6)
+                        }
+                    }
+                }
+                pagerArrow("chevron.right", enabled: currentIndex < records.count - 1) {
+                    if currentIndex < records.count - 1 { selection = records[currentIndex + 1].id }
+                }
+            }
+            Text("第 \(currentIndex + 1) / 共 \(records.count) 条")
+                .font(.tjScaled(11, design: .monospaced))
+                .foregroundStyle(Tj.Palette.text3)
+        }
+        .padding(.top, 4)
+        .padding(.bottom, 10)
+        .frame(maxWidth: .infinity)
+    }
+
+    private func pagerArrow(_ system: String, enabled: Bool, action: @escaping () -> Void) -> some View {
+        Button(action: action) {
+            Image(systemName: system)
+                .font(.tjScaled(13, weight: .semibold))
+                .foregroundStyle(enabled ? Tj.Palette.text : Tj.Palette.text3.opacity(0.4))
+                .frame(width: 30, height: 30)
+                .background(Circle().fill(Tj.Palette.sand2))
+        }
+        .buttonStyle(.plain)
+        .disabled(!enabled)
+    }
+
+    // MARK: - 趋势 / 删除
+
+    private var trendButton: some View {
+        Button { showTrend = true } label: {
+            Label(String(appLoc: "查看趋势图"), systemImage: "chart.xyaxis.line")
+                .font(.tjScaled(15, weight: .semibold))
+                .foregroundStyle(Tj.Palette.paper)
+                .frame(maxWidth: .infinity)
+                .padding(.vertical, 14)
+                .background(
+                    RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                        .fill(Tj.Palette.ink)
+                )
+        }
+        .buttonStyle(.plain)
+        .padding(.horizontal, 20)
+        .padding(.bottom, 20)
+    }
+
+    private var deleteButton: some View {
+        Button(role: .destructive) { showDeleteConfirm = true } label: {
+            Label(String(appLoc: "永久删除"), systemImage: "trash")
+                .font(.tjScaled(12, weight: .medium))
+                .foregroundStyle(Tj.Palette.brick.opacity(0.8))
+                .padding(.horizontal, 14)
+                .padding(.vertical, 8)
+                .background(
+                    RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                        .strokeBorder(Tj.Palette.brick.opacity(0.3), lineWidth: 1)
+                )
+                .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+        .padding(.top, 8)
+    }
+
+    /// 删当前页记录(永久:SwiftData 硬删 + Vault 原图 unlink,见 CLAUDE.md §6)。
+    /// 删后把 selection 落到相邻一条;删空则关闭。
+    private func deleteCurrent() {
+        guard records.indices.contains(currentIndex) else { return }
+        let removingIndex = currentIndex
+        switch records[removingIndex] {
+        case .single(let i):
+            deleteIndicator(i)
+        case .bp(let sys, let dia):
+            deleteIndicator(sys)
+            if let dia { deleteIndicator(dia) }
+        }
+        try? ctx.save()
+
+        let remaining = records
+        if remaining.isEmpty {
+            dismiss()
+        } else {
+            let next = min(removingIndex, remaining.count - 1)
+            selection = remaining[next].id
+        }
+    }
+
+    private func deleteIndicator(_ i: Indicator) {
+        if let asset = i.asset {
+            try? FileVault.shared.remove(relativePath: asset.relativePath)
+            ctx.delete(asset)
+        }
+        ctx.delete(i)
+    }
+
+    // MARK: - 复用件
+
+    @ViewBuilder
+    private func card<Content: View>(@ViewBuilder content: () -> Content) -> some View {
+        VStack(alignment: .leading, spacing: 10) { content() }
+            .padding(14)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .background(
+                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                    .fill(Tj.Palette.paper)
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                    .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+            )
+    }
+
+    private func field(_ label: String, _ value: String) -> some View {
+        HStack(alignment: .top, spacing: 12) {
+            Text(label).font(.tjScaled(13)).foregroundStyle(Tj.Palette.text3)
+            Spacer(minLength: 12)
+            Text(value)
+                .font(.tjScaled(14, weight: .medium))
+                .foregroundStyle(Tj.Palette.text)
+                .multilineTextAlignment(.trailing)
+                .fixedSize(horizontal: false, vertical: true)
+        }
+    }
+
+    @ViewBuilder
+    private func evidenceButton(for indicator: Indicator) -> some View {
+        if indicator.hasEvidenceBox,
+           let page = indicator.sourcePageIndex,
+           let assets = indicator.report?.assets,
+           assets.indices.contains(page) {
+            Button {
+                evidenceTarget = indicator
+            } label: {
+                Label(String(appLoc: "查看原图位置"), systemImage: "viewfinder")
+                    .font(.tjScaled(12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.ink)
+                    .padding(.horizontal, 10)
+                    .padding(.vertical, 6)
+                    .background(Capsule().fill(Tj.Palette.leaf.opacity(0.14)))
+                    .contentShape(Rectangle())
+            }
+            .buttonStyle(.plain)
+        }
+    }
+
+    private var divider: some View {
+        Rectangle().fill(Tj.Palette.lineSoft).frame(height: 1)
+    }
+
+    private func statusChip(_ s: IndicatorStatus) -> some View {
+        let text: String
+        let color: Color
+        let arrow: String
+        switch s {
+        case .high:   text = String(appLoc: "偏高"); color = Tj.Palette.brick; arrow = "↑"
+        case .low:    text = String(appLoc: "偏低"); color = Tj.Palette.brick; arrow = "↓"
+        case .normal: text = String(appLoc: "正常"); color = Tj.Palette.leaf;  arrow = ""
+        }
+        return HStack(spacing: 3) {
+            if !arrow.isEmpty { Text(arrow).font(.tjScaled(11, weight: .bold)) }
+            Text(text).font(.tjScaled(12, weight: .semibold))
+        }
+        .foregroundStyle(color)
+        .padding(.horizontal, 8)
+        .padding(.vertical, 4)
+        .background(Capsule().fill(color.opacity(0.14)))
+    }
+
+    private nonisolated static func dateTimeText(_ d: Date) -> String {
+        d.formatted(.dateTime.year().month().day().hour().minute())
+    }
+}
--- a/康康/Features/Timeline/TimelineEntryDetailView.swift
+++ b/康康/Features/Timeline/TimelineEntryDetailView.swift
@@ -257,14 +257,7 @@ struct TimelineEntryDetailView: View {
                }
            }

-            if let sum = r.summary, !sum.isEmpty {
-                card {
-                    Text(String(appLoc: "摘要"))
-                        .font(.tjScaled( 12, weight: .semibold)).foregroundStyle(Tj.Palette.text2)
-                    Text(sum).font(.tjScaled( 14)).foregroundStyle(Tj.Palette.text)
-                        .fixedSize(horizontal: false, vertical: true)
-                }
-            }
+            ReportSummaryCard(report: r)

            if !r.indicators.isEmpty {
                card {
@@ -420,7 +413,8 @@ struct TimelineEntryDetailView: View {
    }
 }

-private struct EvidenceImagePreview: View {
+/// 原图证据预览(翻页 + 高亮框)。指标详情与同类聚合详情共用,故为模块内可见。
+struct EvidenceImagePreview: View {
    @Environment(\.dismiss) private var dismiss
    let report: Report
    let indicator: Indicator
@@ -558,3 +552,52 @@ private struct EvidenceHighlightOverlay: View {
        )
    }
 }
+
+// MARK: - 报告摘要卡(无摘要时后台预生成兜底)
+
+/// 有摘要直接显示;无摘要且有指标时触发后台预生成(归档时若被抢占,这里兜底),
+/// 生成期间显示流光线,完成后 SwiftData 观察自动刷新出文本。
+private struct ReportSummaryCard: View {
+    @Environment(\.modelContext) private var ctx
+    let report: Report
+    @State private var generating = false
+
+    var body: some View {
+        Group {
+            if let sum = report.summary, !sum.isEmpty {
+                container {
+                    Text(String(appLoc: "摘要"))
+                        .font(.tjScaled( 12, weight: .semibold)).foregroundStyle(Tj.Palette.text2)
+                    Text(sum).font(.tjScaled( 14)).foregroundStyle(Tj.Palette.text)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+            } else if generating {
+                container {
+                    Text("本地 AI 正在解读这份报告…")
+                        .font(.tjScaled( 12)).foregroundStyle(Tj.Palette.text3)
+                    AIFlowBar()
+                }
+            }
+        }
+        .task {
+            guard (report.summary ?? "").isEmpty, !report.indicators.isEmpty else { return }
+            generating = true
+            await ReportInsightService.shared.pregenerateIfNeeded(report: report, in: ctx)
+            generating = false
+        }
+    }
+
+    private func container<C: View>(@ViewBuilder _ body: () -> C) -> some View {
+        VStack(alignment: .leading, spacing: 10) { body() }
+            .padding(14)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .background(
+                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                    .fill(Tj.Palette.paper)
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                    .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+            )
+    }
+}
--- a/康康/Features/Trends/TrendDetailView.swift
+++ b/康康/Features/Trends/TrendDetailView.swift
@@ -69,7 +69,7 @@ struct TrendDetailView: View {
                }
                chartCard
                statsCard
-                aiPlaceholder
+                TrendInsightCard(bucket: bucket)
                pointsList
            }
            .padding(.horizontal, 20)
@@ -318,27 +318,6 @@ struct TrendDetailView: View {
        return ("\(arrow) \(fmt(abs(d)))\(pctStr)", color)
    }

-    // MARK: AI 解读占位
-
-    private var aiPlaceholder: some View {
-        HStack(spacing: 8) {
-            Image(systemName: "sparkles")
-                .font(.tjScaled( 12))
-                .foregroundStyle(Tj.Palette.text3)
-            Text("AI 趋势解读即将上线")
-                .font(.tjScaled( 12))
-                .foregroundStyle(Tj.Palette.text3)
-            Spacer()
-        }
-        .padding(.horizontal, 14)
-        .padding(.vertical, 12)
-        .frame(maxWidth: .infinity, alignment: .leading)
-        .background(
-            RoundedRectangle(cornerRadius: Tj.Radius.sm, style: .continuous)
-                .fill(Tj.Palette.sand2.opacity(0.6))
-        )
-    }
-
    // MARK: 数据点列表

    /// 跨线按天合并:每天一行,展示该天各线的值。倒序。
@@ -423,6 +402,80 @@ struct TrendDetailView: View {
    }
 }

+// MARK: - AI 趋势解读卡
+
+/// 进入页面先查指纹缓存:命中秒显;未命中本地现算(经 TrendInsightService,§3.1)。
+private struct TrendInsightCard: View {
+    let bucket: SeriesBucket
+    @State private var text: String?
+    @State private var running = false
+    @State private var failedMessage: String?
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack(spacing: 6) {
+                Image(systemName: "sparkles")
+                    .font(.tjScaled( 12))
+                    .foregroundStyle(Tj.Palette.ink)
+                Text("AI 解读")
+                    .font(.tjScaled( 12, weight: .semibold))
+                    .foregroundStyle(Tj.Palette.text2)
+                Spacer()
+            }
+            if let text {
+                Text(text)
+                    .font(.tjScaled( 13))
+                    .lineSpacing(3)
+                    .foregroundStyle(Tj.Palette.text)
+                    .fixedSize(horizontal: false, vertical: true)
+                AIDisclaimerFooter()
+            } else if running {
+                Text("本地 AI 解读中…")
+                    .font(.tjScaled( 12))
+                    .foregroundStyle(Tj.Palette.text3)
+                AIFlowBar()
+            } else if let failedMessage {
+                HStack {
+                    Text(failedMessage)
+                        .font(.tjScaled( 12))
+                        .foregroundStyle(Tj.Palette.text3)
+                    Spacer()
+                    Button("重试") { Task { await load(force: true) } }
+                        .font(.tjScaled( 12, weight: .medium))
+                        .foregroundStyle(Tj.Palette.ink)
+                }
+            }
+        }
+        .padding(14)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                .fill(Tj.Palette.paper)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
+                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
+        )
+        .task(id: bucket.id) { await load(force: false) }
+    }
+
+    @MainActor
+    private func load(force: Bool) async {
+        if !force, let cached = TrendInsightService.shared.cachedText(for: bucket) {
+            text = cached
+            return
+        }
+        running = true
+        failedMessage = nil
+        do {
+            text = try await TrendInsightService.shared.generate(for: bucket)
+        } catch {
+            failedMessage = String(appLoc: "AI 解读暂不可用(模型未就绪或繁忙)")
+        }
+        running = false
+    }
+}
+
 enum TrendRange: String, CaseIterable, Identifiable {
    case all, year, sixMonths, threeMonths
    var id: String { rawValue }
--- a/康康/Localizable.xcstrings
+++ b/康康/Localizable.xcstrings
@@ -1112,6 +1112,7 @@
      }
    },
    "AI 思考中…  本地推理,通常 5-10 秒" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -1154,6 +1155,12 @@
          }
        }
      }
+    },
+    "AI 整理中 · 本地推理" : {
+
+    },
+    "AI 整理失败,已填入原话" : {
+
    },
    "AI 模型尚未准备好" : {
      "localizations" : {
@@ -1223,6 +1230,15 @@
          }
        }
      }
+    },
+    "AI 生成中 · %.1f tok/s" : {
+
+    },
+    "AI 生成中 · 本地推理" : {
+
+    },
+    "AI 解读" : {
+
    },
    "AI 解读基于通用健康知识生成,并不掌握你完整的病史与个体情况,仅供日常记录参考。" : {
      "localizations" : {
@@ -1245,6 +1261,9 @@
          }
        }
      }
+    },
+    "AI 解读暂不可用(模型未就绪或繁忙)" : {
+
    },
    "AI 识别与解读可能出现错误或遗漏:拍照得到的数值、单位、参考范围请务必与原始报告核对," : {
      "localizations" : {
@@ -1267,9 +1286,6 @@
          }
        }
      }
-    },
-    "AI 趋势解读即将上线" : {
-
    },
    "AI 辅助 · 医生角度查漏补缺" : {
      "localizations" : {
@@ -1317,6 +1333,9 @@
    },
    "Apple 健康里没有可导入的生日、性别、身高或血型。" : {

+    },
+    "Arm SME2" : {
+
    },
    "B 型" : {
      "localizations" : {
@@ -1386,12 +1405,18 @@
    },
    "lo" : {

+    },
+    "Metal GPU · 兜底 / 对照" : {
+
    },
    "mmHg" : {

    },
    "mmol/L" : {

+    },
+    "MNN 在端侧 CPU 上以 Arm SME2 指令集加速 Qwen 推理(本地、不上云)。切换后下一次 AI 调用生效。" : {
+
    },
    "O 型" : {
      "localizations" : {
@@ -1414,6 +1439,19 @@
          }
        }
      }
+    },
+    "prompt %lld tok · 生成 %lld tok · 100%% 本地" : {
+      "localizations" : {
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "new",
+            "value" : "prompt %1$lld tok · 生成 %2$lld tok · 100%% 本地"
+          }
+        }
+      }
+    },
+    "Qwen3.5-2B 已就绪" : {
+
    },
    "s" : {

@@ -1853,6 +1891,7 @@
      }
    },
    "两个模型都已就绪" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -2523,9 +2562,6 @@
          }
        }
      }
-    },
-    "例:最近血压波动大吗？" : {
-
    },
    "例:最近血糖好像不稳,把过去三个月的化验单整理一下" : {
      "extractionState" : "stale",
@@ -2572,9 +2608,6 @@
          }
        }
      }
-    },
-    "例:把我最近头晕、睡眠和指标变化整理给医生" : {
-
    },
    "例如:< 3.40 或 3.9 - 6.1" : {
      "localizations" : {
@@ -2773,6 +2806,9 @@
          }
        }
      }
+    },
+    "保存后点一下,就能把这句话填进输入框" : {
+
    },
    "保存归档" : {
      "extractionState" : "stale",
@@ -2906,6 +2942,9 @@
          }
        }
      }
+    },
+    "停止生成" : {
+
    },
    "健康日历" : {

@@ -3369,6 +3408,9 @@
    },
    "最高" : {

+    },
+    "写下要整理什么,或先提问补充情况…" : {
+
    },
    "冠心病" : {
      "localizations" : {
@@ -3611,6 +3653,9 @@
          }
        }
      }
+    },
+    "前往设置" : {
+
    },
    "剧烈" : {
      "localizations" : {
@@ -3635,6 +3680,7 @@
      }
    },
    "加" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -4096,6 +4142,9 @@
          }
        }
      }
+    },
+    "各引擎实测对比" : {
+
    },
    "同一指标记录满 2 次后,会在这里出现时间序列" : {

@@ -4344,6 +4393,9 @@
          }
        }
      }
+    },
+    "在「我的 · 推理引擎」切换引擎后再跑一次,即可对比 SME2 与 GPU。" : {
+
    },
    "在内存较小的旧机型上,App 仍可用于手动记录、归档与查看," : {
      "localizations" : {
@@ -5241,6 +5293,12 @@
          }
        }
      }
+    },
+    "已取消整理,填入原话" : {
+
+    },
+    "已在本地档案中找到 %lld 条相关记录" : {
+
    },
    "已处理 %.1fs · 比云端快 4.2×" : {
      "extractionState" : "stale",
@@ -5891,6 +5949,9 @@
          }
        }
      }
+    },
+    "开始说话…" : {
+
    },
    "异常项" : {
      "extractionState" : "stale",
@@ -5914,31 +5975,6 @@
          }
        }
      }
-    },
-    "异常项快拍" : {
-      "localizations" : {
-        "en" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "Abnormal item quick capture"
-          }
-        },
-        "ja" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "異常項目クイック撮影"
-          }
-        },
-        "ko" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "이상 항목 빠른 촬영"
-          }
-        }
-      }
-    },
-    "异常项快拍需要相机。去「设置 → 康康 → 相机」打开后再回来。" : {
-
    },
    "强度" : {
      "localizations" : {
@@ -6032,6 +6068,9 @@
          }
        }
      }
+    },
+    "录音启动失败:%@" : {
+
    },
    "影像报告" : {
      "localizations" : {
@@ -6186,6 +6225,12 @@
          }
        }
      }
+    },
+    "性能自检" : {
+
+    },
+    "总耗时" : {
+
    },
    "总胆固醇" : {
      "extractionState" : "stale",
@@ -6277,9 +6322,6 @@
          }
        }
      }
-    },
-    "患者" : {
-
    },
    "慢性肾病" : {
      "localizations" : {
@@ -6324,6 +6366,9 @@
          }
        }
      }
+    },
+    "我" : {
+
    },
    "我的" : {
      "localizations" : {
@@ -6671,7 +6716,7 @@
        }
      }
    },
-    "拍一张含异常指标的照片 · 拍完再框选" : {
+    "拍一张含目标指标的照片 · 拍完再框选" : {

    },
    "拍到的局部" : {
@@ -7045,6 +7090,31 @@
    },
    "指标详情" : {

+    },
+    "指标速记" : {
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Quick metric log"
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "指標クイック記録"
+          }
+        },
+        "ko" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "지표 빠른 기록"
+          }
+        }
+      }
+    },
+    "指标速记需要相机。去「设置 → 康康 → 相机」打开后再回来。" : {
+
    },
    "按%lld岁调整" : {
      "localizations" : {
@@ -7067,6 +7137,15 @@
          }
        }
      }
+    },
+    "按本机配置选择 · 当前 MLX(MNN 不可用)" : {
+
+    },
+    "按本机配置选择 · 当前 MNN + SME2" : {
+
+    },
+    "按本机配置选择 · 当前 MNN(NEON)" : {
+
    },
    "推理中…" : {
      "localizations" : {
@@ -7111,8 +7190,12 @@
          }
        }
      }
+    },
+    "推理引擎" : {
+
    },
    "推理自检" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -7448,6 +7531,9 @@
          }
        }
      }
+    },
+    "改用原话" : {
+
    },
    "放大后整个 App 的文字立即变大,无需重启。设置会被记住。" : {

@@ -7618,6 +7704,7 @@
      }
    },
    "文本解读 · 趋势 / 问答" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -7638,6 +7725,12 @@
          }
        }
      }
+    },
+    "文本解读 · 趋势 / 问答(MLX 兜底)" : {
+
+    },
+    "文本解读 + 拍照识别 · MNN + SME2 端侧加速" : {
+
    },
    "新建" : {
      "localizations" : {
@@ -7798,6 +7891,9 @@
          }
        }
      }
+    },
+    "日记 ×%lld" : {
+
    },
    "日记详情" : {

@@ -8248,6 +8344,12 @@
          }
        }
      }
+    },
+    "本地 AI 正在解读这份报告…" : {
+
+    },
+    "本地 AI 解读中…" : {
+
    },
    "本地 RAG · Qwen3 1.7B · 不上传任何数据" : {
      "extractionState" : "stale",
@@ -8382,6 +8484,9 @@
          }
        }
      }
+    },
+    "本地档案中暂无相关记录,将仅按你的描述整理" : {
+
    },
    "本地识别中" : {
      "localizations" : {
@@ -8476,6 +8581,9 @@
    },
    "本月暂无记录" : {

+    },
+    "本机不支持端侧语音识别" : {
+
    },
    "本机保存" : {
      "localizations" : {
@@ -8617,6 +8725,18 @@
          }
        }
      }
+    },
+    "本次结果" : {
+
+    },
+    "本设备/模拟器不可用,自动回退 MLX" : {
+
+    },
+    "本设备不支持(需 A19/iPhone 17+)" : {
+
+    },
+    "本设备支持,MNN 已启用 SME2 加速" : {
+
    },
    "本设备未设置 Face ID 或密码" : {
      "localizations" : {
@@ -8693,6 +8813,9 @@
    },
    "查看原图位置" : {

+    },
+    "查看趋势图" : {
+
    },
    "标准" : {

@@ -8767,7 +8890,7 @@
        }
      }
    },
-    "核对异常项" : {
+    "核对指标" : {

    },
    "核对识别结果" : {
@@ -8948,6 +9071,9 @@
          }
        }
      }
+    },
+    "正在听 · 识别在本机完成" : {
+
    },
    "正在本地识别第 1 / 3 页…" : {
      "extractionState" : "stale",
@@ -9020,6 +9146,9 @@
    },
    "正在查看本地记录…" : {

+    },
+    "正在根据这些记录回答…" : {
+
    },
    "正常" : {
      "localizations" : {
@@ -9200,6 +9329,9 @@
          }
        }
      }
+    },
+    "没听清,再试一次" : {
+
    },
    "没有指标 — 点上方「加一项」补一行,或直接保存只存图片" : {
      "localizations" : {
@@ -9275,6 +9407,9 @@
          }
        }
      }
+    },
+    "添加" : {
+
    },
    "添加你自己的长期监测项" : {
      "localizations" : {
@@ -9297,6 +9432,9 @@
          }
        }
      }
+    },
+    "添加快捷问答" : {
+
    },
    "点底部 + 号可以补一条" : {
      "localizations" : {
@@ -9501,6 +9639,12 @@
          }
        }
      }
+    },
+    "生成" : {
+
+    },
+    "生成 %.1f tok/s" : {
+
    },
    "生成失败:%@" : {
      "localizations" : {
@@ -9873,6 +10017,22 @@
        }
      }
    },
+    "端侧 CPU + SME2 加速 · 挑战赛考核路径" : {
+
+    },
+    "端侧 CPU(本机无 SME2,NEON 回退)" : {
+
+    },
+    "第 %lld / 共 %lld 条" : {
+      "localizations" : {
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "new",
+            "value" : "第 %1$lld / 共 %2$lld 条"
+          }
+        }
+      }
+    },
    "第 %lld 轮 · 基于你刚才更新的文本 · %lld 条" : {
      "localizations" : {
        "en" : {
@@ -10280,9 +10440,6 @@
          }
        }
      }
-    },
-    "继续提问或补充情况…" : {
-
    },
    "维生素 D" : {
      "extractionState" : "stale",
@@ -10789,6 +10946,9 @@
          }
        }
      }
+    },
+    "记录已不存在" : {
+
    },
    "记录指标" : {
      "localizations" : {
@@ -11158,6 +11318,15 @@
          }
        }
      }
+    },
+    "语音记录全程在本机完成,声音和文字都不会上传。请在设置中允许麦克风和语音识别。" : {
+
+    },
+    "说一段" : {
+
+    },
+    "说完了,整理成日记" : {
+
    },
    "说说你想给医生看什么" : {
      "extractionState" : "stale",
@@ -11203,6 +11372,9 @@
          }
        }
      }
+    },
+    "读入" : {
+
    },
    "读取生日、性别、身高和血型,确认后填入个人资料" : {

@@ -11597,6 +11769,9 @@
          }
        }
      }
+    },
+    "输入一句常用问题…" : {
+
    },
    "输入密码" : {
      "localizations" : {
@@ -11663,8 +11838,12 @@
          }
        }
      }
+    },
+    "运行性能自检" : {
+
    },
    "运行推理自检" : {
+      "extractionState" : "stale",
      "localizations" : {
        "en" : {
          "stringUnit" : {
@@ -12264,6 +12443,9 @@
          }
        }
      }
+    },
+    "需要麦克风与语音识别权限" : {
+
    },
    "预计耗时 5–8 秒 · 端侧 SME2 加速" : {
      "extractionState" : "stale",
--- a/康康/Models/HealthExport.swift
+++ b/康康/Models/HealthExport.swift
@@ -28,7 +28,7 @@ final class HealthExport {
    var inferredLabelCN: String?

    // demo 卖点凭证
-    /// 模型 tag,如 "Qwen3-1.7B-4bit"。截图能证明本地推理。
+    /// 模型 tag,如 "Qwen3.5-2B-MNN"(iPhone17+ 主路径)或 "Qwen3.5-2B-4bit"(MLX 兜底)。截图能证明本地推理。
    var modelTag: String
    /// 末次 tok/s,对应 demo 卖点 #6 Live Activity 数据。
    var decodeRate: Double
@@ -44,7 +44,7 @@ final class HealthExport {
         inferredTimeToDate: Date? = nil,
         inferredIntent: String? = nil,
         inferredLabelCN: String? = nil,
-         modelTag: String = "Qwen3-1.7B-4bit",
+         modelTag: String = "Qwen3.5-2B-MNN",
         decodeRate: Double = 0) {
        self.prompt = prompt
        self.content = content
--- a/康康/Models/Models.swift
+++ b/康康/Models/Models.swift
@@ -6,7 +6,7 @@ enum IndicatorStatus: String, Codable, CaseIterable {
    case high, low, normal
 }

-/// 指标录入来源。manual = 「记录指标」手动录入;quickCapture = 异常项快拍(VL);report = 报告归档携带。
+/// 指标录入来源。manual = 「记录指标」手动录入;quickCapture = 指标速记(VL);report = 报告归档携带。
 /// 旧数据无此字段 → 默认 manual(轻量迁移)。
 enum IndicatorSource: String, Codable, CaseIterable {
    case manual, quickCapture, report
@@ -14,7 +14,7 @@ enum IndicatorSource: String, Codable, CaseIterable {
    var label: String {
        switch self {
        case .manual:       return String(appLoc: "手动记录")
-        case .quickCapture: return String(appLoc: "异常项快拍")
+        case .quickCapture: return String(appLoc: "指标速记")
        case .report:       return String(appLoc: "报告归档")
        }
    }
--- a/康康/RootView.swift
+++ b/康康/RootView.swift
@@ -96,7 +96,7 @@ struct RootView: View {
            DiaryQuickSheet()
        }
        .sheet(isPresented: $showIndicator) {
-            // 「拍照识别」入口:关闭手输表单 → 打开异常项快拍 VL 流程(并入「记录指标」)。
+            // 「拍照识别」入口:关闭手输表单 → 打开指标速记 VL 流程(并入「记录指标」)。
            IndicatorQuickSheet(onRequestCamera: {
                showIndicator = false
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
--- a/康康/Services/BenchmarkService.swift
+++ b/康康/Services/BenchmarkService.swift
@@ -0,0 +1,67 @@
+import Foundation
+
+/// 单次性能自检结果。按后端标签归档,供「MNN·SME2 vs MLX·GPU」对比展示(§12 卖点 2/6)。
+struct BenchmarkResult: Codable, Equatable {
+    var backendLabel: String
+    var promptTokens: Int
+    var genTokens: Int
+    var prefillTokensPerSecond: Double
+    var decodeTokensPerSecond: Double
+    var totalSeconds: Double
+    var date: Date
+}
+
+/// 性能自检服务:跑固定 prompt,取 AIRuntime 的归一统计,按后端标签存 UserDefaults。
+/// UI(ModelSelfTestView)只经本服务调 AIRuntime(§3.1)。
+@MainActor
+struct BenchmarkService {
+    static let shared = BenchmarkService()
+    private init() {}
+
+    nonisolated static let storeKey = "kk.benchmark.results"
+
+    /// 固定测试 prompt:跨设备/引擎可比的前提。
+    static let fixedPrompt = "用中文一句话介绍肝功能里 ALT 这个指标。"
+
+    /// 跑一次自检。onToken 把流式输出交给 UI 展示。
+    func run(onToken: @escaping @MainActor (String, Double) -> Void) async throws -> BenchmarkResult {
+        try await AIRuntime.shared.prepare()
+        let start = Date()
+        let stream = await AIRuntime.shared.generate(prompt: Self.fixedPrompt, maxTokens: 128)
+        for try await chunk in stream {
+            onToken(chunk.text, chunk.decodeRate)
+        }
+        let total = Date().timeIntervalSince(start)
+        let label = await AIRuntime.shared.activeBackendLabel
+        let stats = await AIRuntime.shared.lastGenerateStats
+        let result = BenchmarkResult(
+            backendLabel: label,
+            promptTokens: stats?.promptTokens ?? 0,
+            genTokens: stats?.genTokens ?? 0,
+            prefillTokensPerSecond: stats?.prefillTokensPerSecond ?? 0,
+            decodeTokensPerSecond: stats?.decodeTokensPerSecond ?? 0,
+            totalSeconds: total,
+            date: .now
+        )
+        Self.save(result)
+        return result
+    }
+
+    // MARK: - 存档(静态纯函数,单测覆盖;nonisolated:纯 UserDefaults 操作,无需主线程)
+
+    nonisolated static func save(_ result: BenchmarkResult, defaults: UserDefaults = .standard) {
+        var all = load(defaults: defaults)
+        all[result.backendLabel] = result
+        if let data = try? JSONEncoder().encode(all) {
+            defaults.set(data, forKey: storeKey)
+        }
+    }
+
+    nonisolated static func load(defaults: UserDefaults = .standard) -> [String: BenchmarkResult] {
+        guard let data = defaults.data(forKey: storeKey),
+              let all = try? JSONDecoder().decode([String: BenchmarkResult].self, from: data) else {
+            return [:]
+        }
+        return all
+    }
+}
--- a/康康/Services/CaptureService.swift
+++ b/康康/Services/CaptureService.swift
@@ -1,5 +1,6 @@
 import Foundation
 import UIKit
+import ImageIO
 import SwiftData

 /// VL 解析结果(已结构化,可直接喂 SwiftData 模型构造)。
@@ -77,53 +78,6 @@ actor CaptureService {
        try await runVL(on: assets)
    }

-    /// 异常项快拍:对一张**局部照片**(JPEG data)跑 VL,只抽 indicators,不建 Report、不留图。
-    /// - 临时文件落 `NSTemporaryDirectory`(`.completeFileProtectionUnlessOpen`),推理后 `defer` 删除 ——
-    ///   符合「最后只存参数和异常值」(§ 需求)与隐私基线(§6),全程不写 Vault、不建 Asset。
-    /// - 失败抛 `CaptureError`,UI 回退手动录入(§3.2 失败回退红线)。
-    /// 调用方(MainActor)负责把识别结果落成独立 Indicator。
-    func recognizeRegion(imageData: Data) async throws -> [ParsedReport.ParsedIndicator] {
-        do {
-            try await AIRuntime.shared.prepareVL()
-        } catch {
-            throw CaptureError.modelNotReady
-        }
-
-        let tmpURL = URL(fileURLWithPath: NSTemporaryDirectory())
-            .appendingPathComponent("region-\(UUID().uuidString).jpg")
-        do {
-            // 用 .completeFileProtectionUnlessOpen 而非 .complete:VL 推理可能持续数秒,
-            // 期间设备若锁屏,.complete 会让读/写抛 EPERM 使快拍在锁屏下必失败;
-            // unlessOpen 允许已打开句柄继续访问,与 Vault(completeUnlessOpen)一致。
-            try imageData.write(to: tmpURL, options: [.completeFileProtectionUnlessOpen, .atomic])
-        } catch {
-            throw CaptureError.inferenceFailed("临时图片写入失败:\(error.localizedDescription)")
-        }
-        defer { try? FileManager.default.removeItem(at: tmpURL) }
-
-        let raw: String
-        do {
-            raw = try await AIRuntime.shared.analyzeReport(
-                imageURLs: [tmpURL],
-                prompt: VLPrompts.regionExtraction(),
-                // 整张化验单可能含十余项,512 token 会截断 → 解析失败。给足额度。
-                maxTokens: 2048
-            )
-        } catch {
-            throw CaptureError.inferenceFailed("\(error)")
-        }
-        #if DEBUG
-        print("🔎 [recognizeRegion] image bytes=\(imageData.count), VL raw output:\n\(raw)\n--- end VL raw ---")
-        #endif
-        do {
-            return try CaptureService.parseIndicatorsJSON(raw)
-        } catch let CaptureError.parseFailed(msg) {
-            throw CaptureError.parseFailed(msg)
-        } catch {
-            throw CaptureError.parseFailed("\(error)")
-        }
-    }
-
    /// 「拍照识别」OCR 链路:把 Vision OCR 出的纯文本交给 LLM(Qwen3-1.7B)结构化抽指标。
    /// 不建 Report、不留图;失败抛 `CaptureError`,UI 回退手动录入(§3.2)。
    /// 调用方(MainActor)先做 OCR,再把文本传进来——OCR 不需进 actor,也避免 UIImage 跨 actor。
@@ -149,12 +103,19 @@ actor CaptureService {
        // Qwen3 可能吐 <think>…</think>,先剥掉再抠 JSON。
        let cleaned = CaptureService.stripThink(collected)
        #if DEBUG
-        print("🧠 [recognizeIndicators] LLM cleaned output:\n\(cleaned)\n--- end LLM ---")
+        // 取证:原始输出(含可能未闭合的 <think>)+ strip 后,定位「空/非法 JSON」根因。
+        // 用 NSLog(走统一日志)而非 print(stdout 被 Xcode lldb 接管,idevicesyslog 抓不到)。
+        NSLog("KKDBG-VL RAW LLM output (%d chars):\n%@\n--- end RAW ---", collected.count, collected)
+        NSLog("KKDBG-VL cleaned (%d chars):\n%@\n--- end cleaned ---", cleaned.count, cleaned)
        #endif
        do {
            return try CaptureService.parseIndicatorsJSON(cleaned)
        } catch let CaptureError.parseFailed(msg) {
-            throw CaptureError.parseFailed(msg)
+            // 把模型实际输出的特征带到屏幕上,便于现场定位(原始长度 / strip 后长度 / 前缀)。
+            let rawLen = collected.count
+            let cleanLen = cleaned.count
+            let preview = cleaned.isEmpty ? "(strip 后为空)" : String(cleaned.prefix(60))
+            throw CaptureError.parseFailed("\(msg)〔raw \(rawLen)字/clean \(cleanLen)字·前缀:\(preview)〕")
        } catch {
            throw CaptureError.parseFailed("\(error)")
        }
@@ -182,11 +143,14 @@ actor CaptureService {
            throw CaptureError.modelNotReady
        }
        let urls = assets.map { FileVault.shared.rootURL.appendingPathComponent($0.relativePath) }
+        // OCR 参考(Vision 本地,<1s/页):给 2B 多模态当数字「抄写员」,降低小字误读。
+        // 任何失败都静默回退为空串,绝不阻断识别主流程(§3.2)。
+        let ocr = await Self.ocrReference(for: urls)
        let raw: String
        do {
            raw = try await AIRuntime.shared.analyzeReport(
                imageURLs: urls,
-                prompt: VLPrompts.reportExtraction()
+                prompt: VLPrompts.reportExtraction(ocrText: ocr)
            )
        } catch {
            throw CaptureError.inferenceFailed("\(error)")
@@ -200,6 +164,20 @@ actor CaptureService {
        }
    }

+    /// 对 Vault 报告图逐页 OCR 拼参考文本。最多 4 页;失败/空文本返回 ""。
+    /// 用 ImageIO 直取 CGImage(不经 UIImage,避免跨 actor 传非 Sendable 引用)。
+    private static func ocrReference(for urls: [URL]) async -> String {
+        var pages: [String] = []
+        for (idx, url) in urls.prefix(4).enumerated() {
+            guard let src = CGImageSourceCreateWithURL(url as CFURL, nil),
+                  let cg = CGImageSourceCreateImageAtIndex(src, 0, nil) else { continue }
+            guard let text = try? await OCRService.recognizeText(in: cg),
+                  !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { continue }
+            pages.append(urls.count > 1 ? "【第 \(idx + 1) 页】\n\(text)" : text)
+        }
+        return pages.joined(separator: "\n")
+    }
+
    // MARK: - JSON parse(static + 纯函数 → 方便单测)

    /// 从 VL 输出里抠出第一段合法 JSON 对象并解析。
@@ -213,7 +191,7 @@ actor CaptureService {
        // 用 extractBalancedJSON(而非只认 {} 的 extractJSONObject):VL 多项时偶尔直接吐
        // 裸数组 [{...},{...}],只认对象会从第一个 { 配对,只截出第一个 indicator、静默丢掉
        // 其余 —— 这是影像档案核心卖点上的数据丢失。顶层是数组时整体视作 indicators。
-        let jsonString = extractBalancedJSON(from: raw)
+        let jsonString = repairJSON(extractBalancedJSON(from: raw))
        guard let data = jsonString.data(using: .utf8) else {
            throw CaptureError.parseFailed("非 UTF-8 输出")
        }
@@ -259,7 +237,7 @@ actor CaptureService {
    /// 复用 `extractJSONObject` + `parseIndicator`。解析不到任何 indicator 返回空数组(不抛),
    /// UI 据此走「没读出指标,手动补充」分支。JSON 本身不合法才抛 `parseFailed`。
    static func parseIndicatorsJSON(_ raw: String) throws -> [ParsedReport.ParsedIndicator] {
-        let jsonString = extractBalancedJSON(from: raw)
+        let jsonString = repairJSON(extractBalancedJSON(from: raw))
        guard let data = jsonString.data(using: .utf8) else {
            throw CaptureError.parseFailed("非 UTF-8 输出")
        }
@@ -324,6 +302,21 @@ actor CaptureService {
        return String(s[start...])
    }

+    /// 弱模型(2B)常见 JSON 畸形的安全修复,仅在 JSONSerialization 前兜底:
+    /// - 中文弯引号 “ ” → 直引号 "(模型偶尔给 key/value 套全角引号)
+    /// - 去对象/数组尾逗号(`,}` / `,]` → `}` / `]`)
+    /// 修不好仍按原逻辑报错;只做结构性修正,不改字符串语义。
+    static func repairJSON(_ s: String) -> String {
+        var t = s
+        t = t.replacingOccurrences(of: "\u{201C}", with: "\"")  // “
+        t = t.replacingOccurrences(of: "\u{201D}", with: "\"")  // ”
+        if let re = try? NSRegularExpression(pattern: ",\\s*([}\\]])") {
+            t = re.stringByReplacingMatches(
+                in: t, range: NSRange(t.startIndex..., in: t), withTemplate: "$1")
+        }
+        return t
+    }
+
    /// 抠出第一段平衡的 JSON 值,`{...}` 或 `[...]` 以先出现者为准。
    /// 用于局部识别(模型可能输出 `{"indicators":[...]}` 或裸 `[...]`)。
    /// 失败返回去围栏后的原串(后续 JSONSerialization 报错)。
--- a/康康/Services/DiaryAssistService.swift
+++ b/康康/Services/DiaryAssistService.swift
@@ -74,8 +74,8 @@ struct DiaryAssistService {

        // 1. 去 <think>...</think>(复用 HealthExportService 的兜底)
        let stripped = HealthExportService.stripThinkBlocks(collected)
-        // 2. 抠出第一段平衡 JSON(复用 CaptureService.extractJSONObject)
-        let jsonStr = CaptureService.extractJSONObject(from: stripped)
+        // 2. 抠出第一段平衡 JSON(复用 CaptureService.extractJSONObject)+ 弱模型畸形修复
+        let jsonStr = CaptureService.repairJSON(CaptureService.extractJSONObject(from: stripped))
        guard let data = jsonStr.data(using: .utf8),
              let obj = try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed]),
              let dict = obj as? [String: Any] else {
@@ -98,4 +98,29 @@ struct DiaryAssistService {
        guard !questions.isEmpty else { throw AssistError.empty }
        return (Array(questions.prefix(4)), lastRate)
    }
+
+    /// 把语音转写稿整理成健康日记草稿(spec 2026-06-10-voice-diary)。
+    /// 失败(模型未就绪 / 输出为空)抛错,调用方回退为直接使用原话,不卡死。
+    /// 与 suggest 同样走 AIRuntime actor 队列,自然与追问/拍照串行。
+    func organize(transcript: String) async throws -> (text: String, decodeRate: Double) {
+        do {
+            try await AIRuntime.shared.prepare()
+        } catch {
+            throw AssistError.modelNotReady
+        }
+
+        let prompt = DiaryAssistPrompts.organize(transcript: transcript)
+        var collected = ""
+        var lastRate: Double = 0
+        let stream = await AIRuntime.shared.generate(prompt: prompt, maxTokens: 400)
+        for try await chunk in stream {
+            collected += chunk.text
+            if chunk.decodeRate > 0 { lastRate = chunk.decodeRate }
+        }
+
+        let text = HealthExportService.stripThinkBlocks(collected)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty else { throw AssistError.empty }
+        return (text, lastRate)
+    }
 }
--- a/康康/Services/HealthExportDialogue.swift
+++ b/康康/Services/HealthExportDialogue.swift
@@ -7,7 +7,7 @@ struct HealthExportDialogueTurn: Identifiable, Hashable, Sendable {

        var transcriptLabel: String {
            switch self {
-            case .user: return String(appLoc: "患者")
+            case .user: return String(appLoc: "我")
            case .assistant: return String(appLoc: "康康")
            }
        }
--- a/康康/Services/HealthExportService.swift
+++ b/康康/Services/HealthExportService.swift
@@ -35,8 +35,56 @@ struct HealthExportService {
        }
    }

+    /// 检索结果摘要 —— 把「本地 RAG 找到了什么」拿给 UI 演出来(§12 卖点 3)。
+    struct RetrievalSummary: Sendable, Equatable {
+        var chips: [String]
+        var indicatorCount: Int
+        var reportCount: Int
+        var symptomCount: Int
+        var diaryCount: Int
+
+        var totalCount: Int { indicatorCount + reportCount + symptomCount + diaryCount }
+
+        /// 同名指标合并计数(保持检索的新→旧顺序),超出 cap 折叠成 "+N"。纯函数,单测覆盖。
+        static func groupedChips(_ names: [String], cap: Int = 8) -> [String] {
+            var order: [String] = []
+            var counts: [String: Int] = [:]
+            for n in names {
+                if counts[n] == nil { order.append(n) }
+                counts[n, default: 0] += 1
+            }
+            var chips = order.map { name -> String in
+                let c = counts[name] ?? 1
+                return c > 1 ? "\(name) ×\(c)" : name
+            }
+            if chips.count > cap {
+                let overflow = chips.count - cap
+                chips = Array(chips.prefix(cap)) + ["+\(overflow)"]
+            }
+            return chips
+        }
+
+        @MainActor
+        static func from(snapshot: Snapshot) -> RetrievalSummary {
+            var chips = groupedChips(snapshot.indicators.map(\.name), cap: 8)
+            chips += snapshot.reports.prefix(3).map(\.title)
+            chips += snapshot.symptoms.prefix(3).map(\.name)
+            if !snapshot.diaries.isEmpty {
+                chips.append(String(appLoc: "日记 ×\(snapshot.diaries.count)"))
+            }
+            return RetrievalSummary(
+                chips: chips,
+                indicatorCount: snapshot.indicators.count,
+                reportCount: snapshot.reports.count,
+                symptomCount: snapshot.symptoms.count,
+                diaryCount: snapshot.diaries.count
+            )
+        }
+    }
+
    enum Event {
        case phaseChanged(Phase)
+        case retrieved(RetrievalSummary)
        case token(TokenChunk)
        case completed(persistentID: PersistentIdentifier)
        // .failed 走 stream throw,不在 Event 里
@@ -80,6 +128,7 @@ struct HealthExportService {
                    // —— Phase 2: 检索 ——
                    continuation.yield(.phaseChanged(.retrieving))
                    let snapshot = Self.retrieve(intent: intent, ctx: modelContext)
+                    continuation.yield(.retrieved(RetrievalSummary.from(snapshot: snapshot)))
                    try Task.checkCancellation()

                    // —— Phase 3: 生成 ——
@@ -178,9 +227,10 @@ struct HealthExportService {
    }

    /// 多轮导出页的单轮问答。只回答,不入库。
+    /// 事件流:先 .retrieved(检索可视化),后 .token 流式正文;不发 .phaseChanged / .completed。
    func answer(question: String,
                conversation: [HealthExportDialogueTurn],
-                in modelContext: ModelContext) -> AsyncThrowingStream<TokenChunk, Error> {
+                in modelContext: ModelContext) -> AsyncThrowingStream<Event, Error> {
        AsyncThrowingStream { continuation in
            let task = Task { @MainActor in
                do {
@@ -191,6 +241,7 @@ struct HealthExportService {
                    }

                    let snapshot = Self.retrieveDialogueSnapshot(ctx: modelContext)
+                    continuation.yield(.retrieved(RetrievalSummary.from(snapshot: snapshot)))
                    let dataJSON = Self.serializeData(snapshot: snapshot)
                    let transcript = HealthExportDialogueTurn.transcript(from: conversation)
                    let prompt = HealthExportPrompts.dialogueAnswer(
@@ -209,7 +260,7 @@ struct HealthExportService {
                        if clean.count > displayed.count, clean.hasPrefix(displayed) {
                            let delta = String(clean.dropFirst(displayed.count))
                            displayed = clean
-                            continuation.yield(TokenChunk(text: delta, decodeRate: chunk.decodeRate))
+                            continuation.yield(.token(TokenChunk(text: delta, decodeRate: chunk.decodeRate)))
                        } else if clean != displayed {
                            displayed = clean
                        }
@@ -245,6 +296,7 @@ struct HealthExportService {

                    continuation.yield(.phaseChanged(.retrieving))
                    let snapshot = Self.retrieveDialogueSnapshot(ctx: modelContext)
+                    continuation.yield(.retrieved(RetrievalSummary.from(snapshot: snapshot)))
                    let dataJSON = Self.serializeData(snapshot: snapshot)
                    let transcript = HealthExportDialogueTurn.transcript(from: conversation)
                    try Task.checkCancellation()
@@ -644,7 +696,7 @@ struct HealthExportService {
            && p.currentMedications.isEmpty
    }

-    /// 无真实记录时的确定性摘要:6 段全「无记录」,主诉仅照搬患者原话,不做任何推断。
+    /// 无真实记录时的确定性摘要:6 段全「无记录」,主诉仅照搬本人原话,不做任何推断。
    static func fallbackReport(label: String, userPrompt: String) -> String {
        let title = label.isEmpty ? "# 就诊摘要" : "# 就诊摘要 — \(label)"
        let complaint = userPrompt.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -652,12 +704,12 @@ struct HealthExportService {
        return """
        \(title)

-        > 本次未检索到可用的健康记录(指标 / 症状 / 报告 / 日记均为空),以下仅据患者原话,未做任何推断。
+        > 本次未检索到可用的健康记录(指标 / 症状 / 报告 / 日记均为空),以下仅据本人原话,未做任何推断。

        ## 主诉
        \(complaintLine)

-        ## 患者背景
+        ## 本人背景
        无记录

        ## 近期症状(按时间倒序)
@@ -669,7 +721,7 @@ struct HealthExportService {
        ## 在服药与过敏
        无记录

-        ## 患者疑问
+        ## 本人疑问
        无记录
        """
    }
--- a/康康/Services/ModelDownloadService.swift
+++ b/康康/Services/ModelDownloadService.swift
@@ -58,7 +58,7 @@ final class ModelDownloadService {
    }

    func downloadAll() {
-        for kind in ModelKind.allCases { download(kind) }
+        for kind in ModelKind.userFacing { download(kind) }
    }

    /// 暂停下载。已下载的 .part 保留,下次从断点续传。
--- a/康康/Services/OCRService.swift
+++ b/康康/Services/OCRService.swift
@@ -23,7 +23,7 @@ enum OCRService {
                let handler = VNImageRequestHandler(cgImage: cgImage, orientation: .up, options: [:])
                do {
                    try handler.perform([request])
-                    let obs = (request.results as? [VNRecognizedTextObservation]) ?? []
+                    let obs = request.results ?? []
                    cont.resume(returning: assemble(obs))
                } catch {
                    cont.resume(throwing: error)
--- a/康康/Services/ReportInsightService.swift
+++ b/康康/Services/ReportInsightService.swift
@@ -0,0 +1,61 @@
+import Foundation
+import SwiftData
+
+/// 报告大白话摘要预生成(§3.1:流程经本服务碰 AIRuntime,UI 不直接调)。
+/// 时机:归档保存后立即后台跑(用户继续操作时完成);详情页打开时兜底重试。
+/// 写回策略:只在 summary 为空时生成 —— 绝不覆盖 VL 已给出或用户编辑过的摘要。
+@MainActor
+final class ReportInsightService {
+    static let shared = ReportInsightService()
+    private init() {}
+
+    /// 进行中的报告 ID,防止「保存后台任务」与「详情页兜底」重复触发。
+    private var inFlight: Set<String> = []
+
+    func pregenerateIfNeeded(report: Report, in ctx: ModelContext) async {
+        guard (report.summary ?? "").isEmpty, !report.indicators.isEmpty else { return }
+        let key = String(describing: report.persistentModelID)
+        guard !inFlight.contains(key) else { return }
+        inFlight.insert(key)
+        defer { inFlight.remove(key) }
+
+        do {
+            try await AIRuntime.shared.prepare()
+        } catch {
+            return   // 模型未就绪:静默放弃,详情页下次打开再试
+        }
+
+        let prompt = InsightPrompts.reportPlainSummary(
+            title: report.title,
+            typeLabel: report.type.label,
+            indicatorLines: Self.indicatorLines(for: report.indicators)
+        )
+        var collected = ""
+        do {
+            let stream = await AIRuntime.shared.generate(
+                prompt: prompt, maxTokens: 200, priority: .background)
+            for try await chunk in stream { collected += chunk.text }
+        } catch {
+            return   // 被前台任务抢占(CancellationError)或推理失败:放弃,兜底路径再试
+        }
+        let text = HealthExportService.stripThinkBlocks(collected)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty, (report.summary ?? "").isEmpty else { return }
+        report.summary = text
+        try? ctx.save()
+    }
+
+    /// 「名 值 单位(参考 range)status」每指标一行;异常项排前,上限 15 行控 prompt 体积。
+    static func indicatorLines(for indicators: [Indicator]) -> String {
+        let sorted = indicators.sorted {
+            ($0.status == .normal ? 1 : 0) < ($1.status == .normal ? 1 : 0)
+        }
+        return sorted.prefix(15).map { i in
+            var line = "\(i.name) \(i.value)"
+            if !i.unit.isEmpty { line += " \(i.unit)" }
+            if !i.range.isEmpty { line += "(参考 \(i.range))" }
+            line += " \(i.status.rawValue)"
+            return line
+        }.joined(separator: "\n")
+    }
+}
--- a/康康/Services/SpeechDictationService.swift
+++ b/康康/Services/SpeechDictationService.swift
@@ -0,0 +1,151 @@
+import Foundation
+import Speech
+import AVFoundation
+
+/// 端侧流式语音转写(spec 2026-06-10-voice-diary)。
+/// AVAudioEngine 麦克风 buffer → SFSpeechAudioBufferRecognitionRequest,
+/// `requiresOnDeviceRecognition = true` 硬性端侧,识别内容不出设备;**不落盘任何音频**。
+///
+/// 生命周期:start(onPartial:) 开始录音并实时回调 partial;stop() 结束并返回最终稿。
+/// 调用方:DiaryQuickSheet。工程默认 MainActor 隔离,本类型即 MainActor;
+/// audio tap 与识别回调在系统线程,闭包内只碰局部捕获对象,回主线程统一走 Task { @MainActor }。
+final class SpeechDictationService {
+
+    enum DictationError: Error, LocalizedError {
+        case unavailable
+        case audioEngineStartFailed(String)
+
+        var errorDescription: String? {
+            switch self {
+            case .unavailable:
+                return String(appLoc: "本机不支持端侧语音识别")
+            case .audioEngineStartFailed(let m):
+                return String(appLoc: "录音启动失败:\(m)")
+            }
+        }
+    }
+
+    /// 优先系统语言;系统语言不支持端侧时兜底中文(demo 机即使系统是英文也能用)。
+    private static func makeRecognizer() -> SFSpeechRecognizer? {
+        if let r = SFSpeechRecognizer(locale: .current), r.supportsOnDeviceRecognition {
+            return r
+        }
+        if let r = SFSpeechRecognizer(locale: Locale(identifier: "zh-CN")),
+           r.supportsOnDeviceRecognition {
+            return r
+        }
+        return nil
+    }
+
+    /// 本机是否支持端侧识别。false(模拟器/老机型)时 UI 隐藏 mic 入口,静默降级。
+    static var isAvailable: Bool { makeRecognizer() != nil }
+
+    private let audioEngine = AVAudioEngine()
+    private var request: SFSpeechAudioBufferRecognitionRequest?
+    private var task: SFSpeechRecognitionTask?
+    /// 识别回调持续刷新;isFinal 或出错时置 didFinish。stop() 用「final 优先、partial 兜底」。
+    private var latestText = ""
+    private var didFinish = false
+
+    private(set) var isRecording = false
+
+    /// 麦克风 + 语音识别两个权限一起申请。任一被拒返回 false。
+    func requestAuthorization() async -> Bool {
+        let speech = await withCheckedContinuation { (c: CheckedContinuation<SFSpeechRecognizerAuthorizationStatus, Never>) in
+            SFSpeechRecognizer.requestAuthorization { c.resume(returning: $0) }
+        }
+        guard speech == .authorized else { return false }
+        return await AVAudioApplication.requestRecordPermission()
+    }
+
+    /// 开始录音 + 流式识别。partial 结果在主线程回调(录音面板实时字幕)。
+    func start(onPartial: @escaping (String) -> Void) throws {
+        guard !isRecording else { return }
+        guard let recognizer = Self.makeRecognizer(), recognizer.isAvailable else {
+            throw DictationError.unavailable
+        }
+
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setCategory(.record, mode: .measurement, options: .duckOthers)
+            try session.setActive(true, options: .notifyOthersOnDeactivation)
+        } catch {
+            throw DictationError.audioEngineStartFailed(error.localizedDescription)
+        }
+
+        let request = SFSpeechAudioBufferRecognitionRequest()
+        request.requiresOnDeviceRecognition = true   // 红线:识别不出设备
+        request.shouldReportPartialResults = true
+        request.addsPunctuation = true
+        self.request = request
+        latestText = ""
+        didFinish = false
+
+        let input = audioEngine.inputNode
+        let format = input.outputFormat(forBus: 0)
+        // tap 在音频线程跑:只碰局部捕获的 request,不碰 self
+        input.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, _ in
+            request.append(buffer)
+        }
+        audioEngine.prepare()
+        do {
+            try audioEngine.start()
+        } catch {
+            input.removeTap(onBus: 0)
+            deactivateSession()
+            throw DictationError.audioEngineStartFailed(error.localizedDescription)
+        }
+
+        task = recognizer.recognitionTask(with: request) { [weak self] result, error in
+            // 系统线程 → 主线程
+            Task { @MainActor in
+                guard let self else { return }
+                if let result {
+                    self.latestText = result.bestTranscription.formattedString
+                    onPartial(self.latestText)
+                    if result.isFinal { self.didFinish = true }
+                }
+                if error != nil { self.didFinish = true }
+            }
+        }
+        isRecording = true
+    }
+
+    /// 停止录音,等待最终识别结果(最多 1.5s,超时用最新 partial),返回最终稿。
+    /// 中途识别出错时已拿到的 partial 一样返回(spec 错误表:照常进整理流程)。
+    func stop() async -> String {
+        guard isRecording else { return "" }
+        isRecording = false
+
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+        request?.endAudio()
+
+        let deadline = Date().addingTimeInterval(1.5)
+        while !didFinish && Date() < deadline {
+            try? await Task.sleep(nanoseconds: 100_000_000)
+        }
+        task?.cancel()
+        task = nil
+        request = nil
+        deactivateSession()
+        return latestText
+    }
+
+    /// 用户直接关 sheet 时的清理:不关心结果,立即停。
+    func abort() {
+        guard isRecording else { return }
+        isRecording = false
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+        request?.endAudio()
+        task?.cancel()
+        task = nil
+        request = nil
+        deactivateSession()
+    }
+
+    private func deactivateSession() {
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    }
+}
--- a/康康/Services/TrendInsightService.swift
+++ b/康康/Services/TrendInsightService.swift
@@ -0,0 +1,94 @@
+import Foundation
+
+/// 趋势 AI 一句话解读:小预算(≤140 token)+ 按数据指纹缓存(UserDefaults)。
+/// 数据没变不重算 —— 进趋势详情页秒开;新增/修改记录改变指纹 → 自动重新生成。
+@MainActor
+final class TrendInsightService {
+    static let shared = TrendInsightService()
+    private init() {}
+
+    struct Cached: Codable, Equatable {
+        var fingerprint: String
+        var text: String
+        var generatedAt: Date
+    }
+
+    nonisolated static let storePrefix = "kk.trendInsight."
+
+    /// 数据指纹:每条线的 key + 点数 + 首末时间 + 末值/极值。体量小,直接当指纹字符串。
+    nonisolated static func fingerprint(for bucket: SeriesBucket) -> String {
+        var parts: [String] = [bucket.id]
+        for line in bucket.lines {
+            let pts = line.points
+            let first = pts.first.map { Int($0.date.timeIntervalSince1970) } ?? 0
+            let last = pts.last.map { Int($0.date.timeIntervalSince1970) } ?? 0
+            let lastV = pts.last?.value ?? 0
+            let minV = pts.map(\.value).min() ?? 0
+            let maxV = pts.map(\.value).max() ?? 0
+            parts.append("\(line.seriesKey)#\(pts.count)#\(first)#\(last)#\(lastV)#\(minV)#\(maxV)")
+        }
+        return parts.joined(separator: "|")
+    }
+
+    /// 命中缓存(指纹一致)返回文本,否则 nil。
+    func cachedText(for bucket: SeriesBucket) -> String? {
+        guard let data = UserDefaults.standard.data(forKey: Self.storePrefix + bucket.id),
+              let c = try? JSONDecoder().decode(Cached.self, from: data),
+              c.fingerprint == Self.fingerprint(for: bucket) else {
+            return nil
+        }
+        return c.text
+    }
+
+    /// 现算一条解读并写缓存。模型未就绪/输出为空时抛错,UI 显示「暂不可用 + 重试」。
+    func generate(for bucket: SeriesBucket) async throws -> String {
+        try await AIRuntime.shared.prepare()
+        let prompt = InsightPrompts.trendInsight(
+            title: bucket.title,
+            unit: bucket.unit,
+            rangeText: Self.rangeText(for: bucket),
+            dataLines: Self.dataLines(for: bucket)
+        )
+        var collected = ""
+        let stream = await AIRuntime.shared.generate(prompt: prompt, maxTokens: 140)
+        for try await chunk in stream { collected += chunk.text }
+        let text = HealthExportService.stripThinkBlocks(collected)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty else { throw AIRuntimeError.inferenceFailed("空输出") }
+        let cached = Cached(fingerprint: Self.fingerprint(for: bucket), text: text, generatedAt: .now)
+        if let data = try? JSONEncoder().encode(cached) {
+            UserDefaults.standard.set(data, forKey: Self.storePrefix + bucket.id)
+        }
+        return text
+    }
+
+    /// 每条线最近 24 个点拼成 "yyyy-MM-dd 值";多线(血压)各占一行带 label 前缀。
+    /// 用 UTC 时区:展示日期仅供模型理解走向,差几小时无影响,但测试与设备时区无关。
+    nonisolated static func dataLines(for bucket: SeriesBucket) -> String {
+        let df = DateFormatter()
+        df.locale = Locale(identifier: "en_US_POSIX")
+        df.timeZone = TimeZone(identifier: "UTC")
+        df.dateFormat = "yyyy-MM-dd"
+        var lines: [String] = []
+        for line in bucket.lines {
+            let pts = line.points.suffix(24)
+            let prefix = bucket.lines.count > 1 ? "\(line.label ?? line.seriesKey):" : ""
+            let series = pts.map { "\(df.string(from: $0.date)) \(fmt($0.value))" }
+                .joined(separator: " / ")
+            lines.append(prefix + series)
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    /// ",参考 lo-hi" 或空串(无参考范围时整段省略)。
+    nonisolated static func rangeText(for bucket: SeriesBucket) -> String {
+        guard let r = bucket.lines.first?.referenceRange else { return "" }
+        return ",参考 \(fmt(r.lowerBound))-\(fmt(r.upperBound))"
+    }
+
+    private nonisolated static func fmt(_ v: Double) -> String {
+        v.truncatingRemainder(dividingBy: 1) == 0
+            ? String(format: "%.0f", v)
+            : String(format: "%.1f", v)
+    }
+}
--- a/康康/康康-Bridging-Header.h
+++ b/康康/康康-Bridging-Header.h
@@ -0,0 +1,6 @@
+//
+//  康康-Bridging-Header.h
+//  把 Objective-C 接口暴露给 Swift。
+//
+
+#import "AI/MNN/MNNLLMBridge.h"
--- a/康康Tests/BenchmarkStoreTests.swift
+++ b/康康Tests/BenchmarkStoreTests.swift
@@ -0,0 +1,45 @@
+import Testing
+import Foundation
+@testable import 康康
+
+struct BenchmarkStoreTests {
+
+    /// 每个用例独立 suite,避免 Swift Testing 并行执行时互相清空数据。
+    private func freshDefaults(_ name: String) -> UserDefaults {
+        let suite = "test.kk.benchmark.\(name)"
+        let d = UserDefaults(suiteName: suite)!
+        d.removePersistentDomain(forName: suite)
+        return d
+    }
+
+    @Test func savesAndLoadsPerBackend() {
+        let d = freshDefaults("savesAndLoads")
+        let mnn = BenchmarkResult(backendLabel: "MNN · SME2", promptTokens: 30, genTokens: 80,
+                                  prefillTokensPerSecond: 120, decodeTokensPerSecond: 25,
+                                  totalSeconds: 4.2, date: .now)
+        let mlx = BenchmarkResult(backendLabel: "MLX · GPU", promptTokens: 30, genTokens: 80,
+                                  prefillTokensPerSecond: 300, decodeTokensPerSecond: 40,
+                                  totalSeconds: 2.5, date: .now)
+        BenchmarkService.save(mnn, defaults: d)
+        BenchmarkService.save(mlx, defaults: d)
+        let all = BenchmarkService.load(defaults: d)
+        #expect(all.count == 2)
+        #expect(all["MNN · SME2"]?.decodeTokensPerSecond == 25)
+    }
+
+    @Test func overwritesSameBackend() {
+        let d = freshDefaults("overwrites")
+        let old = BenchmarkResult(backendLabel: "MLX · GPU", promptTokens: 1, genTokens: 1,
+                                  prefillTokensPerSecond: 1, decodeTokensPerSecond: 1,
+                                  totalSeconds: 1, date: .now)
+        var new = old
+        new.decodeTokensPerSecond = 99
+        BenchmarkService.save(old, defaults: d)
+        BenchmarkService.save(new, defaults: d)
+        #expect(BenchmarkService.load(defaults: d)["MLX · GPU"]?.decodeTokensPerSecond == 99)
+    }
+
+    @Test func loadOnEmptyReturnsEmpty() {
+        #expect(BenchmarkService.load(defaults: freshDefaults("loadEmpty")).isEmpty)
+    }
+}
--- a/康康Tests/DiaryOrganizePromptTests.swift
+++ b/康康Tests/DiaryOrganizePromptTests.swift
@@ -0,0 +1,28 @@
+import Testing
+@testable import 康康
+
+struct DiaryOrganizePromptTests {
+    @Test func organizePromptContainsTranscriptAndHardRules() {
+        let prompt = DiaryAssistPrompts.organize(transcript: "今天早上头晕量了血压140 90")
+
+        #expect(prompt.contains("今天早上头晕量了血压140 90"))
+        // 健康数据红线:数值/单位/药名/时间不许改,必须写进 prompt
+        #expect(prompt.contains("数值"))
+        #expect(prompt.contains("药名"))
+        // 自适应样式两条规则都在
+        #expect(prompt.contains("一段通顺的话"))
+        #expect(prompt.contains("分行"))
+        // 项目 prompt 规范:禁思考标签
+        #expect(prompt.contains("/no_think"))
+    }
+
+    @Test func organizePromptTruncatesLongTranscript() {
+        let long = String(repeating: "头晕", count: 2000)   // 4000 字符,超过上限
+        let prompt = DiaryAssistPrompts.organize(transcript: long)
+
+        // 整条 prompt 里口述部分被截断到 organizeTranscriptLimit
+        let expectedTail = String(long.prefix(DiaryAssistPrompts.organizeTranscriptLimit))
+        #expect(prompt.contains(expectedTail))
+        #expect(!prompt.contains(String(long.prefix(DiaryAssistPrompts.organizeTranscriptLimit + 2))))
+    }
+}
--- a/康康Tests/HealthExportDialogueTests.swift
+++ b/康康Tests/HealthExportDialogueTests.swift
@@ -3,7 +3,7 @@ import Testing
@testable import 康康

 struct HealthExportDialogueTests {
-    @Test func dialogueTranscriptKeepsTurnOrderAndRoles() {
+    @Test func dialogueTranscriptKeepsTurnOrderAndRoles() throws {
        let turns: [HealthExportDialogueTurn] = [
            .user("我最近头晕,帮我看看"),
            .assistant("我会结合你的指标和日记整理。"),
@@ -12,10 +12,13 @@ struct HealthExportDialogueTests {

        let transcript = HealthExportDialogueTurn.transcript(from: turns)

-        #expect(transcript.contains("患者: 我最近头晕,帮我看看"))
+        // 用户角色标签是「我」(产品红线:不出现「患者」,见 ca5a3fa)。
+        #expect(transcript.contains("我: 我最近头晕,帮我看看"))
        #expect(transcript.contains("康康: 我会结合你的指标和日记整理。"))
-        #expect(transcript.contains("患者: 重点看血压"))
-        #expect(transcript.range(of: "患者: 我最近头晕")!.lowerBound < transcript.range(of: "患者: 重点看血压")!.lowerBound)
+        #expect(transcript.contains("我: 重点看血压"))
+        let first = try #require(transcript.range(of: "我: 我最近头晕"))
+        let second = try #require(transcript.range(of: "我: 重点看血压"))
+        #expect(first.lowerBound < second.lowerBound)
    }

    @Test func dialogueTranscriptDropsEmptyTurns() {
@@ -27,8 +30,8 @@ struct HealthExportDialogueTests {

        let transcript = HealthExportDialogueTurn.transcript(from: turns)

-        #expect(!transcript.contains("患者:   "))
+        #expect(!transcript.contains("我:   "))
        #expect(transcript.contains("康康: 请补充想看的问题"))
-        #expect(transcript.contains("患者: 最近三个月"))
+        #expect(transcript.contains("我: 最近三个月"))
    }
 }
--- a/康康Tests/InferencePriorityTests.swift
+++ b/康康Tests/InferencePriorityTests.swift
@@ -0,0 +1,28 @@
+import Testing
+@testable import 康康
+
+struct InferencePriorityTests {
+
+    @Test func interactiveJumpsAheadOfBackground() {
+        let idx = AIRuntime.gateInsertionIndex(of: .interactive,
+                                               in: [.interactive, .background, .background])
+        #expect(idx == 1)
+    }
+
+    @Test func interactiveKeepsFIFOAmongInteractive() {
+        let idx = AIRuntime.gateInsertionIndex(of: .interactive,
+                                               in: [.interactive, .interactive])
+        #expect(idx == 2)
+    }
+
+    @Test func backgroundAlwaysAppends() {
+        let idx = AIRuntime.gateInsertionIndex(of: .background,
+                                               in: [.interactive, .background])
+        #expect(idx == 2)
+    }
+
+    @Test func emptyQueueInsertsAtZero() {
+        #expect(AIRuntime.gateInsertionIndex(of: .interactive, in: []) == 0)
+        #expect(AIRuntime.gateInsertionIndex(of: .background, in: []) == 0)
+    }
+}
--- a/康康Tests/InsightPromptsTests.swift
+++ b/康康Tests/InsightPromptsTests.swift
@@ -0,0 +1,26 @@
+import Testing
+@testable import 康康
+
+struct InsightPromptsTests {
+
+    @Test func reportSummaryPromptCarriesDataAndGuards() {
+        let p = InsightPrompts.reportPlainSummary(
+            title: "春季体检", typeLabel: "体检报告",
+            indicatorLines: "血红蛋白 118 g/L(参考 130-175)low")
+        #expect(p.contains("春季体检"))
+        #expect(p.contains("血红蛋白 118"))
+        #expect(p.contains("/no_think"))
+        #expect(p.contains("不诊断"))
+        #expect(!p.contains("患者"))
+    }
+
+    @Test func trendPromptCarriesDataAndGuards() {
+        let p = InsightPrompts.trendInsight(
+            title: "空腹血糖", unit: "mmol/L", rangeText: ",参考 3.9-6.1",
+            dataLines: "2026-05-01 5.2 / 2026-06-01 5.8")
+        #expect(p.contains("空腹血糖"))
+        #expect(p.contains("2026-06-01 5.8"))
+        #expect(p.contains("/no_think"))
+        #expect(!p.contains("患者"))
+    }
+}
--- a/康康Tests/ModelManifestTests.swift
+++ b/康康Tests/ModelManifestTests.swift
@@ -4,8 +4,8 @@ import Foundation

 struct ModelManifestTests {

-    @Test func llmHasNineFunctionalFiles() {
-        #expect(ModelManifest.files(for: .llm).count == 9)
+    @Test func llmHasTenFunctionalFiles() {
+        #expect(ModelManifest.files(for: .llm).count == 10)
    }

    @Test func vlHasFourteenFunctionalFiles() {
@@ -13,13 +13,35 @@ struct ModelManifestTests {
    }

    @Test func llmTotalBytesMatchesManifest() {
-        #expect(ModelManifest.totalBytes(for: .llm) == 984_013_244)
+        #expect(ModelManifest.totalBytes(for: .llm) == 1_749_079_691)
    }

    @Test func vlTotalBytesMatchesManifest() {
        #expect(ModelManifest.totalBytes(for: .vl) == 3_109_729_929)
    }

+    @Test func mnnHasSixFunctionalFiles() {
+        #expect(ModelManifest.files(for: .mnnLLM).count == 6)
+    }
+
+    @Test func mnnTotalBytesMatchesManifest() {
+        #expect(ModelManifest.totalBytes(for: .mnnLLM) == 1_185_759_005)
+    }
+
+    @Test func mnnHasEssentialRuntimeFiles() {
+        let names = ModelManifest.files(for: .mnnLLM).map(\.path)
+        #expect(names.contains("config.json"))
+        #expect(names.contains("llm.mnn"))
+        #expect(names.contains("llm.mnn.weight"))
+        #expect(names.contains("tokenizer.txt"))
+    }
+
+    @Test func mnnFileURLUsesRepoPath() {
+        let file = ModelFile(path: "config.json", bytes: 652)
+        let url = ModelManifest.fileURL(for: .mnnLLM, file: file)
+        #expect(url.absoluteString == "https://file.myv0.com/Qwen3.5-2B-MNN/config.json")
+    }
+
    @Test func excludesReadmeAndGitattributes() {
        for kind in [ModelKind.llm, .vl] {
            let names = ModelManifest.files(for: kind).map(\.path)
@@ -40,8 +62,8 @@ struct ModelManifestTests {
    }

    @Test func fileURLIsBaseSlashRepoSlashPath() {
-        let file = ModelFile(path: "config.json", bytes: 937)
+        let file = ModelFile(path: "config.json", bytes: 3_113)
        let url = ModelManifest.fileURL(for: .llm, file: file)
-        #expect(url.absoluteString == "https://file.myv0.com/Qwen3-1.7B-4bit/config.json")
+        #expect(url.absoluteString == "https://file.myv0.com/Qwen3.5-2B-4bit/config.json")
    }
 }
--- a/康康Tests/RegionImageCropperTests.swift
+++ b/康康Tests/RegionImageCropperTests.swift
@@ -3,7 +3,7 @@ import CoreGraphics
 import AVFoundation
@testable import 康康

-/// 异常项快拍的局部裁剪几何。
+/// 指标速记的局部裁剪几何。
 /// 回归用例:屏上「宽而矮」的小框,必须裁出「宽 > 高」的照片 rect。
 /// 旧实现用 `metadataOutputRectConverted`(传感器横向坐标)套到竖屏照片 → x/y 轴对调,
 /// 把宽框裁成竖窄条(2026-05-31 真机 bug)。本组用例钉住正确的纯几何映射。
@@ -112,4 +112,5 @@ final class RegionImageCropperTests: XCTestCase {
                                                 imageFrame: CGRect(x: 0, y: 0, width: 100, height: 100)),
            .zero)
    }
+
 }
--- a/康康Tests/RetrievalSummaryTests.swift
+++ b/康康Tests/RetrievalSummaryTests.swift
@@ -0,0 +1,22 @@
+import Testing
+@testable import 康康
+
+struct RetrievalSummaryTests {
+
+    @Test func groupsAndCountsPreservingOrder() {
+        let chips = HealthExportService.RetrievalSummary.groupedChips(
+            ["血压", "血糖", "血压", "血压", "体重"], cap: 8)
+        #expect(chips == ["血压 ×3", "血糖", "体重"])
+    }
+
+    @Test func capsAndAppendsOverflow() {
+        let names = (1...12).map { "指标\($0)" }
+        let chips = HealthExportService.RetrievalSummary.groupedChips(names, cap: 8)
+        #expect(chips.count == 9)
+        #expect(chips.last == "+4")
+    }
+
+    @Test func emptyInputGivesEmptyChips() {
+        #expect(HealthExportService.RetrievalSummary.groupedChips([], cap: 8).isEmpty)
+    }
+}
--- a/康康Tests/SeriesBucketTests.swift
+++ b/康康Tests/SeriesBucketTests.swift
@@ -18,14 +18,17 @@ struct SeriesBucketTests {
                  seriesKey: seriesKey)
    }

-    @Test func skipsIndicatorsWithoutSeriesKey() {
+    @Test func indicatorsWithoutSeriesKeyFoldIntoLabBucket() {
+        // 「lab 段」特性:无 seriesKey 的指标按 name+unit 归并,同名 ≥minPoints 次即成趋势。
        let now = Date()
        let items = [
-            makeIndicator(value: "5.0", capturedAt: now, seriesKey: nil),
+            makeIndicator(value: "5.0", capturedAt: now.addingTimeInterval(-86_400), seriesKey: nil),
            makeIndicator(value: "5.2", capturedAt: now, seriesKey: nil),
        ]
        let buckets = SeriesBucket.build(from: items)
-        #expect(buckets.isEmpty)
+        #expect(buckets.count == 1)
+        #expect(buckets.first?.kind == .lab)
+        #expect(buckets.first?.lines.first?.points.count == 2)
    }

    @Test func filtersOutSeriesWithFewerThanMinPoints() {
--- a/康康Tests/SpeechDictationAvailabilityTests.swift
+++ b/康康Tests/SpeechDictationAvailabilityTests.swift
@@ -0,0 +1,13 @@
+import Testing
+@testable import 康康
+
+struct SpeechDictationAvailabilityTests {
+    /// 模拟器冒烟:isAvailable 的探测路径(SFSpeechRecognizer 构造 + supportsOnDeviceRecognition)
+    /// 不许崩溃、不许卡死;模拟器多为 false(mic 按钮隐藏),个别 Xcode/macOS 组合为 true 也合法,
+    /// 所以只断言「可重复调用且结果稳定」,不断言具体值。
+    @Test func isAvailableProbeIsStableAndDoesNotCrash() {
+        let first = SpeechDictationService.isAvailable
+        let second = SpeechDictationService.isAvailable
+        #expect(first == second)
+    }
+}
--- a/康康Tests/TrendInsightCacheTests.swift
+++ b/康康Tests/TrendInsightCacheTests.swift
@@ -0,0 +1,43 @@
+import Testing
+import SwiftUI
+@testable import 康康
+
+@MainActor
+struct TrendInsightCacheTests {
+
+    private func bucket(values: [Double]) -> SeriesBucket {
+        let points = values.enumerated().map { i, v in
+            SeriesBucket.Point(id: "p\(i)",
+                               date: Date(timeIntervalSince1970: Double(i) * 86_400),
+                               value: v, status: .normal)
+        }
+        let line = SeriesBucket.SeriesLine(id: "glucose.fasting", seriesKey: "glucose.fasting",
+                                           label: nil, color: .blue, points: points,
+                                           referenceRange: 3.9...6.1)
+        return SeriesBucket(id: "glucose.fasting", title: "空腹血糖", unit: "mmol/L",
+                            lines: [line], latestDate: .now, kind: .monitor)
+    }
+
+    @Test func fingerprintStableForSameData() {
+        let a = TrendInsightService.fingerprint(for: bucket(values: [5.2, 5.5]))
+        let b = TrendInsightService.fingerprint(for: bucket(values: [5.2, 5.5]))
+        #expect(a == b)
+    }
+
+    @Test func fingerprintChangesWhenDataChanges() {
+        let a = TrendInsightService.fingerprint(for: bucket(values: [5.2, 5.5]))
+        let b = TrendInsightService.fingerprint(for: bucket(values: [5.2, 5.5, 6.0]))
+        #expect(a != b)
+    }
+
+    @Test func dataLinesFormatsDateAndValue() {
+        let lines = TrendInsightService.dataLines(for: bucket(values: [5.2, 5.5]))
+        #expect(lines.contains("1970-01-01 5.2"))
+        #expect(lines.contains("1970-01-02 5.5"))
+    }
+
+    @Test func rangeTextRendersReference() {
+        #expect(TrendInsightService.rangeText(for: bucket(values: [5.2]))
+                == ",参考 3.9-6.1")
+    }
+}
--- a/康康Tests/VLPromptsOCRTests.swift
+++ b/康康Tests/VLPromptsOCRTests.swift
@@ -0,0 +1,32 @@
+import Testing
+@testable import 康康
+
+struct VLPromptsOCRTests {
+
+    @Test func emptyOCRKeepsPromptClean() {
+        let p = VLPrompts.reportExtraction(ocrText: "")
+        #expect(!p.contains("OCR 参考文本"))
+        #expect(!p.contains("{{OCR_SECTION}}"))
+        #expect(p.contains("现在请识别图片并输出 JSON"))
+    }
+
+    @Test func ocrTextIsInjectedBeforeFinalInstruction() {
+        let p = VLPrompts.reportExtraction(ocrText: "尿酸  486  208-428  μmol/L")
+        #expect(p.contains("OCR 参考文本"))
+        #expect(p.contains("尿酸  486"))
+        let ocrPos = p.range(of: "尿酸  486")!.lowerBound
+        let endPos = p.range(of: "现在请识别图片并输出 JSON")!.lowerBound
+        #expect(ocrPos < endPos)
+    }
+
+    @Test func clipKeepsShortTextIntact() {
+        #expect(VLPrompts.clipOCR("短文本") == "短文本")
+    }
+
+    @Test func clipCutsAtLineBoundary() {
+        let long = Array(repeating: "指标行 1.23 mmol/L", count: 400).joined(separator: "\n")
+        let clipped = VLPrompts.clipOCR(long, limit: 200)
+        #expect(clipped.count < 260)
+        #expect(clipped.hasSuffix("(后续内容过长已截断)"))
+    }
+}
Author	SHA1	Message	Date
link2026	69de5faf4b	``` feat(localization): 添加AI功能相关的本地化字符串新增了多个AI功能相关的本地化文本，包括AI整理、AI解读、本地推理等界面的文字显示，并添加了语音识别和性能测试相关的提示信息。同时更新了一些现有条目的状态标记。 ```	2026-06-10 08:15:43 +08:00
link2026	477a64ecb4	fix(语音日记): dictation 服务改 @State 防视图重建丢实例 struct View 重建时普通 let 属性会换成全新 SpeechDictationService, stop() 落在没在录音的新实例上返回空串 → 误报「没听清,再试一次」, 且真正在录音的老实例关不掉(麦克风悬挂)。改 @State 保证实例唯一; 停止时若服务仍返回空,用 @State 实时字幕兜底(用户看到什么就用什么)。 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 08:04:15 +08:00
link2026	6405733358	docs(plan): 比赛优化五件套计划 — 全部勾选(余 9.3 真机手测) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:13:24 +08:00
link2026	2e27677f80	test: 修正两处断言旧行为的存量测试(患者→我文案、lab 段归并) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:12:48 +08:00
link2026	2e90139df7	docs(AI): MNN prefix KV cache 调研 — setPrefixCacheFile 可用,建议 W6 量化后接入 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:12:48 +08:00
link2026	77139f5e32	feat(Capture): 报告识别注入 Vision OCR 参考文本,提升 2B 多模态数字准确率 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:12:48 +08:00
link2026	0dd60d6021	feat(Trends): AI 趋势解读上线 — 数据指纹缓存,秒开不重算 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:12:48 +08:00
link2026	43cdde9bab	feat(Capture): 归档后后台预生成大白话摘要,详情页秒开 + 兜底重试 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 07:12:48 +08:00
link2026	0a824610cf	docs(plan): 勾选已完成步骤(余真机手测) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:53:25 +08:00
link2026	7e8e692695	test(语音日记): 端侧识别可用性探测冒烟测试(模拟器降级路径) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:51:53 +08:00
link2026	3f9a2af279	feat(Ask): 检索过程可视化 — RAG 命中记录以 chips 展示,生成前先看见 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:42:59 +08:00
link2026	a65c63947b	feat(Me): 性能自检卡 — 后端标识 + prefill/decode 实测 + 引擎对比存档 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:42:59 +08:00
link2026	8494e51823	feat(AI): 推理闸门双优先级 — 前台插队、后台按 token 让位;暴露统计与后端标签 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:42:59 +08:00
link2026	070e016f81	feat(AI): 两后端归一的 GenerateStats(prefill/decode 实测统计) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:42:59 +08:00
link2026	8c8599e77d	feat(语音日记): DiaryQuickSheet 接入语音输入(录音→整理→回退原话) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:24:49 +08:00
link2026	b7e8ab33ec	feat(语音日记): DiaryVoicePanel 录音/整理面板 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:13:54 +08:00
link2026	db327afd79	feat(语音日记): SpeechDictationService 端侧流式转写(不落盘音频) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:12:54 +08:00
link2026	5eb724ab86	feat(语音日记): DiaryAssistService.organize 转写稿整理 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:11:55 +08:00
link2026	cfeb25247a	feat(语音日记): organize prompt(自适应样式 + 数值不可改红线) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:11:15 +08:00
link2026	26a7d53b1b	feat(语音日记): 新增麦克风与语音识别权限描述(端侧识别文案) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:07:38 +08:00
link2026	e603738330	docs(plan): 语音健康日记实施计划 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 06:05:59 +08:00
link2026	7f0a76098a	docs(spec): 语音健康日记(端侧 ASR + LLM 整理)设计文档 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 05:41:29 +08:00
link2026	b79ae54b7b	``` feat(iOS): 更新MNN后端模型配置优化性能将MNN主模型从Qwen3.5-4B(~2.64GiB)降级为Qwen3.5-2B(~1.1GiB)，因为4B版本实测运行过慢，影响用户体验。iPhone17+/SME2设备使用2B模型，保留MLX 兜底方案用于模拟器和备用场景，确保AI推理性能和存储效率的平衡。 ```	2026-06-09 22:20:07 +08:00
link2026	ca5a3fa38b	``` fix(AI): 统一将"患者"相关术语替换为"本人" 统一修改代码中的称谓，将所有"患者"相关的文本替换为"本人"，包括提示词、注释和界面显示中的"患者"、"患者背景"、"患者疑问"等表述，以保持用户称谓的一致性。 BREAKING CHANGE: 修改了API返回内容中的术语表述 ```	2026-06-08 23:28:37 +08:00
link2026	836f3d4234	``` feat(AI): 统一多模态模型架构，整合文本和视觉推理路径 - 将文本生成和VL(图→文)功能合并到单一的Qwen3.5-4B多模态MNN模型 - 移除独立的Qwen3-VL-4B模型依赖，MLX VL改为使用.llm的多模态模型 - 更新ModelKind枚举，新增userFacing集合用于面向用户展示 - MNN后端现在同时支持文本和视觉任务，模拟器回退到MLX refactor(models): 模型管理和界面调整以适应新的多模态架构 - 更新模型管理界面，只显示统一的Qwen3.5-4B(MNN)模型给用户 - 修改就绪状态检查逻辑，使用ModelKind.userFacing替代allCases - 更新模型文件清单，从Qwen3.5-2B升级到Qwen3.5-4B-4bit - 调整模型管理页面UI，突出MNN+SME2端侧加速功能 feat(camera): 添加拍照识别引擎切换功能 - 实现双路径拍照识别：Apple Vision OCR + 文本模型和 Qwen3-VL直接识别 - 添加预处理逻辑，优化Qwen3-VL对窄长区域图片的识别效果 - 在模型管理页面添加拍照识别引擎选择组件 - 提供用户界面选项，在两种识别方式间切换 style(ui): 优化输入框样式和颜色主题一致性 - 为指标快速表单添加浅色主题偏好 - 统一所有文本输入框的颜色样式(theme) - 创建EntryInputField组件，替换原有的单行输入+按钮模式 - 实现聊天框风格的条目输入，支持多行自适应和圆形发送按钮 fix(build): 修正Xcode项目配置中的重复框架搜索路径 - 清理project.pbxproj中重复的FRAMEWORK_SEARCH_PATHS配置 - 重新排列Swift桥接头文件配置确保正确引用 - 修复因路径配置重复导致的编译警告问题 test: 增加区域图片预处理和模型清单测试覆盖 - 添加RegionImageCropper.prepareForQwenVL的单元测试 - 验证宽而矮图片的放大和填充逻辑 - 更新ModelManifestTests中的字节数预期值以匹配新模型 - 修正OCRService中VNRecognizedTextObservation类型的处理 ```	2026-06-08 23:25:31 +08:00
link2026	b919404412	fix(MNN): 抑制 MNN 第三方头的 -Wdocumentation 警告 MNN 公共头(Executor/Tensor/Interpreter/ImageProcess.hpp)文档注释不规范, 桥接 #include <MNN/llm/llm.hpp> 时触发 13 条 -Wdocumentation 警告。用 #pragma clang diagnostic 只在解析 MNN 头时关掉,不影响本项目自身文档警告。 device BUILD SUCCEEDED,警告 0。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 21:29:09 +08:00
link2026	ddfd474bb3	feat(AI): MNN 4B 多模态一肩挑文本+视觉,合并为单模型(MLX 仍兜底) 利用 Qwen3.5-4B-MNN 本身是多模态(含 visual.mnn),让同一个 MNN 模型同时做文本生成与拍照识别 → MNN 路径只需下 1 个模型(7.4GB→2.64GB)。 MLX(.llm/.vl)保留作兜底,尤其开发机 iPhone 15 Pro(A17 无 SME2)。 - MNN.xcframework 重建为 OMNI(MNN_BUILD_LLM_OMNI=ON,加 OpenCV 图像解码); 构建脚本同步加 OMNI flag - MNNLLMBridge.analyzeImages:把图片路径拼成 <img>路径</img> 标签 + response, Omni 内部 CV::imread 加载(无需桥接 include OpenCV);与 generateText 共用 runResponse - MNNBackend.analyze:detached 线程跑 blocking VL 调用,聚合为字符串 - AIRuntime:engine=.mnn 且就绪时,prepareVL→prepareMNN、analyzeReport→mnn.analyze; 否则回退 MLX VL device + 模拟器 BUILD SUCCEEDED,0 error,OMNI 框架链接干净。 VL 实际识别质量需真机用化验单 A/B(demo 核心)。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 20:52:58 +08:00
link2026	cbacd9461a	feat(AI): MNN 文本模型升到 Qwen3.5-4B(taobao-mnn 预转换) 现场机 iPhone 17(A19/SME2)内存与加速均可承载 4B,质量优于 2B。 - ModelKind.mnnLLM rawValue → "Qwen3.5-4B-MNN",displayName → Qwen3.5-4B (MNN/SME2) - ModelManifest:7 个运行时文件(llm.mnn.weight ~2.45GB + 拆分的 visual.mnn.weight 188MB),总计 2,836,770,850 bytes(~2.64GiB) - ModelManifestTests:文件数 7 / 总字节 / URL 更新到 Qwen3.5-4B-MNN - CLAUDE.md §2:MNN 主模型记为 Qwen3.5-4B,MLX 兜底仍 2B 模拟器 ModelManifestTests TEST SUCCEEDED。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 20:28:14 +08:00
link2026	39b1521f00	feat(AI): MNN 模型纳入下载体系 ModelKind.mnnLLM(Phase 4) 文本 MNN 模型用 taobao-mnn/Qwen3.5-2B-MNN 官方预转换格式(~1.10GiB), 不再从头转换(避开多模态转文本风险,官方转更可靠)。 - ModelStore.ModelKind 新增 .mnnLLM = "Qwen3.5-2B-MNN" - ModelManifest:.mnnLLM 文件清单(config.json/llm_config.json/llm.mnn/ llm.mnn.weight 1.1GB/tokenizer.txt/visual.mnn,HF API 实测字节) - AIRuntime:mnnModelFolder + 就绪判定改走 ModelStore.isComplete(.mnnLLM) - ModelManagementView:subtitle 加 .mnnLLM 文案(仅此一处,未动其它 WIP) - ModelManifestTests:+4 条 mnnLLM 断言(文件数/总字节/必需文件/URL) 模拟器 ModelManifestTests TEST SUCCEEDED。下载经现有链路,需上传到 file.myv0.com/Qwen3.5-2B-MNN/(CDN 清单随附)。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 19:38:16 +08:00
link2026	9da3fbc87e	feat(Me): 推理引擎切换页 + SME2 状态 + CLAUDE.md 更新(Phase 5 部分) - InferenceSettingsView:MNN(CPU/SME2)/ MLX(GPU)单选切换,展示当前设备 SME2 探测状态(A19 启用 / A17 回退);走设计系统卡片,新文件不动 WIP 的 ModelManagementView - MeView:「模型管理」下新增「推理引擎」入口,detail 显示 MNN·SME2 / MNN·CPU / MLX·GPU - CLAUDE.md §2/§12:AI 运行时改为 MNN(主,SME2)+ MLX(兜底)双后端, 卖点 #2 明确 MNN+Arm SME2 端侧 CPU 加速为挑战赛考核点模拟器 BUILD SUCCEEDED,0 error。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 19:23:00 +08:00
link2026	f6c0ba7077	feat(AI): 双后端路由 MNN/MLX,AIRuntime 按引擎分发(Phase 3 核心) - InferenceEngine:引擎枚举(.mnn 默认 / .mlx 兜底)+ UserDefaults 持久化 + 可用性/SME2 运行时探测(经 MNNLLMBridge) - MNNBackend:actor 封装 MNNLLMBridge 文本流式生成,detached 线程跑同步 response、按 UTF-8 边界 yield TokenChunk,串行化交给 AIRuntime 闸门 - AIRuntime:prepare/generate 按引擎分发;.mnn 且模型就绪→MNN,否则回退 MLX (过渡期 App 始终可用);prepareVL/单模型常驻时互卸 MNN↔MLX 释放内存公有 API 不变,各 Service 零改动模拟器 BUILD SUCCEEDED,0 error。引擎切换 UI + SME2 指示留待 Phase 5。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 18:58:27 +08:00
link2026	afc6a79dd7	feat(AI/MNN): 集成 MNN.xcframework + ObjC++ 桥(LLM+SME2,Phase 1-2) 挑战赛考核点要求 Qwen + MNN + SME2 + CPU 端侧推理,MLX(GPU)不满足。本提交打通原生 MNN 集成的工程层: - scripts/build-mnn-xcframework.sh:从 alibaba/MNN 源码构建 device+sim arm64 双切片 xcframework,MNN_BUILD_LLM=ON 导出 llm/llm.hpp,MNN_SME2=ON (KleidiAI 运行时自动路由:A19/iPhone17 走 SME2,A17 回退 NEON) - MNNLLMBridge.{h,mm}:ObjC++ 封装 MNN Llm 的加载/流式生成,streambuf 按 UTF-8 边界聚合回调,getContext() 取 prefill/decode 算 tok/s;模拟器编为桩 (走 MLX 兜底),SME2 经 sysctl hw.optional.arm.FEAT_SME2 探测 - pbxproj:链接 MNN.xcframework + bridging header - 二进制 gitignore,由脚本本地生成防历史膨胀模拟器 BUILD SUCCEEDED(0 error),xcframework 处理 + 桥编译 + 链接通过。下一步 Phase 3:MNNBackend + AIRuntime 双后端路由。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 18:31:02 +08:00
link2026	06484d09ff	feat(AI): LLM 迁移到 mlx-swift-lm 2.31.3 + Qwen3.5-2B 将 SPM 依赖从 mlx-swift-examples 2.29.1 迁到改名延续仓库 mlx-swift-lm 2.31.3(含 qwen3_5 架构、旧 loadContainer API 兼容),文本 LLM 由 Qwen3-1.7B 换为 Qwen3.5-2B-4bit(走 qwen3_5→Qwen35Model 文本路径)。连带 mlx-swift 0.29.1→0.31.4,顺修弃用 API: - MLX.GPU.clearCache() → MLX.Memory.clearCache() - MLX.GPU.set(cacheLimit:) → MLX.Memory.cacheLimit 更新 ModelManifest(.llm 文件清单+精确字节数,~1.63GiB)、ModelManifestTests、 HealthExport.modelTag 默认值。App BUILD SUCCEEDED + ModelManifestTests 通过。保留作 MNN 改造的 GPU 兜底基线。 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 18:00:28 +08:00