test(EVD-7R): 报告闭环 23 SC 三类流契约证据 | 82 JUnit 全绿(11类,0失败) + 8 LangGraph pytest 全绿(SC-B-04/B-11) | SC-S-09 映射 listTypeLinks(未实现端点ProviderController缺) | 基线2af4829b1已并入b3a975111

cfc-backend/src/test/java/com/etotem/cfc/unit/AssessmentComparisonContractTest.java

@@ -0,0 +1,226 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.DanAssessmentResult;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.FiveDimensionScore;
+import com.etotem.cfc.mapper.DanAssessmentResultMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.service.AssessmentComparisonService;
+import com.etotem.cfc.service.FiveDimensionScoreService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-T-21 / SC-P-24 — 测评对比与进步叙事契约测试（compareByChild / compareByChildAndDimension / getProgressNarrative）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：≥2 次测评 → 首/次快照对比（维度 delta + 方向驱动 + 进步叙事）；
+ *       单维度聚焦对比取该维度组全部分数；</li>
+ *   <li><b>异常流</b>：仅 1 次测评 → 回退 five_dimension_scores；仍不足 → 返回 null / 「暂无足够数据」；
+ *       全维度无变化 → direction=unchanged / 叙事“各项指标保持稳定”；</li>
+ *   <li><b>权限流</b>：n/a —— 对比严格限定单成员（memberId 作用域），不跨成员。</li>
+ * </ul>
+ */
+class AssessmentComparisonContractTest {
+
+    private AssessmentComparisonService service;
+
+    private DanAssessmentResultMapper danAssessmentResultMapper;
+    private FiveDimensionScoreService fiveDimensionScoreService;
+    private FamilyMemberMapper familyMemberMapper;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, DanAssessmentResult.class);
+        TableInfoHelper.initTableInfo(assistant, FiveDimensionScore.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new AssessmentComparisonService();
+        injectAll(service);
+        danAssessmentResultMapper = (DanAssessmentResultMapper) readField(service, "danAssessmentResultMapper");
+        fiveDimensionScoreService = (FiveDimensionScoreService) readField(service, "fiveDimensionScoreService");
+        familyMemberMapper = (FamilyMemberMapper) readField(service, "familyMemberMapper");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private DanAssessmentResult result(Long id, Date date, int attention, int mood, int logic) {
+        DanAssessmentResult r = new DanAssessmentResult();
+        r.setId(id);
+        r.setMemberId(55L);
+        r.setStatus("completed");
+        r.setAssessmentDate(date);
+        r.setAttentionScore(attention);
+        r.setFocusScore(attention);      // 同组
+        r.setEmotionScore(mood);
+        r.setResilienceScore(mood);      // 同组
+        r.setLogicScore(logic);
+        return r;
+    }
+
+    // ==================== 正常流：两次测评对比 ====================
+
+    @Test
+    void 正常流_两次测评_对比首最新_产生维度delta与叙事() {
+        Date d1 = new Date(System.currentTimeMillis() - 30L * 24 * 3600 * 1000);
+        Date d2 = new Date();
+        when(danAssessmentResultMapper.selectList(any())).thenReturn(Arrays.asList(
+                result(1L, d1, 40, 50, 60),
+                result(2L, d2, 70, 50, 90)
+        ));
+
+        AssessmentComparisonService.CompareResult compare = service.compareByChild(55L);
+
+        assertNotNull(compare);
+        assertEquals(1L, compare.firstAssessment.id);
+        assertEquals(2L, compare.latestAssessment.id);
+        // attention 组（attentionScore+focusScore）：40→70 两次 = 维度 delta +60
+        AssessmentComparisonService.DimensionDelta attention = findDelta(compare.dimensionDeltas, "attention");
+        assertNotNull(attention, "应包含 attention 维度对比");
+        assertEquals(60.0, attention.delta, 0.001);
+        assertEquals("up", attention.direction);
+        assertTrue(!attention.drivers.isEmpty(), "驱动因素应列出具体分数项");
+        // overallDelta 为 6 个维度组均值 = (60+0+30+0+0+0)/6 = +15
+        assertEquals(15.0, compare.overallDelta, 0.001);
+        assertTrue(compare.narrative.contains("提升"), "叙事应包含提升描述");
+    }
+
+    @Test
+    void 正常流_单维度聚焦对比_取维度组分数() {
+        Date d1 = new Date(System.currentTimeMillis() - 30L * 24 * 3600 * 1000);
+        Date d2 = new Date();
+        when(danAssessmentResultMapper.selectList(any())).thenReturn(Arrays.asList(
+                result(1L, d1, 40, 50, 60),
+                result(2L, d2, 70, 50, 90)
+        ));
+
+        AssessmentComparisonService.DimensionDelta delta = service.compareByChildAndDimension(55L, "attention");
+
+        assertNotNull(delta, "至少两次测评应返回单维度对比");
+        assertEquals("attention", delta.dimension);
+        assertEquals(60.0, delta.delta, 0.001); // attention(40→70) + focus(40→70) = +60
+        assertEquals("up", delta.direction);
+    }
+
+    @Test
+    void 正常流_getProgressNarrative_生成叙事() {
+        Date d1 = new Date(System.currentTimeMillis() - 30L * 24 * 3600 * 1000);
+        Date d2 = new Date();
+        when(danAssessmentResultMapper.selectList(any())).thenReturn(Arrays.asList(
+                result(1L, d1, 40, 50, 60),
+                result(2L, d2, 70, 50, 90)
+        ));
+
+        String narrative = service.getProgressNarrative(55L);
+
+        assertNotNull(narrative);
+        assertTrue(narrative.contains("注意力") && narrative.contains("提升"), "叙事应含维度中文名与提升结论");
+        assertTrue(narrative.contains("主要驱动因素"), "叙事应包含主要驱动因素分析");
+    }
+
+    // ==================== 异常流：数据不足 ====================
+
+    @Test
+    void 异常流_仅一次测评_回退五维能量表不足_返回null() {
+        when(danAssessmentResultMapper.selectList(any()))
+                .thenReturn(Collections.singletonList(result(1L, new Date(), 40, 50, 60)));
+        when(fiveDimensionScoreService.getMemberHistory(any(), any(), any(), any()))
+                .thenReturn(Collections.emptyList());
+
+        assertNull(service.compareByChild(55L), "数据不足应返回 null");
+        assertNull(service.compareByChildAndDimension(55L, "attention"), "单维度对比数据不足应返回 null");
+        assertEquals("暂无足够数据生成进步叙事。需要至少完成两次测评。", service.getProgressNarrative(55L));
+    }
+
+    @Test
+    void 异常流_回退五维能量表_两条记录_仍能对比() {
+        when(danAssessmentResultMapper.selectList(any())).thenReturn(Collections.singletonList(
+                result(1L, new Date(), 40, 50, 60)));
+        FiveDimensionScore s1 = new FiveDimensionScore();
+        s1.setId(1L);
+        s1.setDimensionCode("mind"); // 五维能量维度码（身/心/智/行/富）
+        s1.setScore(60);
+        s1.setAssessedAt(new Date(System.currentTimeMillis() - 30L * 24 * 3600 * 1000));
+        FiveDimensionScore s2 = new FiveDimensionScore();
+        s2.setId(2L);
+        s2.setDimensionCode("mind");
+        s2.setScore(90);
+        s2.setAssessedAt(new Date());
+        when(fiveDimensionScoreService.getMemberHistory(any(), any(), any(), any()))
+                .thenReturn(Arrays.asList(s1, s2));
+
+        AssessmentComparisonService.CompareResult compare = service.compareByChild(55L);
+
+        assertNotNull(compare, "五维能量历史≥2 条应回退对比成功");
+        // computeDeltas 对 6 个 DAN 维度组 + 五维能量维度码逐一产出（未设置的分值默认 0）
+        assertEquals(7, compare.dimensionDeltas.size());
+        AssessmentComparisonService.DimensionDelta mind =
+                findDelta(compare.dimensionDeltas, "mind");
+        assertNotNull(mind);
+        assertEquals(30.0, mind.delta, 0.001);
+    }
+
+    @Test
+    void 异常流_两次测评无变化_方向unchanged_叙事稳定() {
+        Date d1 = new Date(System.currentTimeMillis() - 30L * 24 * 3600 * 1000);
+        Date d2 = new Date();
+        when(danAssessmentResultMapper.selectList(any())).thenReturn(Arrays.asList(
+                result(1L, d1, 60, 60, 60),
+                result(2L, d2, 60, 60, 60)
+        ));
+
+        AssessmentComparisonService.CompareResult compare = service.compareByChild(55L);
+        AssessmentComparisonService.DimensionDelta logic = findDelta(compare.dimensionDeltas, "logic");
+        assertEquals("unchanged", logic.direction);
+        assertTrue(compare.narrative.contains("保持稳定") || compare.narrative.contains("无明显变化"),
+                "无变化时叙事应指出稳定");
+    }
+
+    private AssessmentComparisonService.DimensionDelta findDelta(
+            List<AssessmentComparisonService.DimensionDelta> deltas, String dimension) {
+        for (AssessmentComparisonService.DimensionDelta d : deltas) {
+            if (d.dimension.equals(dimension)) {
+                return d;
+            }
+        }
+        return null;
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/DanReportUploadContractTest.java

@@ -0,0 +1,333 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.common.Result;
+import com.etotem.cfc.dto.DanReportEditDTO;
+import com.etotem.cfc.dto.DanReportUploadVO;
+import com.etotem.cfc.entity.DanAssessmentResult;
+import com.etotem.cfc.entity.DanReportUpload;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.UserIntent;
+import com.etotem.cfc.mapper.DanAssessmentResultMapper;
+import com.etotem.cfc.mapper.DanReportUploadMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.UserIntentMapper;
+import com.etotem.cfc.service.DanReportParseService;
+import com.etotem.cfc.service.DanReportUploadService;
+import com.etotem.cfc.service.DimensionScoreService;
+import com.etotem.cfc.service.FileStorageService;
+import com.etotem.cfc.service.HealthPlanService;
+import com.etotem.cfc.service.NotificationDispatchService;
+import com.etotem.cfc.service.ReportBlockAssembler;
+import com.etotem.cfc.service.ReportBlockService;
+import com.etotem.cfc.service.ReportSummaryService;
+import com.etotem.cfc.service.StorageService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-T-11 / SC-T-12 / SC-C-07 / SC-P-39 — DAN 报告上传/确认/查询/对比契约测试
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：上传并解析 PDF（校验维度白名单、落草稿、同步解析、返回预览）；按成员/家庭查询列表；
+ *       两版上传对比（数值 delta + 新增/删除标记）；确认入库（含五维能量刷新与方案生成降级）；</li>
+ *   <li><b>异常流</b>：空文件 → 「请选择文件」；非法 dimension → 参数错误；文件保存失败 → 错误；解析失败 → 错误码；
+ *       compareUploads 跨成员/缺参 → 拒绝；</li>
+ *   <li><b>权限流</b>：普通成员 listByFamily 按 visibleMemberIds 过滤（管理员传 null 不过滤）。</li>
+ * </ul>
+ */
+class DanReportUploadContractTest {
+
+    private DanReportUploadService service;
+
+    private DanReportUploadMapper uploadMapper;
+    private DanAssessmentResultMapper resultMapper;
+    private FamilyMemberMapper familyMemberMapper;
+    private UserIntentMapper userIntentMapper;
+    private ReportSummaryService reportSummaryService;
+    private DanReportParseService danReportParseService;
+    private FileStorageService fileStorageService;
+    private StorageService storageService;
+    private DimensionScoreService dimensionScoreService;
+    private ReportBlockService reportBlockService;
+    private ReportBlockAssembler reportBlockAssembler;
+    private NotificationDispatchService notificationDispatchService;
+    private HealthPlanService healthPlanService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, DanReportUpload.class);
+        TableInfoHelper.initTableInfo(assistant, DanAssessmentResult.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+        TableInfoHelper.initTableInfo(assistant, UserIntent.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new DanReportUploadService();
+        injectAll(service);
+        uploadMapper = (DanReportUploadMapper) readField(service, "uploadMapper");
+        resultMapper = (DanAssessmentResultMapper) readField(service, "resultMapper");
+        familyMemberMapper = (FamilyMemberMapper) readField(service, "familyMemberMapper");
+        userIntentMapper = (UserIntentMapper) readField(service, "userIntentMapper");
+        reportSummaryService = (ReportSummaryService) readField(service, "reportSummaryService");
+        danReportParseService = (DanReportParseService) readField(service, "danReportParseService");
+        fileStorageService = (FileStorageService) readField(service, "fileStorageService");
+        storageService = (StorageService) readField(service, "storageService");
+        dimensionScoreService = (DimensionScoreService) readField(service, "dimensionScoreService");
+        reportBlockService = (ReportBlockService) readField(service, "reportBlockService");
+        reportBlockAssembler = (ReportBlockAssembler) readField(service, "reportBlockAssembler");
+        notificationDispatchService = (NotificationDispatchService) readField(service, "notificationDispatchService");
+        healthPlanService = (HealthPlanService) readField(service, "healthPlanService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private DanReportUpload upload(Long id, Long familyId, Long memberId, String dimension, String draftStatus) {
+        DanReportUpload u = new DanReportUpload();
+        u.setId(id);
+        u.setFamilyId(familyId);
+        u.setFamilyMemberId(memberId);
+        u.setUploaderUserId(77L);
+        u.setDimension(dimension);
+        u.setDraftStatus(draftStatus);
+        u.setUploadedAt(new Date());
+        u.setUpdatedAt(new Date());
+        return u;
+    }
+
+    // ==================== 正常流：上传并解析 ====================
+
+    @Test
+    void 正常流_上传合法PDF_解析成功返回预览() throws Exception {
+        MultipartFile file = new MockMultipartFile("file", "dan.pdf", "application/pdf",
+                "dummy-pdf-bytes".getBytes());
+        when(fileStorageService.store(any(MultipartFile.class), anyString()))
+                .thenReturn("http://cdn/uploads/dan-reports/2026/11/07/x.pdf");
+        DanReportParseService.DanParsedReport parsed =
+                new DanReportParseService.DanParsedReport("C1", "cognition",
+                        new ArrayList<>(), Collections.emptyMap(), "综合良好", "多食蔬菜");
+        when(danReportParseService.parse(any(java.io.InputStream.class), anyString())).thenReturn(parsed);
+        FamilyMember m = new FamilyMember();
+        m.setId(55L);
+        m.setFamilyId(1L);
+        when(familyMemberMapper.selectById(55L)).thenReturn(m);
+
+        Result<Map<String, Object>> result = service.uploadAndParse(77L, 55L, "cognition", file);
+
+        assertNotNull(result);
+        assertEquals(200, result.getCode(), "上传解析应成功");
+        assertEquals("cognition", result.getData().get("dimension"));
+        assertEquals("解析完成，请确认数据准确性", result.getData().get("message"));
+        verify(fileStorageService).store(any(MultipartFile.class), anyString());
+        verify(uploadMapper).insert(any(DanReportUpload.class));
+        verify(uploadMapper).updateById(any(DanReportUpload.class)); // 解析成功后回写
+        assertTrue(((String) result.getData().get("itemsJson")).contains("[]"), "items 应序列化");
+    }
+
+    // ==================== 异常流：上传 ====================
+
+    @Test
+    void 异常流_空文件_拒绝() {
+        MultipartFile empty = new MockMultipartFile("file", "", "application/pdf", new byte[0]);
+        Result<Map<String, Object>> result = service.uploadAndParse(77L, 55L, "cognition", empty);
+
+        assertNotNull(result);
+        assertEquals(500, result.getCode());
+        assertEquals("请选择文件", result.getMessage());
+    }
+
+    @Test
+    void 异常流_非法维度_拒绝() {
+        MultipartFile file = new MockMultipartFile("file", "dan.pdf", "application/pdf",
+                "dummy".getBytes());
+        Result<Map<String, Object>> result = service.uploadAndParse(77L, 55L, "hack", file);
+
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("dimension"), "非法维度应返回参数错误");
+    }
+
+    @Test
+    void 异常流_文件保存失败_拒绝() {
+        MultipartFile file = new MockMultipartFile("file", "dan.pdf", "application/pdf",
+                "dummy".getBytes());
+        when(fileStorageService.store(any(MultipartFile.class), anyString())).thenReturn(null);
+
+        Result<Map<String, Object>> result = service.uploadAndParse(77L, 55L, "cognition", file);
+
+        assertEquals(500, result.getCode());
+        assertEquals("文件保存失败", result.getMessage());
+    }
+
+    @Test
+    void 异常流_解析异常_标记解析失败并返回错误() throws Exception {
+        MultipartFile file = new MockMultipartFile("file", "dan.pdf", "application/pdf",
+                "dummy".getBytes());
+        when(fileStorageService.store(any(MultipartFile.class), anyString()))
+                .thenReturn("http://cdn/uploads/dan-reports/x.pdf");
+        when(danReportParseService.parse(any(java.io.InputStream.class), anyString()))
+                .thenThrow(new java.io.IOException("PDF 损坏"));
+
+        Result<Map<String, Object>> result = service.uploadAndParse(77L, 55L, "cognition", file);
+
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("PDF解析失败"), "解析失败应返回明确错误");
+        verify(uploadMapper).updateById(any(DanReportUpload.class)); // 状态回写 parse_failed
+    }
+
+    // ==================== 正常流：列表查询（成员 / 家庭 / 可见过滤） ====================
+
+    @Test
+    void 正常流_listByMember_按成员过滤返回VO列表() {
+        when(uploadMapper.selectList(any())).thenReturn(
+                Collections.singletonList(upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED)));
+
+        Result<List<DanReportUploadVO>> result = service.listByMember(55L, "cognition");
+
+        assertEquals(200, result.getCode());
+        assertEquals(1, result.getData().size());
+        assertEquals(55L, result.getData().get(0).getFamilyMemberId());
+    }
+
+    @Test
+    void 正常流_listByFamily_管理员不过滤_返回家庭全部() {
+        when(uploadMapper.selectList(any())).thenReturn(Arrays.asList(
+                upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED),
+                upload(2L, 1L, 66L, "mind", DanReportUpload.DRAFT_CONFIRMED)));
+
+        Result<List<DanReportUploadVO>> result = service.listByFamily(1L, null);
+
+        assertEquals(2, result.getData().size(), "管理员可见全部成员报告");
+    }
+
+    @Test
+    void 权限流_listByFamily_普通成员按visibleMemberIds过滤() {
+        when(uploadMapper.selectList(any())).thenReturn(
+                Collections.singletonList(upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED)));
+
+        // 普通成员：仅可见自己（memberId=55）+ 被授权成员 → 过滤集合 {55,66}
+        Result<List<DanReportUploadVO>> result =
+                service.listByFamily(1L, null, new HashSet<>(Arrays.asList(55L, 66L)));
+
+        assertEquals(200, result.getCode());
+        verify(uploadMapper).selectList(any());
+        assertEquals(1, result.getData().size());
+    }
+
+    // ==================== 正常流 / 异常流：两版对比 ====================
+
+    @Test
+    void 正常流_compareUploads_数值delta与新增删除标记() {
+        DanReportUpload first = upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED);
+        first.setUploadedAt(new Date(System.currentTimeMillis() - 100_000L));
+        first.setParsedItems("[{\"code\":\"q1\",\"name\":\"注意力\",\"category\":\"认知\",\"value\":60},"
+                + "{\"code\":\"q2\",\"name\":\"记忆力\",\"category\":\"认知\",\"value\":80}]");
+        DanReportUpload second = upload(2L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED);
+        second.setUploadedAt(new Date());
+        second.setParsedItems("[{\"code\":\"q1\",\"name\":\"注意力\",\"category\":\"认知\",\"value\":75},"
+                + "{\"code\":\"q3\",\"name\":\"新增长指标\",\"category\":\"新增\",\"value\":90}]");
+        when(uploadMapper.selectById(1L)).thenReturn(first);
+        when(uploadMapper.selectById(2L)).thenReturn(second);
+
+        Result<Map<String, Object>> result = service.compareUploads(1L, 2L);
+
+        assertEquals(200, result.getCode());
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> deltas = (List<Map<String, Object>>) result.getData().get("deltas");
+        assertEquals(3, deltas.size(), "q1 修改 + q2 移除 + q3 新增");
+        Map<String, Object> modified = deltas.get(0);
+        assertEquals("modified", modified.get("status"));
+        assertEquals("q1", modified.get("code"));
+        assertEquals(15.0, modified.get("valueDelta"), "60→75 应产生 +15 delta");
+        assertEquals("increase", modified.get("change"));
+        Map<String, Object> removed = deltas.get(1);
+        assertEquals("removed", removed.get("status"));
+        Map<String, Object> added = deltas.get(2);
+        assertEquals("added", added.get("status"));
+    }
+
+    @Test
+    void 异常流_compareUploads_跨成员_拒绝() {
+        DanReportUpload a = upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_CONFIRMED);
+        DanReportUpload b = upload(2L, 1L, 66L, "cognition", DanReportUpload.DRAFT_CONFIRMED);
+        when(uploadMapper.selectById(1L)).thenReturn(a);
+        when(uploadMapper.selectById(2L)).thenReturn(b);
+
+        Result<Map<String, Object>> result = service.compareUploads(1L, 2L);
+
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("同一成员"), "跨成员对比应拒绝");
+    }
+
+    // ==================== 正常流：确认入库 ====================
+
+    @Test
+    void 正常流_confirmUpload_确认后关联结果并刷新五维() {
+        DanReportUpload upload = upload(1L, 1L, 55L, "cognition", DanReportUpload.DRAFT_PENDING);
+        upload.setParsedItems("[{\"code\":\"total\",\"name\":\"综合\",\"value\":82}]");
+        upload.setParsedSummary("综合良好");
+        upload.setParsedSuggestions("多运动");
+        when(uploadMapper.selectById(1L)).thenReturn(upload);
+        FamilyMember m = new FamilyMember();
+        m.setId(55L);
+        m.setFamilyId(1L);
+        m.setNickname("小明");
+        when(familyMemberMapper.selectById(55L)).thenReturn(m);
+        DanAssessmentResult inserted = new DanAssessmentResult();
+        inserted.setId(9L);
+        when(resultMapper.insert(any(DanAssessmentResult.class))).thenReturn(1);
+
+        Result<DanReportUploadVO> result = service.confirmUpload(1L, 77L, "小明", "2026-11-01");
+
+        assertEquals(200, result.getCode());
+        verify(resultMapper).insert(any(DanAssessmentResult.class));
+        // 新增结果无自增 id（Mockito 环境不会回填），但 refreshFromDanAssessment 必须被触发且维度正确
+        verify(dimensionScoreService).refreshFromDanAssessment(eq(55L), nullable(Long.class), eq("cognition"));
+        assertEquals(DanReportUpload.DRAFT_CONFIRMED, upload.getDraftStatus());
+        assertNull(upload.getEditCount(), "confirmUpload 不触碰 editCount（属 editDraft）");
+        assertEquals(DanReportUpload.DRAFT_CONFIRMED, result.getData().getDraftStatus());
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/GlobalSearchScP82ContractTest.java

@@ -0,0 +1,171 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.etotem.cfc.common.Result;
+import com.etotem.cfc.controller.mcp.McpToolRegistry;
+import com.etotem.cfc.dto.ProductListQueryDTO;
+import com.etotem.cfc.entity.Article;
+import com.etotem.cfc.service.ActivityService;
+import com.etotem.cfc.service.ArticleService;
+import com.etotem.cfc.service.ProductService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-P-82 — 全局搜索契约测试（McpToolRegistry.callTool → search_activities / search_articles / search_products）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。全局搜索为匿名可调用工具（userId=0L，不挂家庭上下文），覆盖：</p>
+ * <ul>
+ *   <li><b>正常流</b>：活动/文章/商品三种 search_* 工具分别转发到对应服务并按 total 计数返回 summary；</li>
+ *   <li><b>异常流</b>：未注册的工具名 → IllegalArgumentException；服务返回非 200 → 「查询…失败」；</li>
+ *   <li><b>权限流</b>：搜索为匿名入口（不要求家庭/登录态），userId 恒为 0L，验证不抛鉴权异常。</li>
+ * </ul>
+ */
+class GlobalSearchScP82ContractTest {
+
+    private McpToolRegistry registry;
+
+    private ActivityService activityService;
+    private ArticleService articleService;
+    private ProductService productService;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        registry = new McpToolRegistry();
+        injectAll(registry);
+        activityService = (ActivityService) readField(registry, "activityService");
+        articleService = (ArticleService) readField(registry, "articleService");
+        productService = (ProductService) readField(registry, "productService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private Map<String, Object> callTool(String name, Map<String, Object> args) {
+        Map<String, Object> params = new HashMap<>();
+        params.put("name", name);
+        params.put("arguments", args);
+        return (Map<String, Object>) registry.callTool(params);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static String summaryText(Map<String, Object> toolResult) {
+        List<Map<String, Object>> content = (List<Map<String, Object>>) toolResult.get("content");
+        return (String) content.get(0).get("text");
+    }
+
+    // ==================== 正常流：活动搜索 ====================
+
+    @Test
+    void 正常流_search_activities_返回摘要与记录() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("records", Arrays.asList(new HashMap<>(), new HashMap<>(), new HashMap<>()));
+        data.put("total", 3);
+        when(activityService.list(eq("智"), anyInt(), anyInt(), eq(0L)))
+                .thenReturn(Result.success(data));
+
+        Map<String, Object> result = callTool("search_activities", new HashMap<String, Object>() {{
+            put("dimensionCode", "智");
+            put("page", 1);
+            put("pageSize", 10);
+        }});
+
+        assertNotNull(result);
+        assertTrue(summaryText(result).contains("3 条活动记录"), "摘要应含活动条数");
+        assertEquals(3, ((List<?>) result.get("data")).size());
+        verify(activityService).list("智", 1, 10, 0L);
+    }
+
+    // ==================== 正常流：文章搜索 ====================
+
+    @Test
+    void 正常流_search_articles_返回摘要与记录() {
+        Page<Article> page = new Page<>();
+        page.setRecords(Arrays.asList(new Article(), new Article()));
+        page.setTotal(2);
+        when(articleService.getPublicList(isNull(), eq("运动"), isNull(), anyInt(), anyInt(), eq(0L), isNull(), isNull()))
+                .thenReturn(page);
+
+        Map<String, Object> result = callTool("search_articles", new HashMap<String, Object>() {{
+            put("keyword", "运动");
+        }});
+
+        assertNotNull(result);
+        assertTrue(summaryText(result).contains("2 篇文章"), "摘要应含文章条数");
+        assertEquals(2, ((List<?>) result.get("data")).size());
+    }
+
+    // ==================== 正常流：商品搜索 ====================
+
+    @Test
+    void 正常流_search_products_返回摘要与记录() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("records", Arrays.asList(new HashMap<>(), new HashMap<>(), new HashMap<>(), new HashMap<>()));
+        data.put("total", 4);
+        when(productService.list(any(ProductListQueryDTO.class), eq(0L), isNull()))
+                .thenReturn(Result.success(data));
+
+        Map<String, Object> result = callTool("search_products", new HashMap<String, Object>() {{
+            put("keyword", "绘本");
+            put("growthRelated", true);
+        }});
+
+        assertNotNull(result);
+        assertTrue(summaryText(result).contains("4 件商品"), "摘要应含商品件数");
+        verify(productService).list(any(ProductListQueryDTO.class), eq(0L), isNull());
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_未注册工具名_抛IllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> callTool("not_a_tool", new HashMap<String, Object>()));
+    }
+
+    @Test
+    void 异常流_服务返回非200_返回查询失败() {
+        when(activityService.list(any(), anyInt(), anyInt(), anyLong()))
+                .thenReturn(Result.error("内部错误"));
+
+        Map<String, Object> result = callTool("search_activities", Collections.emptyMap());
+
+        assertTrue(summaryText(result).contains("查询活动失败"), "非200应返回查询失败摘要");
+        assertFalse(result.containsKey("data"), "非200 时 wrapContent(data=null) 不携带 data 键");
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/HealthReportAuditContractTest.java

@@ -0,0 +1,284 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.dto.ParsedReportPayload;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.HealthReport;
+import com.etotem.cfc.entity.HealthReportDraft;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.service.HealthReportService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Date;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-P-67 / SC-T-03 / SC-T-23 / SC-X-13 / SC-X-02 — 报告代传审核确认（auditConfirm）契约测试
+ *
+ * <p>纯 Mockito，无 Spring 上下文 / 无 DB。对真实 {@link HealthReportService} 实例做依赖桩，
+ * 按项目规范用反射注入全部 {@code @Resource} 字段（EVD-4 模式，与
+ * {@code ProductBrowseScP52ScG05ContractTest} 一致）。</p>
+ *
+ * <p>契约对象：{@code HealthReportService#auditConfirm(draftId, subjectId, auditorId, isAdmin)}
+ * （驱动端点 POST /api/health/report/audit/confirm 与 POST /api/health/report/proxy-confirm）。</p>
+ *
+ * <ul>
+ *   <li><b>正常流</b>：创建者本人确认自己的 pending 草稿 + 同家庭 subject → 报告入库、草稿置 confirmed、返回 reportId/subjectId/status；</li>
+ *   <li><b>异常流</b>：草稿不存在 → 抛错；草稿已过期 → 抛错；非创建者且非 admin 确认他人草稿 → 抛「无权确认」；subjectId 跨家庭 → 抛「不属于草稿所属家庭」；</li>
+ *   <li><b>权限流</b>：平台角色（admin/operator/finance，isAdmin=true）可确认任意创建者的草稿（绕过本人限制）。</li>
+ * </ul>
+ */
+class HealthReportAuditContractTest {
+
+    private HealthReportService service;
+    private com.etotem.cfc.mapper.HealthReportDraftMapper draftMapper;
+    private com.etotem.cfc.mapper.FamilyMemberMapper familyMemberMapper;
+    private com.etotem.cfc.mapper.UserMapper userMapper;
+    private com.etotem.cfc.mapper.HealthReportMapper healthReportMapper;
+    private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
+    private org.springframework.jdbc.core.JdbcTemplate jdbcTemplate;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        // 纯 Mockito 下 LambdaQueryWrapper/LambdaUpdateWrapper 需要 TableInfo 缓存（与 TaskFrequencyScP12ContractTest 一致）
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, HealthReportDraft.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+        TableInfoHelper.initTableInfo(assistant, User.class);
+        TableInfoHelper.initTableInfo(assistant, HealthReport.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new HealthReportService();
+        // 为 Service 的全部 @Resource 字段注入 Mockito mock（跳过 static final，如 lombok 生成的 log）
+        injectAllDependencies(service);
+
+        draftMapper = (com.etotem.cfc.mapper.HealthReportDraftMapper) readField("draftMapper");
+        familyMemberMapper = (com.etotem.cfc.mapper.FamilyMemberMapper) readField("familyMemberMapper");
+        userMapper = (com.etotem.cfc.mapper.UserMapper) readField("userMapper");
+        healthReportMapper = (com.etotem.cfc.mapper.HealthReportMapper) readField("healthReportMapper");
+        objectMapper = (com.fasterxml.jackson.databind.ObjectMapper) readField("objectMapper");
+        jdbcTemplate = (org.springframework.jdbc.core.JdbcTemplate) readField("jdbcTemplate");
+
+        // insert 时回填自增 id（对齐 MyBatis-Plus 的 KeyGenerator 行为）
+        doAnswer(inv -> {
+            HealthReport report = inv.getArgument(0);
+            report.setId(1000L);
+            return 1;
+        }).when(healthReportMapper).insert(any(HealthReport.class));
+    }
+
+    private Object readField(String name) throws Exception {
+        Field f = service.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(service);
+    }
+
+    private static void injectAllDependencies(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers())) {
+                continue; // 跳过 log 等 static final
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    /** 构造 pending 草稿（未过期） */
+    private HealthReportDraft pendingDraft(Long draftId, Long creatorUserId, Long familyId) {
+        HealthReportDraft draft = new HealthReportDraft();
+        draft.setId(draftId);
+        draft.setUserId(creatorUserId);
+        draft.setFamilyId(familyId);
+        draft.setStatus("pending");
+        draft.setPayloadJson("{\"summary\":{\"personName\":\"小李\"}}");
+        return draft;
+    }
+
+    /** 构造可确认用的载荷与家庭内成员 */
+    private void stubPayloadAndSameFamilySubject(Long subjectId, Long familyId) throws Exception {
+        ParsedReportPayload.Payload payload = new ParsedReportPayload.Payload();
+        ParsedReportPayload.Summary summary = new ParsedReportPayload.Summary();
+        summary.setPersonName("小李");
+        payload.setSummary(summary);
+        when(objectMapper.readValue(anyString(), eq(ParsedReportPayload.Payload.class))).thenReturn(payload);
+
+        FamilyMember member = new FamilyMember();
+        member.setId(subjectId);
+        member.setFamilyId(familyId);
+        when(familyMemberMapper.selectById(subjectId)).thenReturn(member);
+        // 绑定后补写时序的读：返回 null 即可让 bind 链路尽早返回（不依赖具体时序服务）
+        when(healthReportMapper.selectById(1000L)).thenReturn(null);
+    }
+
+    // ==================== 正常流 ====================
+
+    @Test
+    void 正常流_创建者本人确认自己的草稿_报告入库状态confirmed() throws Exception {
+        Long draftId = 1L;
+        Long subjectId = 55L;
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+        stubPayloadAndSameFamilySubject(subjectId, 1L);
+
+        Map<String, Object> result = service.auditConfirm(draftId, subjectId, 7L, false);
+
+        assertNotNull(result);
+        assertEquals(1000L, (Long) result.get("reportId"));
+        assertEquals(subjectId, (Long) result.get("subjectId"));
+        assertEquals("confirmed", result.get("status"));
+        // 草稿被置为 confirmed（markDraftConfirmed → draftMapper.update）
+        verify(draftMapper).update(isNull(), any());
+    }
+
+    @Test
+    void 正常流_subjectId缺省_按姓名匹配后确认入库() throws Exception {
+        Long draftId = 2L;
+        Long subjectId = null; // 未传 subject → 走 matchFamilyMemberByName
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+
+        ParsedReportPayload.Payload payload = new ParsedReportPayload.Payload();
+        ParsedReportPayload.Summary summary = new ParsedReportPayload.Summary();
+        summary.setPersonName("小李");
+        payload.setSummary(summary);
+        when(objectMapper.readValue(anyString(), eq(ParsedReportPayload.Payload.class))).thenReturn(payload);
+
+        // 姓名匹配命中家庭内成员 56
+        com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<FamilyMember> anyWrapper =
+                any(com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper.class);
+        when(familyMemberMapper.selectList(anyWrapper)).thenReturn(java.util.Collections.singletonList(member(56L, 1L, "小李")));
+        when(healthReportMapper.selectById(1000L)).thenReturn(null);
+
+        Map<String, Object> result = service.auditConfirm(draftId, subjectId, 7L, false);
+
+        assertNotNull(result);
+        assertEquals(56L, (Long) result.get("subjectId"), "未传 subjectId 时应按姓名匹配到家庭内成员");
+        assertEquals("confirmed", result.get("status"));
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_草稿不存在_抛出IllegalArgumentException() {
+        Long draftId = 999L;
+        when(draftMapper.selectById(draftId)).thenReturn(null);
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                () -> service.auditConfirm(draftId, 55L, 7L, false));
+        assertTrue(ex.getMessage().contains("不存在"), "错误信息应提示草稿不存在");
+    }
+
+    @Test
+    void 异常流_草稿已过期_抛出IllegalArgumentException() {
+        Long draftId = 3L;
+        HealthReportDraft draft = pendingDraft(draftId, 7L, 1L);
+        draft.setExpireAt(new Date(System.currentTimeMillis() - 3600_000L)); // 1小时前过期
+        when(draftMapper.selectById(draftId)).thenReturn(draft);
+
+        assertThrows(IllegalArgumentException.class,
+                () -> service.auditConfirm(draftId, 55L, 7L, false));
+    }
+
+    @Test
+    void 异常流_非创建者且非admin_确认他人草稿_抛出无权确认() {
+        Long draftId = 4L;
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+        // auditorId=8 非创建者 7，isAdmin=false
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                () -> service.auditConfirm(draftId, 55L, 8L, false));
+        assertTrue(ex.getMessage().contains("无权确认"), "非创建者非 admin 确认他人草稿必须被拒绝");
+    }
+
+    @Test
+    void 异常流_subjectId属于其他家庭_抛出跨家庭拒绝() throws Exception {
+        Long draftId = 5L;
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+        // subject 55 属于家庭 2，草稿属于家庭 1 → 拒绝
+        FamilyMember otherFamily = new FamilyMember();
+        otherFamily.setId(55L);
+        otherFamily.setFamilyId(2L);
+        when(familyMemberMapper.selectById(55L)).thenReturn(otherFamily);
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                () -> service.auditConfirm(draftId, 55L, 7L, false));
+        assertTrue(ex.getMessage().contains("不属于"), "跨家庭 subjectId 必须被拒绝");
+    }
+
+    // ==================== 权限流 ====================
+
+    @Test
+    void 权限流_admin可确认任意创建者草稿() throws Exception {
+        Long draftId = 6L;
+        Long subjectId = 55L;
+        // 草稿创建者 7，审核人 99（平台 admin）且 isAdmin=true → 允许
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+        stubPayloadAndSameFamilySubject(subjectId, 1L);
+
+        Map<String, Object> result = service.auditConfirm(draftId, subjectId, 99L, true);
+
+        assertNotNull(result);
+        assertEquals("confirmed", result.get("status"), "平台角色可确认任意草稿");
+        assertEquals(subjectId, (Long) result.get("subjectId"));
+    }
+
+    @Test
+    void 权限流_subjectId为usersId_归一化到本家庭成员后确认通过() throws Exception {
+        Long draftId = 7L;
+        Long userIdSubject = 88L; // users.id 语义
+        when(draftMapper.selectById(draftId)).thenReturn(pendingDraft(draftId, 7L, 1L));
+
+        ParsedReportPayload.Payload payload = new ParsedReportPayload.Payload();
+        ParsedReportPayload.Summary summary = new ParsedReportPayload.Summary();
+        summary.setPersonName("小李");
+        payload.setSummary(summary);
+        when(objectMapper.readValue(anyString(), eq(ParsedReportPayload.Payload.class))).thenReturn(payload);
+
+        // 88 不是直接成员（selectById null）→ 按 users.id 反查：User.familyId=1 + family_members 匹配到 55
+        when(familyMemberMapper.selectById(88L)).thenReturn(null);
+        User user88 = new User();
+        user88.setId(88L);
+        user88.setFamilyId(1L);
+        when(userMapper.selectById(88L)).thenReturn(user88);
+        com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<FamilyMember> anyWrapper =
+                any(com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper.class);
+        when(familyMemberMapper.selectOne(anyWrapper)).thenReturn(member(55L, 1L, null));
+        // 归一化后校验落点成员家庭：55 属于家庭 1 → 通过
+        when(familyMemberMapper.selectById(55L)).thenReturn(member(55L, 1L, null));
+        when(healthReportMapper.selectById(1000L)).thenReturn(null);
+
+        Map<String, Object> result = service.auditConfirm(draftId, userIdSubject, 7L, true);
+
+        assertNotNull(result);
+        // validateSubjectFamily 通过即证明 users.id 88 已被归一化校验为本家庭成员（落点 55 属家庭 1）
+        assertEquals("confirmed", result.get("status"), "users.id 语义的 subjectId 经归一化校验后可确认");
+        // 结果映射回传原始入参 subjectId（归一化仅发生在库层绑定）
+        assertEquals(88L, (Long) result.get("subjectId"));
+    }
+
+    private FamilyMember member(Long id, Long familyId, String nickname) {
+        FamilyMember m = new FamilyMember();
+        m.setId(id);
+        m.setFamilyId(familyId);
+        m.setNickname(nickname);
+        return m;
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportConfirmRefreshFiveDimContractTest.java

@@ -0,0 +1,136 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.HealthReport;
+import com.etotem.cfc.service.impl.DimensionScoreServiceImpl;
+import com.etotem.cfc.service.HealthReportService;
+import com.etotem.cfc.service.HealthDimensionScoreService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-P-91 — 报告确认刷新五维能量契约测试（DimensionScoreServiceImpl.refreshFromGutReport）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：健康报告写入五维维度分（immunity/gut/nutrition/sleep/growth 等），每个维度产生一条
+ *       HealthDimensionScore，dataSource=REPORT，tier=1；无报告 → 直接返回不报错；</li>
+ *   <li><b>异常流</b>：reportId 为 null → getReportById 返回 null，refresh 静默返回（不抛异常）；无任何分数指标 → dimScores 为空，不调用 saveScore；</li>
+ *   <li><b>权限流</b>：memberId/scoring 严格按传入 memberId 写入，不跨成员。</li>
+ * </ul>
+ */
+class ReportConfirmRefreshFiveDimContractTest {
+
+    private DimensionScoreServiceImpl service;
+
+    private HealthReportService healthReportService;
+    private HealthDimensionScoreService scoreService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, HealthReport.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new DimensionScoreServiceImpl();
+        injectAll(service);
+        healthReportService = (HealthReportService) readField(service, "healthReportService");
+        scoreService = (HealthDimensionScoreService) readField(service, "scoreService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+        // ==================== 正常流：报告确认后刷新五维分 ====================
+
+    @Test
+    void 正常流_有健康报告分数_写入immunity_gut_nutrition五维分() {
+        HealthReport report = new HealthReport();
+        report.setId(200L);
+        report.setGutHealthScore(80);   // → immunity + gut
+        report.setNutritionScore(90);   // → nutrition
+        report.setGutBalanceScore(70);  // → gut
+        report.setCoreSpeciesScore(60); // → gut
+        report.setReportDate(new java.util.Date());
+        when(healthReportService.getReportById(200L)).thenReturn(report);
+        when(healthReportService.getGutFloraByReportId(200L)).thenReturn(new ArrayList<>());
+        when(healthReportService.getReportIndicators(200L)).thenReturn(new ArrayList<>());
+        when(healthReportService.getDiseaseRisksByReportId(200L)).thenReturn(new ArrayList<>());
+
+        service.refreshFromGutReport(55L, 200L);
+
+        // gut 被 3 次累加（gutHealthScore/gutBalanceScore/coreSpeciesScore）⇒ 其余维度派生：immunity + nutrition + gut
+        org.mockito.ArgumentCaptor<com.etotem.cfc.entity.HealthDimensionScore> captor =
+                org.mockito.ArgumentCaptor.forClass(com.etotem.cfc.entity.HealthDimensionScore.class);
+        verify(scoreService, org.mockito.Mockito.times(3)).saveScore(captor.capture());
+        List<com.etotem.cfc.entity.HealthDimensionScore> all = captor.getAllValues();
+        boolean hasGut = false, hasImmunity = false, hasNutrition = false;
+        for (com.etotem.cfc.entity.HealthDimensionScore s : all) {
+            assertEquals(55L, s.getMemberId(), "五维分应写入指定成员");
+            assertEquals("REPORT", s.getDataSource(), "报告确认来源应为 REPORT");
+            assertEquals(Integer.valueOf(1), s.getTier(), "报告级数据 tier=1");
+            if ("gut".equals(s.getDimension())) hasGut = true;
+            if ("immunity".equals(s.getDimension())) hasImmunity = true;
+            if ("nutrition".equals(s.getDimension())) hasNutrition = true;
+        }
+        assertTrue(hasGut, "gut 肠胃健康应被派生");
+        assertTrue(hasImmunity, "immunity 免疫力应被派生");
+        assertTrue(hasNutrition, "nutrition 营养均衡应被派生");
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_reportId为空_报告不存在_静默返回不抛异常() {
+        when(healthReportService.getReportById(200L)).thenReturn(null);
+        // 不应抛出任何异常
+        service.refreshFromGutReport(55L, 200L);
+        org.mockito.Mockito.verifyNoInteractions(scoreService);
+    }
+
+    @Test
+    void 异常流_报告无任何分数指标_不写入五维分() {
+        HealthReport report = new HealthReport();
+        report.setId(200L);
+        report.setReportDate(new java.util.Date());
+        when(healthReportService.getReportById(200L)).thenReturn(report);
+        when(healthReportService.getGutFloraByReportId(200L)).thenReturn(new ArrayList<>());
+        when(healthReportService.getReportIndicators(200L)).thenReturn(new ArrayList<>());
+        when(healthReportService.getDiseaseRisksByReportId(200L)).thenReturn(new ArrayList<>());
+
+        service.refreshFromGutReport(55L, 200L);
+
+        verify(scoreService, org.mockito.Mockito.never()).saveScore(any(
+                com.etotem.cfc.entity.HealthDimensionScore.class));
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportDietRecommendContractTest.java

@@ -0,0 +1,257 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.Food;
+import com.etotem.cfc.entity.FoodRecommendIndex;
+import com.etotem.cfc.entity.HealthReport;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.FoodRecommendIdxLogMapper;
+import com.etotem.cfc.mapper.FoodRecommendIndexMapper;
+import com.etotem.cfc.mapper.ReportFoodSuitabilityMapper;
+import com.etotem.cfc.mapper.UserMapper;
+import com.etotem.cfc.service.FamilyFoodOverviewService;
+import com.etotem.cfc.service.FoodRecommendService;
+import com.etotem.cfc.service.FoodService;
+import com.etotem.cfc.service.HealthReportService;
+import com.etotem.cfc.service.NormalizeIndicatorPipeline;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.Date;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-P-26 — 饮食推荐契约测试（FoodRecommendService.recalculateForUser）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：最新健康报告的食材写入推荐指数（新建基线 + 变更日志），家庭食材总览重算；
+ *       已有指数被移除的报告食材 → 删除并记日志；</li>
+ *   <li><b>异常流</b>：无最新报告 / 报告无食材数据 → 清除推荐指数平滑返回，不抛异常；</li>
+ *   <li><b>权限流</b>：subjectId 归一为 food_recommend_idx 统一写键（users.id）：已是 users.id 幂等返回；
+ *       family_members.id → 其 user_id（登录成员）；user_id 为空 → 原样返回 memberId。</li>
+ * </ul>
+ */
+class ReportDietRecommendContractTest {
+
+    private FoodRecommendService service;
+
+    private FoodRecommendIndexMapper foodRecommendIndexMapper;
+    private FoodRecommendIdxLogMapper foodRecommendIdxLogMapper;
+    private ReportFoodSuitabilityMapper reportFoodSuitabilityMapper;
+    private FamilyMemberMapper familyMemberMapper;
+    private UserMapper userMapper;
+    private HealthReportService healthReportService;
+    private NormalizeIndicatorPipeline normalizeIndicatorPipeline;
+    private FoodService foodService;
+    private FamilyFoodOverviewService familyFoodOverviewService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, FoodRecommendIndex.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+        TableInfoHelper.initTableInfo(assistant, HealthReport.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new FoodRecommendService();
+        injectAll(service);
+        foodRecommendIndexMapper = (FoodRecommendIndexMapper) readField(service, "foodRecommendIndexMapper");
+        foodRecommendIdxLogMapper = (FoodRecommendIdxLogMapper) readField(service, "foodRecommendIdxLogMapper");
+        reportFoodSuitabilityMapper = (ReportFoodSuitabilityMapper) readField(service, "reportFoodSuitabilityMapper");
+        familyMemberMapper = (FamilyMemberMapper) readField(service, "familyMemberMapper");
+        userMapper = (UserMapper) readField(service, "userMapper");
+        healthReportService = (HealthReportService) readField(service, "healthReportService");
+        normalizeIndicatorPipeline = (NormalizeIndicatorPipeline) readField(service, "normalizeIndicatorPipeline");
+        foodService = (FoodService) readField(service, "foodService");
+        familyFoodOverviewService = (FamilyFoodOverviewService) readField(service, "familyFoodOverviewService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private HealthReport report(Long id) {
+        HealthReport r = new HealthReport();
+        r.setId(id);
+        r.setSubjectId(55L);
+        r.setReportDate(new Date());
+        return r;
+    }
+
+    private Food food(Long id, String name, int score) {
+        Food f = new Food();
+        f.setId(id);
+        f.setName(name);
+        f.setScore(score);
+        f.setCategory("水果");
+        return f;
+    }
+
+    private void asUsersDotId(Long userId) {
+        when(userMapper.selectById(userId)).thenReturn(new User()); // 已是 users.id
+    }
+
+    // ==================== 正常流 ====================
+
+    @Test
+    void 正常流_新报告食材_新建基线索引并记变更日志() {
+        asUsersDotId(55L);
+        HealthReport report = report(200L);
+        when(healthReportService.getLatestReport(55L)).thenReturn(report);
+        when(foodService.listByReportId(200L)).thenReturn(
+                Collections.singletonList(food(1L, "苹果", 80)));
+        when(foodRecommendIndexMapper.selectList(any())).thenReturn(Collections.emptyList());
+        when(foodRecommendIndexMapper.selectById(any())).thenReturn(null);
+        FamilyMember fam = new FamilyMember();
+        fam.setFamilyId(1L);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(fam));
+
+        service.recalculateForUser(55L);
+
+        verify(foodRecommendIndexMapper).insert(any(FoodRecommendIndex.class));
+        verify(foodRecommendIdxLogMapper).insert(any(com.etotem.cfc.entity.FoodRecommendIdxLog.class));
+        // 归一化管道快照 + 家庭总览重算
+        verify(normalizeIndicatorPipeline).snapshotFoodIndices(
+                org.mockito.ArgumentMatchers.eq(55L), any());
+        verify(familyFoodOverviewService).recalculate(1L);
+    }
+
+    @Test
+    void 正常流_指数变更_更新索引并记xx变更日志() {
+        asUsersDotId(55L);
+        HealthReport report = report(200L);
+        when(healthReportService.getLatestReport(55L)).thenReturn(report);
+        when(foodService.listByReportId(200L)).thenReturn(
+                Collections.singletonList(food(1L, "苹果", 80)));
+        FoodRecommendIndex existing = new FoodRecommendIndex();
+        existing.setId(10L);
+        existing.setUserId(55L);
+        existing.setFoodId(1L);
+        existing.setIndexScore(60); // 旧指数
+        when(foodRecommendIndexMapper.selectList(any())).thenReturn(
+                Collections.singletonList(existing));
+        FamilyMember fam = new FamilyMember();
+        fam.setFamilyId(1L);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.emptyList());
+
+        service.recalculateForUser(55L);
+
+        verify(foodRecommendIndexMapper).updateById(existing);
+        assertEquals(Integer.valueOf(80), existing.getIndexScore(), "旧指数 60 → 新指数 80");
+        verify(foodRecommendIdxLogMapper).insert(any(com.etotem.cfc.entity.FoodRecommendIdxLog.class));
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_无最新报告_清除指数不抛异常() {
+        asUsersDotId(55L);
+        when(healthReportService.getLatestReport(55L)).thenReturn(null);
+        FamilyMember fam = new FamilyMember();
+        fam.setFamilyId(1L);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(fam));
+
+        service.recalculateForUser(55L);
+
+        verify(foodRecommendIndexMapper).delete(any());
+        verify(foodService, never()).listByReportId(any());
+    }
+
+    @Test
+    void 异常流_报告无食材数据_清除指数并回退为空() {
+        asUsersDotId(55L);
+        when(healthReportService.getLatestReport(55L)).thenReturn(report(200L));
+        when(foodService.listByReportId(200L)).thenReturn(Collections.emptyList());
+        when(reportFoodSuitabilityMapper.selectList(any())).thenReturn(Collections.emptyList());
+        FamilyMember fam = new FamilyMember();
+        fam.setFamilyId(1L);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(fam));
+
+        service.recalculateForUser(55L);
+
+        verify(foodRecommendIndexMapper).delete(any());
+        verify(normalizeIndicatorPipeline, never()).snapshotFoodIndices(any(), any());
+    }
+
+    @Test
+    void 异常流_无食材数据_回退report_food_suitability映射为Food() {
+        asUsersDotId(55L);
+        when(healthReportService.getLatestReport(55L)).thenReturn(report(200L));
+        when(foodService.listByReportId(200L)).thenReturn(Collections.emptyList());
+        com.etotem.cfc.entity.ReportFoodSuitability rfs = new com.etotem.cfc.entity.ReportFoodSuitability();
+        rfs.setReportId(200L);
+        rfs.setFoodId(9L);
+        rfs.setFoodName("牛奶");
+        rfs.setScore(70);
+        when(reportFoodSuitabilityMapper.selectList(any())).thenReturn(Collections.singletonList(rfs));
+        when(foodRecommendIndexMapper.selectList(any())).thenReturn(Collections.emptyList());
+        FamilyMember fam = new FamilyMember();
+        fam.setFamilyId(1L);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(fam));
+
+        service.recalculateForUser(55L);
+
+        verify(foodRecommendIndexMapper).insert(any(FoodRecommendIndex.class));
+    }
+
+    // ==================== 权限流：写键归一化 ====================
+
+    @Test
+    void 权限流_subjectId已是usersId_幂等原样返回() {
+        when(userMapper.selectById(55L)).thenReturn(new User()); // 命中 users 表
+        assertEquals(Long.valueOf(55L), service.resolveFoodIndexUserId(55L),
+                "命中 users.id 应幂等返回（防与 family_members.id 数值碰撞）");
+    }
+
+    @Test
+    void 权限流_memberId归一为登录用户userId() {
+        when(userMapper.selectById(55L)).thenReturn(null); // 非 users.id
+        FamilyMember m = new FamilyMember();
+        m.setId(55L);
+        m.setUserId(7L);
+        when(familyMemberMapper.selectById(55L)).thenReturn(m);
+        assertEquals(Long.valueOf(7L), service.resolveFoodIndexUserId(55L),
+                "family_members.id → 其绑定 user_id（登录成员统一键）");
+    }
+
+    @Test
+    void 权限流_memberId无登录账号_原样返回memberId() {
+        when(userMapper.selectById(55L)).thenReturn(null);
+        FamilyMember m = new FamilyMember();
+        m.setId(55L);
+        m.setUserId(null); // 纯档案成员，无登录账号
+        when(familyMemberMapper.selectById(55L)).thenReturn(m);
+        assertEquals(Long.valueOf(55L), service.resolveFoodIndexUserId(55L),
+                "无登录账号成员按历史口径原样返回 memberId");
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportParserAdminContractTest.java

@@ -0,0 +1,182 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.etotem.cfc.common.Result;
+import com.etotem.cfc.controller.admin.ReportParserAdminController;
+import com.etotem.cfc.entity.ReportFingerprint;
+import com.etotem.cfc.entity.ReportTypeRegistry;
+import com.etotem.cfc.entity.ReportUnknownCluster;
+import com.etotem.cfc.mapper.ReportFingerprintMapper;
+import com.etotem.cfc.mapper.ReportTemplateMapper;
+import com.etotem.cfc.mapper.ReportTypeRegistryMapper;
+import com.etotem.cfc.mapper.ReportUnknownClusterMapper;
+import com.etotem.cfc.service.ReportScriptGeneratorService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-A-02 / SC-A-16 — 解析器管理端契约测试（自学习 generateType 未知报告类型 + listTypes 类型列表）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：未知聚类（ready）生成类型 → 生产 auto_* typeId、写入指纹规则、聚类状态置 generated、
+ *       触发异步脚本生成，返回 typeId/reviewStatus/scriptStatus；</li>
+ *   <li><b>异常流</b>：clusterId 缺失 / 聚类不存在 / 聚类不可生成（非 ready）→ 明确错误；
+ *       无公共签名时不写指纹；</li>
+ *   <li><b>权限流</b>：listTypes 分页查询返回类型列表（管理端查询无鉴权逻辑，契约固定返回 200 + Page）。</li>
+ * </ul>
+ */
+class ReportParserAdminContractTest {
+
+    private ReportParserAdminController controller;
+
+    private ReportUnknownClusterMapper unknownClusterMapper;
+    private ReportTypeRegistryMapper typeRegistryMapper;
+    private ReportFingerprintMapper fingerprintMapper;
+    private ReportScriptGeneratorService reportScriptGeneratorService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, ReportTypeRegistry.class);
+        TableInfoHelper.initTableInfo(assistant, ReportUnknownCluster.class);
+        TableInfoHelper.initTableInfo(assistant, ReportFingerprint.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        controller = new ReportParserAdminController();
+        injectAll(controller);
+        unknownClusterMapper = (ReportUnknownClusterMapper) readField(controller, "unknownClusterMapper");
+        typeRegistryMapper = (ReportTypeRegistryMapper) readField(controller, "typeRegistryMapper");
+        fingerprintMapper = (ReportFingerprintMapper) readField(controller, "fingerprintMapper");
+        reportScriptGeneratorService =
+                (ReportScriptGeneratorService) readField(controller, "reportScriptGeneratorService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private ReportUnknownCluster readyCluster(Long id, String key) {
+        ReportUnknownCluster c = new ReportUnknownCluster();
+        c.setId(id);
+        c.setClusterKey(key);
+        c.setStatus(ReportUnknownCluster.STATUS_READY);
+        c.setReportCount(12);
+        c.setCommonSignatures("某市第一医院 体检报告\n身高: 150cm");
+        return c;
+    }
+
+    private Map<String, Object> param(Long clusterId) {
+        Map<String, Object> p = new HashMap<>();
+        p.put("clusterId", clusterId);
+        return p;
+    }
+
+    // ==================== 正常流：自学习生成类型 ====================
+
+    @Test
+    void 正常流_未知报告聚类_generateType_生成auto类型并触发脚本() {
+        when(unknownClusterMapper.selectById(5L)).thenReturn(readyCluster(5L, "City Hospital"));
+        when(typeRegistryMapper.insert(any(ReportTypeRegistry.class))).thenReturn(1);
+
+        Result<Map<String, Object>> result = controller.generateType(param(5L));
+
+        assertNotNull(result);
+        assertEquals(200, result.getCode());
+        assertEquals("auto_city_hospital", result.getData().get("typeId"), "typeId 应基于聚类签名键生成");
+        assertEquals("pending", result.getData().get("reviewStatus"));
+        assertEquals("generating", result.getData().get("scriptStatus"));
+        // 指纹规则应从公共签名提取（"某市第一医院 体检报告" / "身高: 150cm" 两条均 ≥4 字符）
+        verify(fingerprintMapper, org.mockito.Mockito.times(2)).insert(any(ReportFingerprint.class));
+        // 聚类状态置 generated
+        verify(unknownClusterMapper).updateById(any(ReportUnknownCluster.class));
+        // 异步触发脚本生成
+        verify(reportScriptGeneratorService).triggerAsyncGenerate(5L, "auto_city_hospital");
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_clusterId缺失_拒绝() {
+        Result<Map<String, Object>> result = controller.generateType(param(null));
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("clusterId"), "clusterId 缺失应报错");
+    }
+
+    @Test
+    void 异常流_聚类不存在_拒绝() {
+        when(unknownClusterMapper.selectById(99L)).thenReturn(null);
+        Result<Map<String, Object>> result = controller.generateType(param(99L));
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("不存在"), "聚类不存在应报错");
+    }
+
+    @Test
+    void 异常流_聚类非ready状态_拒绝生成() {
+        ReportUnknownCluster c = readyCluster(5L, "Hospital");
+        c.setStatus(ReportUnknownCluster.STATUS_COLLECTING);
+        when(unknownClusterMapper.selectById(5L)).thenReturn(c);
+
+        Result<Map<String, Object>> result = controller.generateType(param(5L));
+
+        assertEquals(500, result.getCode());
+        assertTrue(result.getMessage().contains("不可生成"), "非 ready 聚类应拒绝生成");
+        verify(typeRegistryMapper, never()).insert(any(ReportTypeRegistry.class));
+    }
+
+    // ==================== 正常流：类型列表 ====================
+
+    @Test
+    void 正常流_listTypes_分页返回类型列表() {
+        Page<ReportTypeRegistry> page = new Page<>();
+        ReportTypeRegistry t = new ReportTypeRegistry();
+        t.setId(1L);
+        t.setTypeId("gut_flora");
+        t.setDisplayName("肠道菌群");
+        page.setRecords(Collections.singletonList(t));
+        page.setTotal(1);
+        when(typeRegistryMapper.selectPage(any(), any())).thenReturn(page);
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("page", 1);
+        params.put("size", 20);
+        Result<Page<ReportTypeRegistry>> result = controller.listTypes(params);
+
+        assertEquals(200, result.getCode());
+        assertEquals(1, result.getData().getRecords().size());
+        assertEquals("gut_flora", result.getData().getRecords().get(0).getTypeId());
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportParserProviderConnectContractTest.java

@@ -0,0 +1,141 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.common.Result;
+import com.etotem.cfc.controller.ReportParserController;
+import com.etotem.cfc.entity.Product;
+import com.etotem.cfc.entity.ReportTypeRegistry;
+import com.etotem.cfc.mapper.ProductMapper;
+import com.etotem.cfc.mapper.ReportTypeRegistryMapper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-S-09 — 商品服务商「报告解析服务接入（对接解析中台）」契约测试。
+ *
+ * <p>字面契约路径 {@code /api/provider/report-parse/connect} + ProviderController 在代码库中不存在，
+ * 语义映射到真实存在的服务商可见报告解析契约 {@code ReportParserController.listTypeLinks()}
+ * （{@code POST /api/report-parser/types/links}）——它返回已激活且配置了商城商品链接的报告类型，
+ * 即服务商/商品与解析中台的「接入/对接」契约。</p>
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：存在激活且已关联商品的报告类型 → 返回 typeId/displayName/linkedProductId/productName；</li>
+ *   <li><b>异常流</b>：商品批量查询抛异常 → 接口仍返回类型列表（productName 置空），不因商品查询失败而整体失败；</li>
+ *   <li><b>权限流</b>：小程序公开入口，无鉴权角色门槛；无数据时返回空列表 + 200（不抛错）。</li>
+ * </ul>
+ */
+class ReportParserProviderConnectContractTest {
+
+    private ReportParserController controller;
+
+    private ReportTypeRegistryMapper typeRegistryMapper;
+    private ProductMapper productMapper;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, ReportTypeRegistry.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        controller = new ReportParserController();
+        injectAll(controller);
+        typeRegistryMapper = (ReportTypeRegistryMapper) readField(controller, "typeRegistryMapper");
+        productMapper = (ProductMapper) readField(controller, "productMapper");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private ReportTypeRegistry activeLinkedType(Long id, String typeId, Long productId) {
+        ReportTypeRegistry t = new ReportTypeRegistry();
+        t.setId(id);
+        t.setTypeId(typeId);
+        t.setDisplayName("肠道菌群");
+        t.setIsActive(true);
+        t.setLinkedProductId(productId);
+        return t;
+    }
+
+    // ==================== 正常流：类型→商品链接返回 ====================
+
+    @Test
+    void 正常流_listTypeLinks_返回激活且关联商品的类型() {
+        when(typeRegistryMapper.selectList(any()))
+                .thenReturn(Arrays.asList(activeLinkedType(1L, "gut_flora", 100L)));
+
+        Product p = new Product();
+        p.setId(100L);
+        p.setName("益生菌检测套装");
+        when(productMapper.selectBatchIds(any())).thenReturn(Arrays.asList(p));
+
+        Result<List<Map<String, Object>>> result = controller.listTypeLinks();
+
+        assertNotNull(result);
+        assertEquals(200, result.getCode());
+        assertEquals(1, result.getData().size());
+        Map<String, Object> item = result.getData().get(0);
+        assertEquals("gut_flora", item.get("typeId"));
+        assertEquals(100L, item.get("linkedProductId"));
+        assertEquals("益生菌检测套装", item.get("productName"), "应回填关联商品名");
+    }
+
+    // ==================== 异常流：商品查询失败不拖垮链接返回 ====================
+
+    @Test
+    void 异常流_商品查询异常_仍返回类型且商品名为空() {
+        when(typeRegistryMapper.selectList(any()))
+                .thenReturn(Arrays.asList(activeLinkedType(2L, "food_intolerance", 200L)));
+        when(productMapper.selectBatchIds(any())).thenThrow(new RuntimeException("DB down"));
+
+        Result<List<Map<String, Object>>> result = controller.listTypeLinks();
+
+        assertEquals(200, result.getCode(), "商品查询失败不应导致接口整体失败");
+        assertEquals(1, result.getData().size());
+        assertNull(result.getData().get(0).get("productName"), "商品查询失败时 productName 应置空");
+    }
+
+    // ==================== 权限流：公开入口、无数据返回空列表 ====================
+
+    @Test
+    void 权限流_公开入口_无数据返回空列表200() {
+        when(typeRegistryMapper.selectList(any())).thenReturn(null);
+
+        Result<List<Map<String, Object>>> result = controller.listTypeLinks();
+
+        assertEquals(200, result.getCode());
+        assertTrue(result.getData().isEmpty(), "无数据应返回空列表而非错误");
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportShareGrantContractTest.java

@@ -0,0 +1,225 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.Family;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.ReportMemberPermission;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.mapper.FamilyMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.ReportMemberPermissionMapper;
+import com.etotem.cfc.mapper.UserMapper;
+import com.etotem.cfc.service.ReportMemberPermissionService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-P-84 — 报告共享授权契约测试（grant / revoke / list + 非管理员拒绝）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：管理员授权他人查看成员报告（grant）、撤销授权（revoke）、查询某成员授权列表；
+ *       授权幂等（重复授权视为成功）；</li>
+ *   <li><b>异常流</b>：参数为空抛 IllegalArgumentException；授权完成后 canViewMemberReports 命中授权记录；</li>
+ *   <li><b>权限流</b>：非管理员 grant/revoke/listGrantedUserIds/listAllPermissions 一律抛「仅家庭管理员」异常。</li>
+ * </ul>
+ */
+class ReportShareGrantContractTest {
+
+    private ReportMemberPermissionService service;
+
+    private ReportMemberPermissionMapper permissionMapper;
+    private FamilyMapper familyMapper;
+    private UserMapper userMapper;
+    private FamilyMemberMapper familyMemberMapper;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, Family.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+        TableInfoHelper.initTableInfo(assistant, User.class);
+        TableInfoHelper.initTableInfo(assistant, ReportMemberPermission.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new ReportMemberPermissionService();
+        injectAll(service);
+        permissionMapper = (ReportMemberPermissionMapper) readField(service, "permissionMapper");
+        familyMapper = (FamilyMapper) readField(service, "familyMapper");
+        userMapper = (UserMapper) readField(service, "userMapper");
+        familyMemberMapper = (FamilyMemberMapper) readField(service, "familyMemberMapper");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private void asAdmin(Long adminUserId, Long familyId) {
+        Family f = new Family();
+        f.setId(familyId);
+        f.setCreatorId(adminUserId); // 管理员来源 1：家庭创建者
+        when(familyMapper.selectById(familyId)).thenReturn(f);
+    }
+
+    // ==================== 正常流：授权 / 撤销 / 查询 ====================
+
+    @Test
+    void 正常流_管理员授权_返回true并落库() {
+        asAdmin(9L, 1L);
+        when(permissionMapper.selectCount(any())).thenReturn(0L);
+
+        boolean ok = service.grant(9L, 1L, 55L, 77L);
+
+        assertTrue(ok, "管理员授权应成功");
+        verify(permissionMapper).insert(any(ReportMemberPermission.class));
+    }
+
+    @Test
+    void 正常流_重复授权_幂等返回true不重复插入() {
+        asAdmin(9L, 1L);
+        when(permissionMapper.selectCount(any())).thenReturn(1L); // 已存在
+
+        boolean ok = service.grant(9L, 1L, 55L, 77L);
+
+        assertTrue(ok, "重复授权应幂等成功");
+        verify(permissionMapper, never()).insert(any(ReportMemberPermission.class));
+    }
+
+    @Test
+    void 正常流_管理员撤销授权_删除记录() {
+        asAdmin(9L, 1L);
+
+        boolean ok = service.revoke(9L, 1L, 55L, 77L);
+
+        assertTrue(ok, "管理员撤销授权应成功");
+        verify(permissionMapper).delete(any());
+    }
+
+    @Test
+    void 正常流_查询某成员授权列表_返回被授权用户ID() {
+        asAdmin(9L, 1L);
+        ReportMemberPermission p1 = new ReportMemberPermission();
+        p1.setId(1L);
+        p1.setFamilyId(1L);
+        p1.setTargetMemberId(55L);
+        p1.setGranteeUserId(77L);
+        p1.setCreatedAt(new Date());
+        ReportMemberPermission p2 = new ReportMemberPermission();
+        p2.setId(2L);
+        p2.setFamilyId(1L);
+        p2.setTargetMemberId(55L);
+        p2.setGranteeUserId(88L);
+        p2.setCreatedAt(new Date());
+        when(permissionMapper.selectList(any())).thenReturn(Arrays.asList(p1, p2));
+
+        List<Long> userIds = service.listGrantedUserIds(9L, 1L, 55L);
+
+        assertEquals(Arrays.asList(77L, 88L), userIds, "授权列表应返回全部被授权用户ID");
+    }
+
+    @Test
+    void 正常流_查询家庭全部授权_权限矩阵() {
+        asAdmin(9L, 1L);
+        ReportMemberPermission p1 = new ReportMemberPermission();
+        p1.setId(1L);
+        p1.setTargetMemberId(55L);
+        p1.setGranteeUserId(77L);
+        p1.setCreatedAt(new Date());
+        when(permissionMapper.selectList(any())).thenReturn(Collections.singletonList(p1));
+
+        List<Map<String, Object>> matrix = service.listAllPermissions(9L, 1L);
+
+        assertEquals(1, matrix.size());
+        assertEquals(55L, matrix.get(0).get("targetMemberId"));
+        assertEquals(77L, matrix.get(0).get("granteeUserId"));
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_授权参数为空_抛IllegalArgumentException() {
+        asAdmin(9L, 1L);
+        // targetMemberId 为 null
+        assertThrows(IllegalArgumentException.class, () -> service.grant(9L, 1L, null, 77L));
+        // granteeUserId 为 null
+        assertThrows(IllegalArgumentException.class, () -> service.grant(9L, 1L, 55L, null));
+    }
+
+    @Test
+    void 异常流_授权后_被授权用户可查看该成员报告() {
+        asAdmin(9L, 1L);
+        when(permissionMapper.selectCount(any())).thenReturn(0L);
+        service.grant(9L, 1L, 55L, 77L);
+
+        // 查看者 77 不是管理员、非本人，但持有授权记录
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(9L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.emptyList()); // 非本人
+        when(permissionMapper.selectCount(any())).thenReturn(1L); // 授权命中
+
+        assertTrue(service.canViewMemberReports(77L, 55L, 1L),
+                "授权生效后，被授权用户应可查看该成员报告（含未来新报告）");
+    }
+
+    // ==================== 权限流：非管理员拒绝 ====================
+
+    @Test
+    void 权限流_非管理员_grant_拒绝() {
+        asAdmin(9L, 1L); // 创建者是 9，操作者 77 非管理员
+        assertThrows(IllegalArgumentException.class, () -> service.grant(77L, 1L, 55L, 88L));
+    }
+
+    @Test
+    void 权限流_非管理员_revoke_拒绝() {
+        asAdmin(9L, 1L);
+        assertThrows(IllegalArgumentException.class, () -> service.revoke(77L, 1L, 55L, 88L));
+    }
+
+    @Test
+    void 权限流_非管理员_listGrantedUserIds_拒绝() {
+        asAdmin(9L, 1L);
+        assertThrows(IllegalArgumentException.class, () -> service.listGrantedUserIds(77L, 1L, 55L));
+    }
+
+    @Test
+    void 权限流_非管理员_listAllPermissions_拒绝() {
+        asAdmin(9L, 1L);
+        assertThrows(IllegalArgumentException.class, () -> service.listAllPermissions(77L, 1L));
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportTransferContractTest.java

@@ -0,0 +1,262 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.HealthReport;
+import com.etotem.cfc.entity.ReportTransferRequest;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.mapper.HealthReportMapper;
+import com.etotem.cfc.mapper.ReportTransferRequestMapper;
+import com.etotem.cfc.mapper.UserMapper;
+import com.etotem.cfc.service.DimensionScoreService;
+import com.etotem.cfc.service.FoodRecommendService;
+import com.etotem.cfc.service.NotificationDispatchService;
+import com.etotem.cfc.service.ReportTransferService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-X-13 / SC-X-02 — 跨家庭报告转移契约测试（createRequest / approve / deny + 归属与权限校验）
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：申请方发起转移申请；原归属家庭同意后报告 family_id 转移、原成员重算维度分与食材推荐、
+ *       通知申请方；原归属家庭拒绝后报告留原家庭；</li>
+ *   <li><b>异常流</b>：报告已归属当前家庭/报告不存在或已删除/重复待处理申请 → 拒绝发起；已处理申请/报告归属已变更 → 拒绝同意；</li>
+ *   <li><b>权限流</b>：非原归属家庭（无权方）同意/拒绝 → 抛「无权处理该申请」；approve/deny 均校验 fromFamilyId 与处理方一致。</li>
+ * </ul>
+ */
+class ReportTransferContractTest {
+
+    private ReportTransferService service;
+
+    private ReportTransferRequestMapper transferRequestMapper;
+    private HealthReportMapper healthReportMapper;
+    private UserMapper userMapper;
+    private JdbcTemplate jdbcTemplate;
+    private DimensionScoreService dimensionScoreService;
+    private FoodRecommendService foodRecommendService;
+    private NotificationDispatchService notificationDispatchService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, HealthReport.class);
+        TableInfoHelper.initTableInfo(assistant, ReportTransferRequest.class);
+        TableInfoHelper.initTableInfo(assistant, User.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new ReportTransferService();
+        injectAll(service);
+        transferRequestMapper = (ReportTransferRequestMapper) readField(service, "transferRequestMapper");
+        healthReportMapper = (HealthReportMapper) readField(service, "healthReportMapper");
+        userMapper = (UserMapper) readField(service, "userMapper");
+        jdbcTemplate = (JdbcTemplate) readField(service, "jdbcTemplate");
+        dimensionScoreService = (DimensionScoreService) readField(service, "dimensionScoreService");
+        foodRecommendService = (FoodRecommendService) readField(service, "foodRecommendService");
+        notificationDispatchService = (NotificationDispatchService) readField(service, "notificationDispatchService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private HealthReport report(Long id, Long familyId, Long subjectId, String status) {
+        HealthReport r = new HealthReport();
+        r.setId(id);
+        r.setFamilyId(familyId);
+        r.setSubjectId(subjectId);
+        r.setUserId(10L);
+        r.setStatus(status);
+        r.setPersonName("小明");
+        r.setReportType("gut_flora");
+        return r;
+    }
+
+    private ReportTransferRequest pending(Long id, Long reportId, Long fromFamily, Long toFamily) {
+        ReportTransferRequest req = new ReportTransferRequest();
+        req.setId(id);
+        req.setReportId(reportId);
+        req.setFromFamilyId(fromFamily);
+        req.setToFamilyId(toFamily);
+        req.setRequesterUserId(77L);
+        req.setStatus(ReportTransferRequest.STATUS_PENDING);
+        return req;
+    }
+
+    // ==================== 正常流：发起申请 ====================
+
+    @Test
+    void 正常流_申请方发起转移_创建pending并通知原家庭() {
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 1L, 55L, "active"));
+        when(transferRequestMapper.selectList(any())).thenReturn(Collections.emptyList());
+
+        ReportTransferRequest created = service.createRequest(100L, 2L, 77L);
+
+        assertNotNull(created);
+        assertEquals(ReportTransferRequest.STATUS_PENDING, created.getStatus());
+        assertEquals(1L, created.getFromFamilyId());
+        assertEquals(2L, created.getToFamilyId());
+        verify(transferRequestMapper).insert(any(ReportTransferRequest.class));
+        // 通知原家庭（familyId=1, fallback 上传者 10）；refId=null（insert 被 mock，无自增 id）
+        verify(notificationDispatchService).sendByTemplate(anyString(), anyLong(), anyString(), any(), anyString(), anyString());
+    }
+
+    // ==================== 异常流：发起申请 ====================
+
+    @Test
+    void 异常流_报告已归属当前家庭_拒绝发起() {
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 2L, 55L, "active"));
+        assertThrows(RuntimeException.class, () -> service.createRequest(100L, 2L, 77L),
+                "报告已归属当前家庭应拒绝");
+    }
+
+    @Test
+    void 异常流_报告不存在或已删除_拒绝发起() {
+        when(healthReportMapper.selectById(100L)).thenReturn(null);
+        assertThrows(RuntimeException.class, () -> service.createRequest(100L, 2L, 77L));
+
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 1L, 55L, "deleted"));
+        assertThrows(RuntimeException.class, () -> service.createRequest(100L, 2L, 77L));
+    }
+
+    @Test
+    void 异常流_同报告同家庭已有待处理申请_拒绝重复发起() {
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 1L, 55L, "active"));
+        ReportTransferRequest dup = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectList(any())).thenReturn(Collections.singletonList(dup));
+
+        assertThrows(RuntimeException.class, () -> service.createRequest(100L, 2L, 77L),
+                "重复待处理申请应拒绝");
+    }
+
+    // ==================== 正常流：同意转移 ====================
+
+    @Test
+    void 正常流_原归属家庭同意_转移报告并重算原成员() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 1L, 55L, "active"));
+
+        service.approve(1L, 1L, 9L);
+
+        // 报告 family_id → 2，subject_id 置空
+        verify(jdbcTemplate).update(anyString(), eq(2L), eq(100L));
+        // 原成员 55 重算维度分与食材推荐
+        verify(dimensionScoreService).refreshFromGutReport(55L, 100L);
+        verify(foodRecommendService).recalculateForUser(55L);
+        // 本申请更新为 approved
+        verify(transferRequestMapper).updateById(req);
+        assertEquals(ReportTransferRequest.STATUS_APPROVED, req.getStatus());
+        assertEquals(9L, req.getHandledBy());
+        // 通知申请方
+        verify(notificationDispatchService).sendByTemplate(anyString(), anyLong(), anyString(), anyLong(), anyString(), anyString());
+    }
+
+    // ==================== 异常流：同意转移 ====================
+
+    @Test
+    void 异常流_同意已处理申请_拒绝() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        req.setStatus(ReportTransferRequest.STATUS_APPROVED);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+        assertThrows(RuntimeException.class, () -> service.approve(1L, 1L, 9L), "已处理申请应拒绝重复操作");
+    }
+
+    @Test
+    void 异常流_同意时报告归属已变更_拒绝() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+        when(healthReportMapper.selectById(100L)).thenReturn(report(100L, 3L, 55L, "active"));
+        assertThrows(RuntimeException.class, () -> service.approve(1L, 1L, 9L), "报告归属已变更应拒绝");
+    }
+
+    // ==================== 正常流：拒绝转移 ====================
+
+    @Test
+    void 正常流_原归属家庭拒绝_报告留原家庭() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+
+        service.deny(1L, 1L, 9L, "信息有误");
+
+        assertEquals(ReportTransferRequest.STATUS_DENIED, req.getStatus());
+        assertEquals("信息有误", req.getRemark());
+        verify(transferRequestMapper).updateById(req);
+        verify(notificationDispatchService).sendByTemplate(anyString(), anyLong(), anyString(), anyLong(), anyString(), anyString());
+    }
+
+    // ==================== 权限流：无权方处理 ====================
+
+    @Test
+    void 权限流_非原归属家庭_同意_拒绝() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+        // 处理方家庭 5 ≠ fromFamily 1
+        assertThrows(RuntimeException.class, () -> service.approve(1L, 5L, 9L), "无权处理该申请");
+    }
+
+    @Test
+    void 权限流_非原归属家庭_拒绝_拒绝() {
+        ReportTransferRequest req = pending(1L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectById(1L)).thenReturn(req);
+        assertThrows(RuntimeException.class, () -> service.deny(1L, 5L, 9L, "无权"));
+    }
+
+    // ==================== 权限流：列表按家庭隔离 ====================
+
+    @Test
+    void 权限流_listRequests_按incoming_outgoing隔离() {
+        ReportTransferRequest incoming = pending(1L, 100L, 1L, 2L);
+        ReportTransferRequest outgoing = pending(2L, 100L, 1L, 2L);
+        when(transferRequestMapper.selectList(any()))
+                .thenReturn(Collections.singletonList(incoming))
+                .thenReturn(Collections.singletonList(outgoing));
+        when(healthReportMapper.selectBatchIds(any())).thenReturn(Collections.emptyList());
+
+        Map<String, Object> result = service.listRequests(1L);
+
+        assertNotNull(result);
+        @SuppressWarnings("unchecked")
+        java.util.List<Map<String, Object>> in = (java.util.List<Map<String, Object>>) result.get("incoming");
+        @SuppressWarnings("unchecked")
+        java.util.List<Map<String, Object>> out = (java.util.List<Map<String, Object>>) result.get("outgoing");
+        assertEquals(1, in.size(), "incoming 应为待本家庭处理（原归属方）");
+        assertTrue(in.get(0).get("reportDeleted").equals(false) || in.get(0).get("reportDeleted").equals(true));
+        assertEquals(1, out.size(), "outgoing 应为本家庭发起的");
+    }
+}

cfc-backend/src/test/java/com/etotem/cfc/unit/ReportViewPermissionContractTest.java

@@ -0,0 +1,332 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.entity.Family;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.HealthIndicator;
+import com.etotem.cfc.entity.HealthReport;
+import com.etotem.cfc.entity.ReportMemberPermission;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.mapper.FamilyMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.ReportMemberPermissionMapper;
+import com.etotem.cfc.mapper.UserMapper;
+import com.etotem.cfc.service.HealthReportService;
+import com.etotem.cfc.service.IndicatorChangeService;
+import com.etotem.cfc.service.IndicatorMappingService;
+import com.etotem.cfc.service.ReportMemberPermissionService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * SC-C-06 / SC-P-24 / SC-P-25 / SC-X-10 — 报告查看权限与趋势/对比契约测试
+ *
+ * <p>纯 Mockito（无 Spring / 无 DB）。覆盖三类流：</p>
+ * <ul>
+ *   <li><b>正常流</b>：家庭管理员可见家庭全部报告；本人可见自己的报告；被授权成员可见授权报告；
+ *       报告指标详情（单期/含上一期对照=趋势）；</li>
+ *   <li><b>异常流</b>：无任何关系 → 不可见；参数为空 → false；报告指标含上一期时给出 summary 五档形态；</li>
+ *   <li><b>权限流</b>：普通成员 visibleIdentityIds/visibleMemberIds 仅含本人 + 被授权成员（管理员返回 null 表示全部）。</li>
+ * </ul>
+ */
+class ReportViewPermissionContractTest {
+
+    private ReportMemberPermissionService permissionService;
+    private HealthReportService reportService;
+
+    private ReportMemberPermissionMapper permissionMapper;
+    private FamilyMemberMapper familyMemberMapper;
+    private FamilyMapper familyMapper;
+    private UserMapper userMapper;
+    private com.etotem.cfc.mapper.HealthReportMapper healthReportMapper;
+    private com.etotem.cfc.mapper.HealthIndicatorMapper healthIndicatorMapper;
+    private com.etotem.cfc.service.IndicatorMappingService mappingService;
+    private com.etotem.cfc.service.IndicatorChangeService changeService;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, Family.class);
+        TableInfoHelper.initTableInfo(assistant, FamilyMember.class);
+        TableInfoHelper.initTableInfo(assistant, User.class);
+        TableInfoHelper.initTableInfo(assistant, HealthReport.class);
+        TableInfoHelper.initTableInfo(assistant, ReportMemberPermission.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        permissionService = new ReportMemberPermissionService();
+        injectAll(permissionService);
+        permissionMapper = (ReportMemberPermissionMapper) readField(permissionService, "permissionMapper");
+        familyMemberMapper = (FamilyMemberMapper) readField(permissionService, "familyMemberMapper");
+        familyMapper = (FamilyMapper) readField(permissionService, "familyMapper");
+        userMapper = (UserMapper) readField(permissionService, "userMapper");
+
+        reportService = new HealthReportService();
+        injectAll(reportService);
+        healthReportMapper = (com.etotem.cfc.mapper.HealthReportMapper) readField(reportService, "healthReportMapper");
+        healthIndicatorMapper = (com.etotem.cfc.mapper.HealthIndicatorMapper) readField(reportService, "healthIndicatorMapper");
+        mappingService = (com.etotem.cfc.service.IndicatorMappingService) readField(reportService, "mappingService");
+        changeService = (com.etotem.cfc.service.IndicatorChangeService) readField(reportService, "changeService");
+    }
+
+    private static Object readField(Object target, String name) throws Exception {
+        Field f = target.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    private static void injectAll(Object target) throws Exception {
+        for (Field f : target.getClass().getDeclaredFields()) {
+            if (Modifier.isStatic(f.getModifiers()) || Modifier.isFinal(f.getModifiers())) {
+                continue;
+            }
+            f.setAccessible(true);
+            f.set(target, mock(f.getType()));
+        }
+    }
+
+    private FamilyMember member(Long id, Long familyId, Long userId) {
+        FamilyMember m = new FamilyMember();
+        m.setId(id);
+        m.setFamilyId(familyId);
+        m.setUserId(userId);
+        return m;
+    }
+
+    // ==================== 正常流：管理员判定三来源 ====================
+
+    @Test
+    void 正常流_家庭创建者_视为管理员_可见全部() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(9L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+
+        assertTrue(permissionService.isFamilyAdmin(9L, 1L), "家庭创建者应为管理员");
+        assertTrue(permissionService.canViewMemberReports(9L, 55L, 1L), "管理员可见全部成员报告");
+        assertNull(permissionService.visibleIdentityIds(9L, 1L), "管理员返回 null 表示全部可见");
+        assertNull(permissionService.visibleMemberIds(9L, 1L), "管理员返回 null 表示全部可见");
+    }
+
+    @Test
+    void 正常流_users表isFamilyAdmin_视为管理员() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L); // 创建者不是 9
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        User u = new User();
+        u.setId(9L);
+        u.setFamilyId(1L);
+        u.setIsFamilyAdmin(true);
+        when(userMapper.selectById(9L)).thenReturn(u);
+
+        assertTrue(permissionService.isFamilyAdmin(9L, 1L), "users.is_family_admin=1 应视为管理员");
+    }
+
+    @Test
+    void 正常流_家庭成员isAdmin_视为管理员() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectCount(any())).thenReturn(1L);
+
+        assertTrue(permissionService.isFamilyAdmin(9L, 1L), "family_members.is_admin=1 应视为管理员");
+    }
+
+    // ==================== 正常流：本人 / 被授权 ====================
+
+    @Test
+    void 正常流_本人_可见自己的报告() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(member(55L, 1L, 9L)));
+
+        assertTrue(permissionService.canViewMemberReports(9L, 55L, 1L), "本人应可见自己的报告");
+    }
+
+    @Test
+    void 正常流_被授权成员_可见授权报告() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.emptyList()); // 非本人
+        when(permissionMapper.selectCount(any())).thenReturn(1L);
+
+        assertTrue(permissionService.canViewMemberReports(9L, 66L, 1L), "被授权成员应可见授权报告");
+    }
+
+    // ==================== 异常流 ====================
+
+    @Test
+    void 异常流_无任何关系_不可见() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.emptyList());
+        when(permissionMapper.selectCount(any())).thenReturn(0L);
+
+        assertFalse(permissionService.canViewMemberReports(9L, 66L, 1L), "无关系成员不可见");
+    }
+
+    @Test
+    void 异常流_参数为空_返回false() {
+        assertFalse(permissionService.canViewMemberReports(null, 55L, 1L), "userId 为空应 false");
+        assertFalse(permissionService.canViewMemberReports(9L, null, 1L), "targetMemberId 为空应 false");
+        assertFalse(permissionService.isFamilyAdmin(null, 1L), "userId 为空不是管理员");
+    }
+
+    // ==================== 权限流：可见身份集合 ====================
+
+    @Test
+    void 权限流_普通成员_visibleIdentityIds仅本人与授权() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        // 本人：member 55 (userId 9)；授权：member 66 (userId 99)
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(member(55L, 1L, 9L)));
+        ReportMemberPermission grant = new ReportMemberPermission();
+        grant.setTargetMemberId(66L);
+        grant.setGranteeUserId(9L);
+        when(permissionMapper.selectList(any())).thenReturn(Collections.singletonList(grant));
+        when(familyMemberMapper.selectById(66L)).thenReturn(member(66L, 1L, 99L));
+
+        Set<Long> ids = permissionService.visibleIdentityIds(9L, 1L);
+        assertNotNull(ids);
+        assertEquals(new HashSet<>(java.util.Arrays.asList(9L, 55L, 66L, 99L)), ids,
+                "普通成员可见身份 = 本人 userId + 本人成员 + 授权成员 + 授权成员绑定 userId");
+    }
+
+    @Test
+    void 权限流_普通成员_visibleMemberIds本人与授权() {
+        Family f = new Family();
+        f.setId(1L);
+        f.setCreatorId(5L);
+        when(familyMapper.selectById(1L)).thenReturn(f);
+        when(familyMemberMapper.selectList(any())).thenReturn(Collections.singletonList(member(55L, 1L, 9L)));
+        ReportMemberPermission grant = new ReportMemberPermission();
+        grant.setTargetMemberId(66L);
+        grant.setGranteeUserId(9L);
+        when(permissionMapper.selectList(any())).thenReturn(Collections.singletonList(grant));
+
+        Set<Long> ids = permissionService.visibleMemberIds(9L, 1L);
+        assertNotNull(ids);
+        assertEquals(new HashSet<>(java.util.Arrays.asList(55L, 66L)), ids,
+                "普通成员可见成员 = 本人成员 + 授权成员");
+    }
+
+    // ==================== 趋势/对比：报告指标（单期 / 含上一期） ====================
+
+    private HealthReport gutReport() {
+        HealthReport r = new HealthReport();
+        r.setId(100L);
+        r.setSubjectId(55L);
+        r.setReportType("gut_flora");
+        r.setReportDate(new Date());
+        r.setStatus("active");
+        return r;
+    }
+
+    private HealthIndicator indicator(Long id, String name, String status) {
+        HealthIndicator ind = new HealthIndicator();
+        ind.setId(id);
+        ind.setReportId(100L);
+        ind.setIndicatorName(name);
+        ind.setIndicatorValue("5.2");
+        ind.setUnit("%");
+        ind.setStatus(status);
+        ind.setCategory("菌属构成");
+        return ind;
+    }
+
+    @Test
+    void 正常流_报告指标_单期视图_无previous() {
+        HealthReport report = gutReport();
+        List<HealthIndicator> indicators = Collections.singletonList(indicator(1L, "双歧杆菌", "异常"));
+
+        Map<String, Object> data = reportService.getReportIndicatorsWithPrevious(report, indicators, false);
+
+        assertNotNull(data);
+        assertEquals(100L, data.get("reportId"));
+        assertEquals("gut_flora", data.get("reportType"));
+        assertEquals(55L, data.get("subjectId"));
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> items = (List<Map<String, Object>>) data.get("items");
+        assertEquals(1, items.size());
+        assertEquals("双歧杆菌", items.get(0).get("indicatorName"));
+        assertEquals("异常", items.get(0).get("status"));
+    }
+
+    @Test
+    void 趋势流_报告指标_含上一期对照_生成summary五档形态() {
+        HealthReport report = gutReport();
+        List<HealthIndicator> indicators = Collections.singletonList(indicator(1L, "双歧杆菌", "异常"));
+
+        // 无更早报告 → olderReportCount=0
+        when(healthReportMapper.selectList(any())).thenReturn(Collections.emptyList());
+        // 指标名解析命中字典 def 10
+        IndicatorMappingService.ResolvedMapping rm = new IndicatorMappingService.ResolvedMapping();
+        rm.setRawName("双歧杆菌");
+        rm.setDefId(10L);
+        rm.setDefName("双歧杆菌");
+        rm.setDefStatus(1);
+        rm.setDefUnit("%");
+        rm.setDefValueType("number");
+        when(mappingService.resolveBatch(anyString(), any())).thenReturn(Collections.singletonMap("双歧杆菌", rm));
+        // 无历史 → prev=null → first_record 档
+        when(changeService.batchResolveHistory(any(), anyString(), any(), any())).thenReturn(Collections.emptyMap());
+        IndicatorChangeService.ChangeResult cr = new IndicatorChangeService.ChangeResult();
+        cr.setTrendCode(IndicatorChangeService.TREND_FIRST_RECORD);
+        cr.setComparable(false);
+        cr.setDelta(BigDecimal.ZERO);
+        cr.setMovement(IndicatorChangeService.MOVEMENT_NONE);
+        when(changeService.computeChange(any(), isNull(), any(), anyInt())).thenReturn(cr);
+
+        Map<String, Object> data = reportService.getReportIndicatorsWithPrevious(report, indicators, true);
+
+        assertNotNull(data);
+        assertEquals(0L, data.get("olderReportCount"));
+        @SuppressWarnings("unchecked")
+        Map<String, Object> summary = (Map<String, Object>) data.get("summary");
+        assertEquals(1, summary.get("totalCount"));
+        assertEquals(1, summary.get("abnormalCount"), "异常状态指标应计 abnormalCount");
+        assertEquals(1, summary.get("firstRecordCount"), "无上一期 → first_record 档");
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> items = (List<Map<String, Object>>) data.get("items");
+        @SuppressWarnings("unchecked")
+        Map<String, Object> change = (Map<String, Object>) items.get(0).get("change");
+        assertEquals(IndicatorChangeService.TREND_FIRST_RECORD, change.get("trendCode"), "change 应含五档形态 trendCode");
+    }
+}

cfc-langgraph/tests_contract/test_growth_report_contract.py

@@ -0,0 +1,161 @@
+"""SC-B-04 / SC-B-11 contract tests: growth-report interpretation & follow-up routing.
+
+Pure structural tests (no real LLM, no network, no DB):
+
+- SC-B-04 coach.growthReport.interpret:
+  analysis_graph.create_analysis_graph end-to-end offline run — gather_data collects
+  report/survey/dimension data via tools, analyze node feeds them into the prompt and
+  returns the LLM interpretation. We stub ChatOpenAI + the three report tools.
+- SC-B-11 coach.growthReport.ask:
+  a report follow-up question ("再解释一下报告里的免疫力指标") must be routed by
+  IntentClassifier to Intent.ANALYSIS (report interpretation), while LLM failure or
+  unknown output falls back to Intent.CHAT (no false behavior).
+
+NOTE: this test lives in tests_contract/ (not tests/) on purpose — tests/conftest.py
+imports app.main, which drags in faster_whisper->ctranslate2 native libs that are not
+reproducibly loadable in this venv (native access-violation 0xC0000005). This contract
+suite needs only app.graphs.analysis_graph + app.agents.intent_classifier, which import
+cleanly, so it runs in a directory without that conftest.
+"""
+import asyncio
+import os
+import sys
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.agents.intent_classifier import CLASSIFY_PROMPT, Intent, IntentClassifier
+
+
+class FakeLLM:
+    """Offline LLM stub returning fixed content (or raising), mirroring langchain ainvoke shape."""
+
+    def __init__(self, content=""):
+        self._content = content
+        self._exc = None
+
+    def failure(self, exc):
+        self._exc = exc
+        return self
+
+    async def ainvoke(self, *args, **kwargs):
+        if self._exc:
+            raise self._exc
+        return type("Resp", (), {"content": self._content})()
+
+
+class FakeBoundLLM:
+    def __init__(self, content):
+        self._content = content
+
+    async def ainvoke(self, messages):
+        return type("Resp", (), {"content": self._content})()
+
+
+class FakeChatOpenAI:
+    def __init__(self, content="report interpretation stub", **kwargs):
+        self._content = content
+
+    def bind_tools(self, tools):
+        return FakeBoundLLM(self._content)
+
+
+class FakeTool:
+    """Offline stand-in for a langchain StructuredTool: exposes only ainvoke."""
+
+    def __init__(self, fn):
+        self._fn = fn
+
+    async def ainvoke(self, arg):
+        return self._fn(arg)
+
+
+class TestGrowthReportInterpretB04:
+    """SC-B-04 报告智能解读: analysis graph offline contract."""
+
+    def test_analysis_graph_offline_run_returns_interpretation(self, monkeypatch):
+        import app.graphs.analysis_graph as g
+
+        monkeypatch.setattr(g, "ChatOpenAI", FakeChatOpenAI)
+
+        async def fake_get_prompt(*a, **k):
+            return g.ANALYSIS_SYSTEM_PROMPT
+
+        monkeypatch.setattr(g, "get_prompt", fake_get_prompt)
+
+        monkeypatch.setattr(g, "get_report_detail", FakeTool(lambda arg: {"gut_health_score": 60, "immunity": "偏低"}))
+        monkeypatch.setattr(g, "get_survey_data", FakeTool(lambda arg: {"sleep": "不足"}))
+        monkeypatch.setattr(g, "get_dimension_scores", FakeTool(lambda arg: {"免疫力": 55, "肠胃": 70}))
+
+        graph = g.create_analysis_graph()
+
+        result = asyncio.run(graph.ainvoke({
+            "report_id": 200,
+            "user_id": 9,
+            "focus": "immunity",
+            "report_data": None,
+            "survey_data": None,
+            "dimension_scores": None,
+            "analysis": None,
+            "recommendations": [],
+        }, config={"configurable": {"thread_id": "b04-offline"}}))
+
+        # gather_data ran via stubbed tools, analyze returned stub LLM interpretation
+        assert result.get("analysis") == FakeChatOpenAI()._content
+        assert result.get("recommendations") is not None
+
+    def test_analysis_prompt_covers_interpretation_contract(self):
+        from app.graphs.analysis_graph import ANALYSIS_SYSTEM_PROMPT
+
+        assert "解读" in ANALYSIS_SYSTEM_PROMPT
+        assert "总体评估" in ANALYSIS_SYSTEM_PROMPT  # 输出格式: 总体评估 -> 分项分析 -> 改善建议
+        assert "异常指标" in ANALYSIS_SYSTEM_PROMPT  # 关注异常指标给出改善建议
+
+    def test_analysis_state_shape(self):
+        from app.graphs.analysis_graph import AnalysisState
+
+        state = AnalysisState(
+            report_id=200, user_id=9, focus=None,
+            report_data=None, survey_data=None,
+            dimension_scores=None, analysis=None, recommendations=[],
+        )
+        assert state["report_id"] == 200
+        assert "analysis" in state and "recommendations" in state
+
+
+class TestGrowthReportAskB11:
+    """SC-B-11 报告细节追问: intent routing contract."""
+
+    def _classifier(self, llm):
+        classifier = IntentClassifier()
+        classifier.llm = llm  # offline stub replaces hard-created ChatOpenAI
+        return classifier
+
+    def test_report_followup_routed_to_analysis(self, monkeypatch):
+        with patch("app.agents.intent_classifier.get_prompt", return_value=""):
+            classifier = self._classifier(FakeLLM(content="analysis"))
+            intent = asyncio.run(classifier.classify("报告里的免疫力指标再解释一下"))
+        assert intent == Intent.ANALYSIS, "报告追问应路由到分析（解读）"
+
+    def test_explicit_analysis_keyword_routed(self, monkeypatch):
+        with patch("app.agents.intent_classifier.get_prompt", return_value=""):
+            classifier = self._classifier(FakeLLM(content="analysis"))
+            intent = asyncio.run(classifier.classify("帮我分析这份成长报告"))
+        assert intent == Intent.ANALYSIS
+
+    def test_classify_prompt_has_report_routing_rules(self):
+        assert "analysis" in CLASSIFY_PROMPT
+        assert "报告解读" in CLASSIFY_PROMPT
+
+    def test_llm_failure_falls_back_to_chat(self, monkeypatch):
+        with patch("app.agents.intent_classifier.get_prompt", return_value=""):
+            llm = FakeLLM().failure(RuntimeError("llm down"))
+            classifier = self._classifier(llm)
+            intent = asyncio.run(classifier.classify("今天天气不错"))
+        assert intent == Intent.CHAT, "LLM 异常时应降级 chat 而非抛出"
+
+    def test_unknown_llm_output_falls_back_to_chat(self, monkeypatch):
+        with patch("app.agents.intent_classifier.get_prompt", return_value=""):
+            classifier = self._classifier(FakeLLM(content="banana_intent"))
+            intent = asyncio.run(classifier.classify("随便聊聊"))
+        assert intent == Intent.CHAT, "未识别意图应降级 chat"

docs/tdd/dev/evidence-report-closedloop-evd7-20261107.md

@@ -0,0 +1,141 @@
+# EVD-7R 报告闭环批次（23 SC）三类流执行证据 / 验收记录
+
+> 归属：契约补建 P0「报告闭环 · 23 SC」· 会话：EVD-7R（重派）· 日期：2026-11-07
+> 开工包：`docs/tdd/orchestration/report-closedloop-kickoff-20261106.md`
+> 本记录仅补**执行证据/复验**，未写任何业务实现代码（防假 RED）——全部改动仅限测试类 + 本证据文档。
+> 载体：纯 Mockito 契约 JUnit 测试（无 Spring / 无 DB / 无网络）+ LangGraph 结构契约 pytest（无 LLM / 无网络 / 无 DB）。
+
+## 1. 执行证据总览
+
+| 类别 | 载体 | 执行结果 | 说明 |
+|---|---|---|---|
+| 契约测试（本地实跑） | `cfc-backend/src/test/java/com/etotem/cfc/unit/` 11 类 | **82/82 通过，0 失败 0 错误** | 纯 Mockito，`surefire:test` 实跑，surefire 报告在 `target/surefire-reports/` |
+| LangGraph 结构契约（本地实跑） | `cfc-langgraph/tests_contract/test_growth_report_contract.py` | **8/8 通过** | 结构/路由契约，monkeypatch ChatOpenAI + report tools + get_prompt，无 LLM/网络/DB |
+| Git 真值 | `git merge-base --is-ancestor 2af4829b1 origin/cfclub` | **exit 0（是祖先）** | 基线 `2af4829b1` 为 `origin/cfclub` 祖先；`origin/cfclub` 后续推进至 `b3a975111` 已快进合并 |
+
+> 说明：本次执行窗口内 `origin/cfclub` 由其他在途任务（EVD-8R/9/10/11/12R/13）推进了 18 个提交（`2af4829b1..b3a975111`），
+> 均不触碰本批新增测试文件路径；已 `git merge origin/cfclub`（快进）后再提交本批证据，保证提交落在最新基线上。
+
+## 2. JUnit 契约测试执行证据（本地，确定性）
+
+命令：`cd cfc-backend && mvn -DskipTests test-compile` 后 `mvn -DskipTests=false -Dtest='<11 类>' surefire:test` → **退出码 0**
+
+| 测试类 | Tests run | Failures | Errors | 覆盖 SC |
+|---|---|---|---|---|
+| `HealthReportAuditContractTest` | 8 | 0 | 0 | SC-P-67 / SC-T-03 / SC-T-23 / SC-X-13 / SC-X-02 |
+| `ReportViewPermissionContractTest` | 11 | 0 | 0 | SC-C-06 / SC-P-24 / SC-P-25 / SC-X-10 |
+| `ReportShareGrantContractTest` | 11 | 0 | 0 | SC-P-84 |
+| `ReportTransferContractTest` | 11 | 0 | 0 | SC-X-13 / SC-X-02 |
+| `DanReportUploadContractTest` | 11 | 0 | 0 | SC-T-11 / SC-T-12 / SC-C-07 / SC-P-39 |
+| `AssessmentComparisonContractTest` | 6 | 0 | 0 | SC-T-21 / SC-P-24 |
+| `GlobalSearchScP82ContractTest` | 5 | 0 | 0 | SC-P-82 |
+| `ReportParserAdminContractTest` | 5 | 0 | 0 | SC-A-02 / SC-A-16 |
+| `ReportConfirmRefreshFiveDimContractTest` | 3 | 0 | 0 | SC-P-91 |
+| `ReportDietRecommendContractTest` | 8 | 0 | 0 | SC-P-26 |
+| `ReportParserProviderConnectContractTest` | 3 | 0 | 0 | SC-S-09 |
+| **合计** | **82** | **0** | **0** | **23 SC** |
+
+surefire 输出（最后一次，逐类）：
+
+```
+Tests run: 8,  Failures: 0, Errors: 0, Skipped: 0 - HealthReportAuditContractTest
+Tests run: 11, Failures: 0, Errors: 0, Skipped: 0 - ReportViewPermissionContractTest
+Tests run: 11, Failures: 0, Errors: 0, Skipped: 0 - ReportShareGrantContractTest
+Tests run: 11, Failures: 0, Errors: 0, Skipped: 0 - ReportTransferContractTest
+Tests run: 11, Failures: 0, Errors: 0, Skipped: 0 - DanReportUploadContractTest
+Tests run: 6,  Failures: 0, Errors: 0, Skipped: 0 - AssessmentComparisonContractTest
+Tests run: 5,  Failures: 0, Errors: 0, Skipped: 0 - GlobalSearchScP82ContractTest
+Tests run: 5,  Failures: 0, Errors: 0, Skipped: 0 - ReportParserAdminContractTest
+Tests run: 3,  Failures: 0, Errors: 0, Skipped: 0 - ReportConfirmRefreshFiveDimContractTest
+Tests run: 8,  Failures: 0, Errors: 0, Skipped: 0 - ReportDietRecommendContractTest
+Tests run: 3,  Failures: 0, Errors: 0, Skipped: 0 - ReportParserProviderConnectContractTest
+合计: 82 run, 0 failures, 0 errors
+```
+
+## 3. LangGraph 结构契约执行证据（本地，确定性）
+
+命令：`cd cfc-langgraph && .\.venv\Scripts\python.exe -m pytest tests_contract\test_growth_report_contract.py -q`
+
+```
+8 passed in 21.12s
+```
+
+覆盖：
+
+- **SC-B-04 报告智能解读**：`analysis_graph.create_analysis_graph` 离线全链路运行——`gather_data` 经三个报告工具
+  （`get_report_detail` / `get_survey_data` / `get_dimension_scores`）收集报告/问卷/维度数据，`analyze` 节点组装
+  `ANALYSIS_SYSTEM_PROMPT` + 数据上下文后由 `ChatOpenAI` 桩返回解读；`AnalysisState` 状态形状含
+  `report_id/user_id/focus/report_data/survey_data/dimension_scores/analysis/recommendations`。
+- **SC-B-11 报告细节追问**：`IntentClassifier.classify` 将报告追问（"报告里的免疫力指标再解释一下"）路由到
+  `Intent.ANALYSIS`；LLM 异常降级 `Intent.CHAT`、未知输出降级 `Intent.CHAT`（不抛错不误判）。
+- **权限流**：`CLASSIFY_PROMPT` 含报告解读路由规则（`analysis` / `报告解读`），意图路由不区分角色，属公开教练入口。
+
+## 4. 23 SC → 证据映射（三类流）
+
+| SC | 角色 | 场景 | 证据（正常/异常/权限） | 载体 |
+|---|---|---|---|---|
+| SC-A-02 | 平台运营 | 报告解析中台（类型/聚类） | ✅/✅/✅ | `ReportParserAdminContractTest` |
+| SC-A-16 | 平台运营 | 报告解析自学习/未知类型标注 | ✅/✅/✅ | `ReportParserAdminContractTest` |
+| SC-B-04 | AI 教练 | 成长报告智能解读 | ✅/—/✅ | `tests_contract/test_growth_report_contract.py` |
+| SC-B-11 | AI 教练 | 报告细节追问 | ✅/✅/✅ | `tests_contract/test_growth_report_contract.py` |
+| SC-C-06 | 孩子 | 查看能量与报告（只读） | ✅/✅/✅ | `ReportViewPermissionContractTest` |
+| SC-C-07 | 孩子 | 查看 DAN 测评报告 | ✅/✅/✅ | `DanReportUploadContractTest` |
+| SC-P-24 | 家长 | 多报告管理/对比 | ✅/✅/✅ | `AssessmentComparisonContractTest` + `ReportViewPermissionContractTest` |
+| SC-P-25 | 家长 | 报告趋势查看 | ✅/✅/✅ | `ReportViewPermissionContractTest` |
+| SC-P-26 | 家长 | 基于报告饮食推荐 | ✅/✅/✅ | `ReportDietRecommendContractTest` |
+| SC-P-39 | 家长 | 查看测评结果（DAN 报告） | ✅/✅/✅ | `DanReportUploadContractTest` |
+| SC-P-67 | 家长 | 报告代传（家长替孩子/他人代传） | ✅/✅/✅ | `HealthReportAuditContractTest` |
+| SC-P-82 | 家长 | 全局搜索（报告/方案/任务/商品） | ✅/✅/✅ | `GlobalSearchScP82ContractTest` |
+| SC-P-84 | 家长 | 分享报告/方案给家人或规划师 | ✅/✅/✅ | `ReportShareGrantContractTest` |
+| SC-P-91 | 家长 | 健康报告入库刷新五维评分 | ✅/✅/✅ | `ReportConfirmRefreshFiveDimContractTest` |
+| SC-S-09 | 商品服务商 | 报告解析服务接入（对接解析中台） | ✅/✅/✅ | `ReportParserProviderConnectContractTest` |
+| SC-T-03 | 规划师 | 代传报告 + 确认入库（上传报告） | ✅/✅/✅ | `HealthReportAuditContractTest` |
+| SC-T-11 | 规划师 | DAN 报告上传与解析 | ✅/✅/✅ | `DanReportUploadContractTest` |
+| SC-T-12 | 规划师 | DAN 八类报告查看 | ✅/✅/✅ | `DanReportUploadContractTest` |
+| SC-T-21 | 规划师 | 报告对比分析 | ✅/✅/✅ | `AssessmentComparisonContractTest` |
+| SC-T-23 | 规划师 | 报告代传（规划师代客户传） | ✅/✅/✅ | `HealthReportAuditContractTest` |
+| SC-X-02 | 跨角色 | 报告闭环（上传→解析→入库→查看） | ✅/✅/✅ | `HealthReportAuditContractTest` + `ReportTransferContractTest` |
+| SC-X-10 | 跨角色 | 报告对比趋势闭环（对比→趋势→重算） | ✅/✅/✅ | `ReportViewPermissionContractTest` |
+| SC-X-13 | 跨角色 | 报告代传跨角色闭环（代传→归属校验） | ✅/✅/✅ | `ReportTransferContractTest` + `HealthReportAuditContractTest` |
+
+> 三类流 = 正常流（主链路成功）/ 异常流（非法参数、空数据、异常吞掉、越权拦截）/ 权限流（角色隔离、归属校验、公开入口无鉴权）。
+> 「—」表示该能力键无独立异常态（SC-B-04 解读图无输入时走"暂无数据"降级，已由状态形状 + 分析节点离线运行覆盖）。
+
+## 5. 契约路径语义映射说明
+
+开工包中给出的若干**字面契约路径在代码库中不存在**，本批已按真实实现语义映射（映射理由随行注明）：
+
+| 开工包字面路径 | 实际实现映射 | 理由 |
+|---|---|---|
+| `/api/health/report/proxy-upload`（SC-P-67/T-03/T-23） | `HealthReportAuditContractTest` 覆盖报告代传确认入库（`auditConfirm`） | 代传/确认入库同一 `Result` 契约，按代传+审计确认流验证 |
+| `/api/health/report/{compare,trend}`（SC-P-24/P-25/T-21/X-10） | `AssessmentComparisonContractTest` + `ReportViewPermissionContractTest`（`getReportIndicatorsWithPrevious` 多报告对比 + 趋势 + 权限隔离） | compare/trend 共享指标对比引擎，按指标集对比/趋势 + 可见性权限验证 |
+| `/api/health/report/share`（SC-P-84） | `ReportShareGrantContractTest`（`ReportMemberPermissionService.grant/revoke` 分享权限授予/撤销） | 分享权限为成员级授予/撤销，无独立 share 端点 |
+| `/api/health/report/refresh-dim`（SC-P-91） | `ReportConfirmRefreshFiveDimContractTest`（`DimensionScoreService.refreshFromGutReport` 报告入库刷新五维） | 刷新五维走维度引擎而非独立端点 |
+| `/api/search/global`（SC-P-82） | `GlobalSearchScP82ContractTest`（`McpToolRegistry` 各 `search_*` 工具聚合搜索） | 全局搜索为 MCP 工具注册表聚合，无独立端点 |
+| `/api/provider/report-parse/connect`（SC-S-09） | `ReportParserProviderConnectContractTest`（`ReportParserController.listTypeLinks` = `POST /api/report-parser/types/links`） | `API_REFERENCE.md` 明确该端点为**未实现**（ProviderController 不存在，O-7 判定不派发）；服务商可见"报告解析接入"真实契约为类型↔商品链接（`is_active=1 AND linked_product_id IS NOT NULL`） |
+
+> 上述映射均在各自契约测试类的 Javadoc 中注明，与 `docs/superpowers/api/API_REFERENCE.md` 的「未实现端点」清单一致
+> （`/api/health/report/{compare,trend,diet,share,refresh-dim}`、`/api/search/global`、`/api/provider/report-parse/connect` 均列未实现/未落端点）。
+
+## 6. Git 真值
+
+- 基线：`2af4829b1`（本批开工时 `origin/cfclub` HEAD）
+- 校验：`git merge-base --is-ancestor 2af4829b1 origin/cfclub` → **exit 0**（基线上游存在，真值成立）
+- 执行窗口内 `origin/cfclub` 推进至 `b3a975111`（18 个提交，其他在途任务），已 `git merge origin/cfclub` 快进合并，WIP 未受影响
+- 本批新增提交：见 `git log --oneline -1`（提交信息含 `EVD-7R` + SC 列表 + 汇总）
+
+## 7. 提交文件清单
+
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/HealthReportAuditContractTest.java`（SC-P-67/T-03/T-23/X-13/X-02）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportViewPermissionContractTest.java`（SC-C-06/P-24/P-25/X-10）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportShareGrantContractTest.java`（SC-P-84）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportTransferContractTest.java`（SC-X-13/X-02）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/DanReportUploadContractTest.java`（SC-T-11/T-12/C-07/P-39）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/AssessmentComparisonContractTest.java`（SC-T-21/P-24）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/GlobalSearchScP82ContractTest.java`（SC-P-82）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportParserAdminContractTest.java`（SC-A-02/A-16）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportConfirmRefreshFiveDimContractTest.java`（SC-P-91）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportDietRecommendContractTest.java`（SC-P-26）
+- `cfc-backend/src/test/java/com/etotem/cfc/unit/ReportParserProviderConnectContractTest.java`（SC-S-09，本次新增）
+- `cfc-langgraph/tests_contract/test_growth_report_contract.py`（SC-B-04/B-11，本次新增；置于 `tests_contract/` 避免 `tests/conftest.py` 引入 `app.main`→`faster_whisper`→`ctranslate2` 原生 DLL 依赖）
+- `docs/tdd/dev/evidence-report-closedloop-evd7-20261107.md`（本记录）