Explorar o código

feat(task): 全局任务健康规则引擎(铁名归一/错开≥2h/抗凝停姜黄/提醒文案)

- 新增 TaskHealthRuleService(纯字符串规则,44 单测全绿):
  R1 铁补充剂名归一为华禧益维生@铁叶酸片(保留剂量)
  R2 铁与钙/姜黄/茶咖啡间隔<2h 时铁为机动方自动挪到不同半天
  R3 方案/当日任务集含阿司匹林/华法林时不安排姜黄
  R4 姜黄任务附「服阿司匹林或华法林时停止执行」;铁任务附「与钙片、茶、咖啡、姜黄素间隔2小时以上」
- HealthPlanServiceImpl:方案→模板生成入口(insertTasksForMember/insertExecutionTasksForMember)
  挂 applyPlanDraftRules;newPlanTask 附提醒文案;每日实例由 RepeatTaskGenerator 继承
- TaskService:手工创建入口(createSingleTask)挂 applyManualTaskHealthRules
  (铁名归一+R4文案+姜黄遇抗凝拒绝创建+铁任务同日冲突自动挪 deadline)
- 测试:TaskHealthRuleServiceTest 27 + TaskHealthRuleHookTest 9 + TaskCreateHealthRuleTest 8
  TaskCreateScP10ContractTest 14/14、PlanActivationExecutionContractTest 14/14 等合同全绿
Xiaogang Liao hai 1 día
pai
achega
e0667ae22c

+ 295 - 0
cfc-backend/src/main/java/com/etotem/cfc/service/TaskHealthRuleService.java

@@ -0,0 +1,295 @@
+package com.etotem.cfc.service;
+
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 任务健康规则引擎(全局,创建任务时应用):
+ * <ul>
+ *   <li>R1 铁名归一:铁补充剂(铁剂/力蜚能铁/硫酸亚铁/琥珀酸亚铁/富马酸亚铁/甘氨酸亚铁/蛋白琥珀酸铁等)统一替换为「华禧益维生@铁叶酸片」,保留剂量文本;</li>
+ *   <li>R2 错开 ≥2h:铁与钙片、姜黄素同日任务间隔不足 2 小时时,铁为机动方自动挪到与冲突物不同半天;</li>
+ *   <li>R3 阿司匹林/华法林:同一方案/任务集中含阿司匹林或华法林时,不安排姜黄素任务;</li>
+ *   <li>R4 提醒文案:姜黄任务附「服阿司匹林或华法林时停止执行」;铁任务附「与钙片、茶、咖啡、姜黄素间隔2小时以上」。</li>
+ * </ul>
+ * 规则只作用于任务标题/description 与补充剂排期,不改动健康方案原文。
+ */
+@Component
+public class TaskHealthRuleService {
+
+    /** 目标铁补充剂商品名 */
+    public static final String IRON_PRODUCT = "华禧益维生@铁叶酸片";
+
+    /** 姜黄素提醒文案 */
+    public static final String TURMERIC_REMINDER = "服阿司匹林或华法林时停止执行";
+
+    /** 补铁错开提醒文案 */
+    public static final String IRON_SEPARATION_REMINDER = "与钙片、茶、咖啡、姜黄素间隔2小时以上";
+
+    /** 冲突物间隔阈值(毫秒) */
+    private static final long SEPARATION_WINDOW_MS = 2 * 60 * 60 * 1000L;
+
+    /** 铁补充剂名(按长度降序,先匹配长名防截断;不含"铁蛋白/铁缺乏"等复查词) */
+    private static final Pattern IRON_PRODUCT_PATTERN = Pattern.compile(
+        "蛋白琥珀酸铁|甘氨酸亚铁|富马酸亚铁|琥珀酸亚铁|硫酸亚铁|力蜚能铁|铁剂"
+    );
+
+    private static final Pattern TURMERIC_PATTERN = Pattern.compile("姜黄");
+    private static final Pattern ANTICOAGULANT_PATTERN = Pattern.compile("阿司匹林|华法林");
+    private static final Pattern CALCIUM_PATTERN = Pattern.compile("钙(?:片|D|d|剂)?");
+    private static final Pattern TEA_COFFEE_PATTERN = Pattern.compile("茶|咖啡");
+
+    /** 标题内嵌时间 "HH:mm"(方案任务标题形如「【第三阶段】07:00 早餐后:...」) */
+    private static final Pattern TIME_PATTERN = Pattern.compile("(\\d{1,2}):(\\d{2})");
+
+    /**
+     * R1:将标题中的铁补充剂名统一替换为「华禧益维生@铁叶酸片」,保留剂量文本。
+     * 复查类词语(铁蛋白/铁缺乏/血清铁蛋白等)不匹配铁补充剂名,天然不替换。
+     */
+    public String normalizeIronName(String title) {
+        if (title == null || title.isEmpty()) return title;
+        return IRON_PRODUCT_PATTERN.matcher(title)
+            .replaceAll(Matcher.quoteReplacement(IRON_PRODUCT));
+    }
+
+    /** 判断标题是否含姜黄素 */
+    public boolean containsTurmeric(String title) {
+        return title != null && TURMERIC_PATTERN.matcher(title).find();
+    }
+
+    /** 判断标题是否含阿司匹林/华法林 */
+    public boolean containsAnticoagulant(String title) {
+        return title != null && ANTICOAGULANT_PATTERN.matcher(title).find();
+    }
+
+    /** 判断标题是否含钙补充剂(R2 冲突物) */
+    public boolean containsCalcium(String title) {
+        return title != null && CALCIUM_PATTERN.matcher(title).find();
+    }
+
+    /** 判断标题是否含茶/咖啡(R2 冲突物,生活行为,以提醒文案为主) */
+    public boolean containsTeaOrCoffee(String title) {
+        return title != null && TEA_COFFEE_PATTERN.matcher(title).find();
+    }
+
+    /**
+     * R2:在同一批任务标题中,铁任务(含铁补充剂)与冲突物(钙片/姜黄素/茶/咖啡)间隔 &lt;2h 时,
+     * 铁为机动方自动挪到「与冲突物不同半天」的空闲时段(默认晚 22:00;若晚 22:00 仍与冲突物冲突则再往后挪)。
+     * 同时应用 R1 铁名归一。返回调整后的标题列表(顺序不变)。
+     */
+    public List<String> resolveIronConflicts(List<String> titles) {
+        List<String> result = new ArrayList<>();
+        if (titles == null) return result;
+        for (String raw : titles) {
+            result.add(raw == null ? null : normalizeIronName(raw));
+        }
+
+        // 收集铁任务与各任务时间
+        int ironIdx = -1;
+        for (int i = 0; i < result.size(); i++) {
+            String t = result.get(i);
+            if (t != null && containsIron(t)) { ironIdx = i; break; }
+        }
+        if (ironIdx < 0) return result;
+
+        String ironTitle = result.get(ironIdx);
+        Integer ironTime = extractTimeMinutes(ironTitle);
+        if (ironTime == null) return result; // 标题无时间 → 不挪
+
+        // 找到最小冲突物时间
+        Integer conflictTime = null;
+        for (int i = 0; i < result.size(); i++) {
+            if (i == ironIdx) continue;
+            String t = result.get(i);
+            if (t == null) continue;
+            if (containsCalcium(t) || containsTurmeric(t) || containsTeaOrCoffee(t)) {
+                Integer ct = extractTimeMinutes(t);
+                if (ct != null && (conflictTime == null || ct < conflictTime)) {
+                    conflictTime = ct;
+                }
+            }
+        }
+        if (conflictTime == null) return result; // 无冲突物
+
+        if (Math.abs(ironTime - conflictTime) >= 120) return result; // 已错开 ≥2h
+
+        // 冲突:铁挪到与冲突物不同半天且间隔 ≥2h 的时段
+        String newTitle = shiftIronToFreeSlot(ironTitle, conflictTime, result);
+        if (newTitle != null) {
+            result.set(ironIdx, newTitle);
+        }
+        return result;
+    }
+
+    /**
+     * 判断标题是否含铁补充剂(归一后仍含铁叶酸片 = 铁任务)。
+     */
+    public boolean containsIron(String title) {
+        return IRON_PRODUCT_PATTERN.matcher(title).find()
+            || title.contains(IRON_PRODUCT);
+    }
+
+    /**
+     * R2(手工创建/时间档位版):给定新建铁任务时刻(当天分钟数 0-1439)与同日冲突物时刻列表,
+     * 返回铁应挪到的档位:<ul>
+     *   <li>与所有冲突物均间隔 ≥2h → 原档位不变;</li>
+     *   <li>冲突物在早上半天 → 铁挪当晚 22:00(同天分钟 1320);</li>
+     *   <li>冲突物在晚上半天 → 铁挪次日 06:30(跨天表示 1440+390)。</li>
+     * </ul>
+     * 返回 null 表示无可用档位(调用方保持原时刻)。供 TaskService 手工创建铁任务时调用。
+     */
+    public Integer pickIronFreeSlot(Integer ironMinute, List<Integer> conflictMinutes) {
+        if (ironMinute == null) return null;
+        if (conflictMinutes == null || conflictMinutes.isEmpty()) return ironMinute;
+        List<Integer> conflicts = new ArrayList<>();
+        for (Integer c : conflictMinutes) {
+            if (c != null) conflicts.add(c);
+        }
+        if (conflicts.isEmpty()) return ironMinute;
+
+        // 已与所有冲突物间隔 ≥2h → 保持原档
+        boolean separated = true;
+        for (Integer c : conflicts) {
+            if (Math.abs(ironMinute - c) < 120) { separated = false; break; }
+        }
+        if (separated) return ironMinute;
+
+        // 冲突物是否有晚会话(≥12:00)→ 决定铁挪向:全会话在早上 → 当晚;否则 → 次日早上
+        boolean anyEveningConflict = conflicts.stream().anyMatch(c -> c >= 12 * 60);
+        List<Integer> candidates = new ArrayList<>();
+        if (anyEveningConflict) {
+            // 次日早上候选档(跨天表示,从 06:30 起每 30min 递增)
+            for (int m = 6 * 60 + 30; m <= 11 * 60 + 30; m += 30) {
+                candidates.add(24 * 60 + m);
+            }
+        } else {
+            // 当晚候选档(22:00 起,优先 22:00/22:30,再 21:30/21:00 …)
+            candidates.add(22 * 60);
+            candidates.add(22 * 60 + 30);
+            for (int m = 21 * 60 + 30; m >= 18 * 60; m -= 30) {
+                candidates.add(m);
+            }
+        }
+        // 选出与所有冲突物均间隔 ≥2h 的第一个候选档;找不到则保持原档(异常兜底极罕见)
+        for (Integer cand : candidates) {
+            int dayMinute = cand % (24 * 60);
+            boolean ok = true;
+            for (Integer c : conflicts) {
+                if (Math.abs(dayMinute - c) < 120) { ok = false; break; }
+            }
+            if (ok) return cand;
+        }
+        return ironMinute;
+    }
+
+    /**
+     * 从标题提取 HH:mm 时间(分钟数);无时间返回 null。
+     * 标题形如「07:00 早餐后:...」或「【第三阶段】07:00 早餐后:...」。
+     */
+    private Integer extractTimeMinutes(String title) {
+        Matcher m = TIME_PATTERN.matcher(title);
+        if (!m.find()) return null;
+        try {
+            int h = Integer.parseInt(m.group(1));
+            int min = Integer.parseInt(m.group(2));
+            if (h < 0 || h > 23 || min < 0 || min > 59) return null;
+            return h * 60 + min;
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    /**
+     * 将铁任务标题挪到与冲突时刻「不同半天」的时段(≥2h 间隔)。
+     * 冲突物在上午(≤12:00) → 铁挪晚上 22:00;冲突物在下午/晚上 → 铁挪次日 06:30(次日 00:00 后)。
+     * 若目标时段仍与其它冲突物 <2h,则按 30min 步进继续挪。
+     */
+    private String shiftIronToFreeSlot(String ironTitle, int conflictTime, List<String> allTitles) {
+        boolean conflictInMorning = conflictTime <= 12 * 60;
+        int base = conflictInMorning ? 22 * 60 : 27 * 60; // 27*60 = 次日03:00(跨天,视为更晚时段)
+        for (int slot = base; slot < 30 * 60; slot += 30) {
+            if (Math.abs(slot - conflictTime) >= 120 && isSlotFree(slot, allTitles, ironTitle)) {
+                return replaceTitleTime(ironTitle, slot);
+            }
+        }
+        // 兜底:30*60=次日06:00 仍冲突则取 23:30
+        return replaceTitleTime(ironTitle, 23 * 60 + 30);
+    }
+
+    /** 目标时段是否与其它含冲突物的任务冲突 */
+    private boolean isSlotFree(int slot, List<String> titles, String ironTitle) {
+        for (String t : titles) {
+            if (t == null || t.equals(ironTitle)) continue;
+            if (!(containsCalcium(t) || containsTurmeric(t) || containsTeaOrCoffee(t))) continue;
+            Integer ct = extractTimeMinutes(t);
+            if (ct != null && Math.abs(ct - slot) < 120) return false;
+        }
+        return true;
+    }
+
+    /** 替换标题中的首个 HH:mm 为给定分钟数对应的 HH:mm */
+    private String replaceTitleTime(String title, int minutes) {
+        int h = minutes / 60, m = minutes % 60;
+        if (h >= 24) { h -= 24; } // 跨天时段降为当天可显示时刻(告警由文案提示)
+        String hh = String.format("%02d", h);
+        String mm = String.format("%02d", m);
+        Matcher matcher = TIME_PATTERN.matcher(title);
+        return matcher.replaceFirst(hh + ":" + mm);
+    }
+
+    /**
+     * 判断铁任务标题与冲突物是否已错开 ≥2h(供测试与挂点校验)。
+     */
+    public boolean isIronSeparatedFromConflicts(String ironTitle, List<String> allTitles) {
+        Integer ironTime = extractTimeMinutes(ironTitle);
+        if (ironTime == null) return true;
+        for (String t : allTitles) {
+            if (t == null || t.equals(ironTitle)) continue;
+            if (!(containsCalcium(t) || containsTurmeric(t) || containsTeaOrCoffee(t))) continue;
+            Integer ct = extractTimeMinutes(t);
+            if (ct != null && Math.abs(ct - ironTime) < 120) return false;
+        }
+        return true;
+    }
+
+    /**
+     * R3:同一批任务标题中含阿司匹林或华法林时,移除姜黄素任务。
+     */
+    public List<String> suppressTurmericWithAnticoagulant(List<String> titles) {
+        if (titles == null) return new ArrayList<>();
+        boolean hasAnticoagulant = titles.stream()
+            .filter(t -> t != null)
+            .anyMatch(this::containsAnticoagulant);
+        if (!hasAnticoagulant) return new ArrayList<>(titles);
+        List<String> kept = new ArrayList<>();
+        for (String t : titles) {
+            if (t != null && containsTurmeric(t)) continue; // 停姜黄
+            kept.add(t);
+        }
+        return kept;
+    }
+
+    /**
+     * R4:按任务标题生成/追加 description。
+     * 姜黄任务 → 附「服阿司匹林或华法林时停止执行」;铁任务 → 附「与钙片、茶、咖啡、姜黄素间隔2小时以上」。
+     * 既有描述保留在前,追加提醒在末尾(不重复追加)。
+     */
+    public String buildDescription(String title, String existingDesc) {
+        if (title == null || title.isEmpty()) return existingDesc;
+        StringBuilder sb = new StringBuilder(existingDesc == null ? "" : existingDesc);
+        boolean turmeric = containsTurmeric(title);
+        boolean iron = containsIron(title);
+        if (turmeric && !sb.toString().contains(TURMERIC_REMINDER)) {
+            if (sb.length() > 0) sb.append(";");
+            sb.append(TURMERIC_REMINDER);
+        }
+        if (iron && !sb.toString().contains(IRON_SEPARATION_REMINDER)) {
+            if (sb.length() > 0) sb.append(";");
+            sb.append(IRON_SEPARATION_REMINDER);
+        }
+        return sb.toString();
+    }
+}

+ 106 - 0
cfc-backend/src/main/java/com/etotem/cfc/service/TaskService.java

@@ -94,6 +94,10 @@ public class TaskService implements TaskServiceInterface {
     @Resource
     private CfPathwayEarnService cfPathwayEarnService;
 
+    /** 任务健康规则引擎:手工创建任务统一应用(铁名归一/抗凝停姜黄/提醒文案) */
+    @Resource
+    private TaskHealthRuleService taskHealthRuleService;
+
     private static final int EARLY_BONUS = 1; // 提前完成奖励
     private static final int PENALTY_MAX_DAILY = 5; // 每日最多扣分
     private static final int LATE_GRACE_MINUTES = 10; // 10分钟内不算迟到
@@ -434,9 +438,111 @@ task.setReviewByCategory(dto.getReviewByCategory() != null ? dto.getReviewByCate
             task.setDeadline(null);
         }
 
+        // 任务健康规则挂点(手工创建入口,全局生效):
+        // R1 铁名归一 / R3 抗凝药停姜黄(拒绝创建)/ R4 提醒文案 / R2 铁错开≥2h(自动挪 deadline)
+        applyManualTaskHealthRules(task);
+
         return task;
     }
 
+    /**
+     * 手工创建任务的全局健康规则:
+     * <ul>
+     *   <li>R1 铁名归一:标题中的铁补充剂名统一为「华禧益维生@铁叶酸片」,保留剂量文本;</li>
+     *   <li>R3 阿司匹林/华法林:创建姜黄任务时,若该执行人已有进行中的抗凝药任务 → 拒绝创建;</li>
+     *   <li>R4 提醒文案:姜黄任务附「服阿司匹林或华法林时停止执行」;铁任务附「与钙片、茶、咖啡、姜黄素间隔2小时以上」;</li>
+     *   <li>R2 错开 ≥2h:新建铁任务与同日已有冲突物(钙/姜黄/茶咖啡)间隔不足 2h 时,铁为机动方自动挪档。</li>
+     * </ul>
+     * 规则引擎未装配(null)或标题不含目标补剂时零动作,不影响其他任务创建路径。
+     */
+    private void applyManualTaskHealthRules(Task task) {
+        if (taskHealthRuleService == null || task == null || task.getTitle() == null) {
+            return;
+        }
+        // R1:铁名归一(保留剂量文本)
+        String newTitle = taskHealthRuleService.normalizeIronName(task.getTitle());
+        boolean modified = !newTitle.equals(task.getTitle());
+        task.setTitle(newTitle);
+
+        // R4:按标题附提醒文案(既有描述保留在前、追加不重复)
+        String description = taskHealthRuleService.buildDescription(newTitle, task.getDescription());
+        if (!description.equals(task.getDescription())) {
+            task.setDescription(description);
+        }
+
+        boolean iron = taskHealthRuleService.containsIron(newTitle);
+        boolean turmeric = taskHealthRuleService.containsTurmeric(newTitle);
+        if (!iron && !turmeric) {
+            return;
+        }
+
+        // 同执行人同日已有任务(含模板生成的周期实例,is_template 也纳入判断冲突上下文)
+        List<Task> existing = new ArrayList<>();
+        if (task.getDeadline() != null && task.getExecutorId() != null) {
+            Calendar start = Calendar.getInstance();
+            start.setTime(task.getDeadline());
+            start.set(Calendar.HOUR_OF_DAY, 0);
+            start.set(Calendar.MINUTE, 0);
+            start.set(Calendar.SECOND, 0);
+            start.set(Calendar.MILLISECOND, 0);
+            Calendar end = Calendar.getInstance();
+            end.setTime(start.getTime());
+            end.add(Calendar.DAY_OF_MONTH, 1);
+            existing = taskMapper.selectList(new LambdaQueryWrapper<Task>()
+                    .eq(Task::getFamilyId, task.getFamilyId())
+                    .eq(Task::getExecutorId, task.getExecutorId())
+                    .ge(Task::getDeadline, start.getTime())
+                    .lt(Task::getDeadline, end.getTime())
+                    .last("LIMIT 200"));
+        }
+
+        // R3:姜黄 + 执行人进行中抗凝药任务 → 拒绝创建
+        if (turmeric) {
+            boolean anticoagulant = existing.stream().anyMatch(t ->
+                    taskHealthRuleService.containsAnticoagulant(t.getTitle()));
+            if (anticoagulant) {
+                throw new IllegalArgumentException("执行人正在服用阿司匹林或华法林,按健康规则不安排姜黄素任务");
+            }
+        }
+
+        // R2:铁与同日冲突物(钙/姜黄/茶咖啡)间隔 <2h → 铁为机动方自动挪档
+        if (iron && task.getDeadline() != null && !existing.isEmpty()) {
+            List<Integer> conflictMinutes = new ArrayList<>();
+            for (Task t : existing) {
+                if (t.getTitle() == null || t.getDeadline() == null) continue;
+                if (taskHealthRuleService.containsCalcium(t.getTitle())
+                        || taskHealthRuleService.containsTurmeric(t.getTitle())
+                        || taskHealthRuleService.containsTeaOrCoffee(t.getTitle())) {
+                    Calendar c = Calendar.getInstance();
+                    c.setTime(t.getDeadline());
+                    conflictMinutes.add(c.get(Calendar.HOUR_OF_DAY) * 60 + c.get(Calendar.MINUTE));
+                }
+            }
+            Calendar base = Calendar.getInstance();
+            base.setTime(task.getDeadline());
+            int ironMinute = base.get(Calendar.HOUR_OF_DAY) * 60 + base.get(Calendar.MINUTE);
+            Integer slot = taskHealthRuleService.pickIronFreeSlot(ironMinute, conflictMinutes);
+            if (slot != null && slot != ironMinute) {
+                if (slot >= 24 * 60) {
+                    // 跨天:次日早上
+                    base.add(Calendar.DAY_OF_MONTH, 1);
+                    base.set(Calendar.HOUR_OF_DAY, (slot - 24 * 60) / 60);
+                    base.set(Calendar.MINUTE, (slot - 24 * 60) % 60);
+                } else {
+                    base.set(Calendar.HOUR_OF_DAY, slot / 60);
+                    base.set(Calendar.MINUTE, slot % 60);
+                }
+                base.set(Calendar.SECOND, 0);
+                base.set(Calendar.MILLISECOND, 0);
+                Date shifted = base.getTime();
+                log.info("任务健康规则R2:铁任务错开 ≥2h,deadline {} → {}",
+                        new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm").format(task.getDeadline()),
+                        new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm").format(shifted));
+                task.setDeadline(shifted);
+            }
+        }
+    }
+
     private Long getCurrentMemberId(Long userId) {
         FamilyMember member = familyMemberMapper.selectOne(
                 new LambdaQueryWrapper<FamilyMember>()

+ 69 - 1
cfc-backend/src/main/java/com/etotem/cfc/service/impl/HealthPlanServiceImpl.java

@@ -29,6 +29,7 @@ import com.etotem.cfc.service.AttributionAnalysisService;
 import com.etotem.cfc.service.CartService;
 import com.etotem.cfc.service.HealthPlanService;
 import com.etotem.cfc.service.ProductRecommendationService;
+import com.etotem.cfc.service.TaskHealthRuleService;
 import com.etotem.cfc.service.api.WechatServiceInterface;
 import com.etotem.cfc.util.PlanContentSafetyUtil;
 import lombok.extern.slf4j.Slf4j;
@@ -105,6 +106,10 @@ public class HealthPlanServiceImpl implements HealthPlanService {
     @Resource
     private WechatServiceInterface wechatService;
 
+    /** 任务健康规则引擎:方案→模板生成处统一应用(铁名归一/错开≥2h/抗凝停姜黄/提醒文案) */
+    @Resource
+    private TaskHealthRuleService taskHealthRuleService;
+
     @Resource
     private ProductMapper productMapper;
 
@@ -615,6 +620,10 @@ public class HealthPlanServiceImpl implements HealthPlanService {
         if (drafts == null || drafts.isEmpty()) {
             return created;
         }
+        drafts = applyPlanDraftRules(drafts);
+        if (drafts.isEmpty()) {
+            return created;
+        }
         for (TaskDraft draft : drafts) {
             // 购买类草稿由 R5 购买任务承载,这里只生成执行类任务
             if (PLAN_PURCHASE_CATEGORY.equals(draft.categoryLabel)) continue;
@@ -1675,6 +1684,11 @@ public class HealthPlanServiceImpl implements HealthPlanService {
                                       List<TaskDraft> drafts, Date now, Date planEnd) {
         Long memberId = familyMemberId;
         Long executorId = familyMemberId;
+        // 规则引擎挂点:R1 铁名归一 / R2 铁与钙姜黄错开≥2h / R3 抗凝药停姜黄(作用于标题层)
+        drafts = applyPlanDraftRules(drafts);
+        if (drafts == null || drafts.isEmpty()) {
+            return;
+        }
 
         // 1) 先落一次性购买任务,作为服务任务的依赖锚点(D1)
         Long buyTaskId = null;
@@ -1810,7 +1824,11 @@ public class HealthPlanServiceImpl implements HealthPlanService {
         task.setExecutorId(executorId);
         task.setCreatorId(executorId != null ? executorId : 0L);
         task.setTitle(draft.title);
-        task.setDescription("");
+        // R4:按标题附提醒文案(姜黄→抗凝提醒、铁→错开提醒);无命中的任务保持空描述
+        String description = taskHealthRuleService != null
+                ? taskHealthRuleService.buildDescription(draft.title, "")
+                : "";
+        task.setDescription(description);
         task.setPoints(10);
         task.setSourceType("health_plan");
         task.setSourceId(plan.getId());
@@ -1820,6 +1838,56 @@ public class HealthPlanServiceImpl implements HealthPlanService {
         return task;
     }
 
+    /**
+     * 任务健康规则挂点(方案→模板生成入口统一):对草稿列表做
+     * <ul>
+     *   <li>R3 抗凝药(阿司匹林/华法林)在场 → 移除姜黄草稿;</li>
+     *   <li>R1 铁补充剂名归一(铁剂/力蜚能铁等 → 华禧益维生@铁叶酸片,保留剂量);</li>
+     *   <li>R2 铁与钙/姜黄素/茶咖啡间隔 <2h → 铁标题时间挪到不同半天。</li>
+     * </ul>
+     * 幂等:对已归一的草稿重复执行结果不变。购买任务/无铁无姜黄的草稿不改变。
+     */
+    private List<TaskDraft> applyPlanDraftRules(List<TaskDraft> drafts) {
+        if (drafts == null || drafts.isEmpty() || taskHealthRuleService == null) {
+            return drafts;
+        }
+        // R3:此批草稿若含阿司匹林/华法林 → 过滤掉姜黄草稿
+        boolean hasAnticoagulant = false;
+        for (TaskDraft draft : drafts) {
+            if (taskHealthRuleService.containsAnticoagulant(draft.title)) {
+                hasAnticoagulant = true;
+                break;
+            }
+        }
+        List<TaskDraft> kept = new java.util.ArrayList<>();
+        for (TaskDraft draft : drafts) {
+            if (hasAnticoagulant && taskHealthRuleService.containsTurmeric(draft.title)) {
+                log.info("规则引擎R3:方案草稿含抗凝药,移除姜黄任务草稿 [{}]", draft.title);
+                continue;
+            }
+            kept.add(draft);
+        }
+        if (kept.isEmpty()) {
+            return kept;
+        }
+        // R1+R2:铁名归一 + 错开 ≥2h(铁为机动方,作用于同一执行人同一批草稿)
+        List<String> titles = new java.util.ArrayList<>();
+        for (TaskDraft draft : kept) titles.add(draft.title);
+        titles = taskHealthRuleService.resolveIronConflicts(titles);
+        List<TaskDraft> result = new java.util.ArrayList<>();
+        for (int i = 0; i < kept.size(); i++) {
+            TaskDraft draft = kept.get(i);
+            String newTitle = titles.get(i);
+            if (!draft.title.equals(newTitle)) {
+                log.info("规则引擎R1/R2:草稿标题 [{}] → [{}]", draft.title, newTitle);
+            }
+            TaskDraft copy = new TaskDraft(newTitle, draft.categoryLabel, draft.dimensionCode, draft.frequency);
+            copy.parentTaskId = draft.parentTaskId;
+            result.add(copy);
+        }
+        return result;
+    }
+
     /**
      * 单人/旧 flat 方案:从 plan_json 的 root.sections 提取任务草稿;
      * 懒加载回填统一走 extractDraftsFromSections,回填内容既落库也当次返回。

+ 288 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/TaskCreateHealthRuleTest.java

@@ -0,0 +1,288 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.dto.CreateTaskDTO;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.entity.Task;
+import com.etotem.cfc.entity.User;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.MiniGameMapper;
+import com.etotem.cfc.mapper.SurveyTemplateMapper;
+import com.etotem.cfc.mapper.TaskMapper;
+import com.etotem.cfc.service.TaskHealthRuleService;
+import com.etotem.cfc.service.TaskService;
+import com.etotem.cfc.service.UserService;
+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.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.GregorianCalendar;
+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.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.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * 手工创建任务挂点测试:TaskService.createTask → createSingleTask → applyManualTaskHealthRules。
+ * 覆盖 R1 铁名归一 / R3 抗凝药停姜黄(拒绝创建)/ R4 提醒文案 / R2 铁错开 ≥2h(自动挪 deadline)。
+ */
+class TaskCreateHealthRuleTest {
+
+    private TaskService service;
+    private UserService userService;
+    private FamilyMemberMapper familyMemberMapper;
+    private TaskMapper taskMapper;
+
+    private final List<Task> insertedTasks = new ArrayList<>();
+    private long idSeq = 1000L;
+
+    @BeforeAll
+    static void initMybatisPlusTableInfo() {
+        TableInfoHelper.initTableInfo(
+                new MapperBuilderAssistant(new MybatisConfiguration(), ""), FamilyMember.class);
+        TableInfoHelper.initTableInfo(
+                new MapperBuilderAssistant(new MybatisConfiguration(), ""), Task.class);
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        clearRecentTaskRegistry(); // 清空 TaskService 静态幂等登记表,避免测试间同标题任务相互去重
+        service = new TaskService();
+        userService = mock(UserService.class);
+        familyMemberMapper = mock(FamilyMemberMapper.class);
+        taskMapper = mock(TaskMapper.class);
+        MiniGameMapper miniGameMapper = mock(MiniGameMapper.class);
+        SurveyTemplateMapper surveyTemplateMapper = mock(SurveyTemplateMapper.class);
+
+        inject(service, "userService", userService);
+        inject(service, "familyMemberMapper", familyMemberMapper);
+        inject(service, "taskMapper", taskMapper);
+        inject(service, "miniGameMapper", miniGameMapper);
+        inject(service, "surveyTemplateMapper", surveyTemplateMapper);
+        this.taskHealthRuleService = new TaskHealthRuleService();
+        inject(service, "taskHealthRuleService", this.taskHealthRuleService);
+
+        User user = new User();
+        user.setId(1L);
+        user.setFamilyId(1L);
+        when(userService.getUserInfo(1L)).thenReturn(user);
+        when(familyMemberMapper.selectCount(any(Wrapper.class))).thenReturn(1L);
+
+        when(taskMapper.insert(any(Task.class))).thenAnswer(inv -> {
+            Task t = inv.getArgument(0);
+            t.setId(idSeq++);
+            insertedTasks.add(t);
+            return 1;
+        });
+        // 幂等窗口查询:默认空列表(可在用例内覆盖)
+        when(taskMapper.selectList(any(Wrapper.class))).thenAnswer(inv -> Collections.emptyList());
+    }
+
+    private TaskHealthRuleService taskHealthRuleService;
+
+    /** 清空 TaskService 静态幂等登记表(JVM 内快照)与去重锁,保证单测间无状态残留 */
+    private static void clearRecentTaskRegistry() throws Exception {
+        Field recent = TaskService.class.getDeclaredField("RECENT_TASKS");
+        recent.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        java.util.Map<String, long[]> recentMap = (java.util.Map<String, long[]>) recent.get(null);
+        recentMap.clear();
+        Field locks = TaskService.class.getDeclaredField("TASK_DEDUP_LOCKS");
+        locks.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        java.util.Map<String, Object> lockMap = (java.util.Map<String, Object>) locks.get(null);
+        lockMap.clear();
+    }
+
+    private static void inject(Object target, String field, Object value) throws Exception {
+        Field f = target.getClass().getDeclaredField(field);
+        f.setAccessible(true);
+        f.set(target, value);
+    }
+
+    private CreateTaskDTO dto(String title, Date deadline) {
+        CreateTaskDTO dto = new CreateTaskDTO();
+        dto.setTitle(title);
+        dto.setExecutorType("child");
+        dto.setMemberId(11L);
+        dto.setCategory("使用任务");
+        dto.setDeadline(deadline);
+        dto.setPoints(2);
+        return dto;
+    }
+
+    /** 明天某时刻:避免命中「截止时间不能早于当前时间」校验(服务器当前时刻已过今日若干时点) */
+    private Date tomorrowAt(int hour, int minute) {
+        Calendar cal = new GregorianCalendar();
+        cal.add(Calendar.DAY_OF_MONTH, 1);
+        cal.set(Calendar.HOUR_OF_DAY, hour);
+        cal.set(Calendar.MINUTE, minute);
+        cal.set(Calendar.SECOND, 0);
+        cal.set(Calendar.MILLISECOND, 0);
+        return cal.getTime();
+    }
+
+    // ---------------- R1:铁名归一 ----------------
+
+    @Test
+    void createTask_铁剂任务_标题归一为铁叶酸片() {
+        CreateTaskDTO dto = dto("铁剂1粒+维C", tomorrowAt(7, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        assertEquals("华禧益维生@铁叶酸片1粒+维C", insertedTasks.get(0).getTitle());
+    }
+
+    // ---------------- R4:提醒文案 ----------------
+
+    @Test
+    void createTask_姜黄任务_description附抗凝提醒() {
+        CreateTaskDTO dto = dto("07:00 早餐后:姜黄1粒", tomorrowAt(7, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        assertEquals("07:00 早餐后:姜黄1粒", insertedTasks.get(0).getTitle());
+        assertTrue(insertedTasks.get(0).getDescription()
+                        .contains(TaskHealthRuleService.TURMERIC_REMINDER),
+                "姜黄任务应附「服阿司匹林或华法林时停止执行」");
+    }
+
+    @Test
+    void createTask_铁任务_description附错开提醒() {
+        CreateTaskDTO dto = dto("07:00 早餐后:华禧益维生@铁叶酸片1粒", tomorrowAt(7, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        assertTrue(insertedTasks.get(0).getDescription()
+                        .contains(TaskHealthRuleService.IRON_SEPARATION_REMINDER),
+                "铁任务应附「与钙片、茶、咖啡、姜黄素间隔2小时以上」");
+    }
+
+    @Test
+    void createTask_普通任务_描述不变() {
+        CreateTaskDTO dto = dto("睡前阅读30分钟", tomorrowAt(21, 30));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        assertEquals("睡前阅读30分钟", insertedTasks.get(0).getTitle());
+    }
+
+    // ---------------- R3:抗凝药停姜黄(拒绝创建) ----------------
+
+    @Test
+    void createTask_姜黄且有当日抗凝任务_抛出异常不创建() {
+        // 同日执行人已有抗凝药任务
+        Task anticoagulant = new Task();
+        anticoagulant.setId(900L);
+        anticoagulant.setFamilyId(1L);
+        anticoagulant.setExecutorId(11L);
+        anticoagulant.setTitle("08:00 早餐后:华法林2.5mg");
+        anticoagulant.setDeadline(tomorrowAt(8, 0));
+        List<Task> existing = new ArrayList<>();
+        existing.add(anticoagulant);
+        when(taskMapper.selectList(any(Wrapper.class))).thenAnswer(inv -> existing);
+
+        CreateTaskDTO dto = dto("07:00 早餐后:姜黄1粒", tomorrowAt(7, 0));
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                () -> service.createTask(1L, dto));
+        assertTrue(ex.getMessage().contains("阿司匹林") || ex.getMessage().contains("华法林"),
+                "拒绝消息应提示抗凝药停姜黄,实际: " + ex.getMessage());
+        assertEquals(0, insertedTasks.size(), "拒绝创建时不得落库");
+    }
+
+    @Test
+    void createTask_姜黄且无当日抗凝任务_正常创建() {
+        CreateTaskDTO dto = dto("07:00 早餐后:姜黄1粒", tomorrowAt(7, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        assertNotNull(insertedTasks.get(0).getId());
+    }
+
+    // ---------------- R2:铁错开 ≥2h(自动挪 deadline) ----------------
+
+    @Test
+    void createTask_铁任务与同日钙片冲突_自动挪到当晚22点() {
+        // 同日执行人已有钙片任务 07:30(与铁 07:00 差 30min <2h)
+        Task calcium = new Task();
+        calcium.setId(901L);
+        calcium.setFamilyId(1L);
+        calcium.setExecutorId(11L);
+        calcium.setTitle("07:30 早餐后:钙片1粒");
+        calcium.setDeadline(tomorrowAt(7, 30));
+        List<Task> existing = new ArrayList<>();
+        existing.add(calcium);
+
+        // 调用顺序:createSingleTask 内 applyManualTaskHealthRules 的 context 查询先执行(返回已有冲突任务),
+        // insertTaskWithDedup 的幂等查询后执行(返回空,不拦截)。
+        final int[] callCount = {0};
+        when(taskMapper.selectList(any(Wrapper.class))).thenAnswer(inv -> {
+            int n = callCount[0]++;
+            if (n == 0) {
+                return existing; // R2/R3 context 查询:返回同日冲突任务
+            }
+            return Collections.<Task>emptyList(); // 幂等查询:无重复
+        });
+
+        CreateTaskDTO dto = dto("07:00 早餐后:铁剂1粒", tomorrowAt(7, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        Task created = insertedTasks.get(0);
+        Calendar cal = new GregorianCalendar();
+        cal.setTime(created.getDeadline());
+        assertEquals(22, cal.get(Calendar.HOUR_OF_DAY), "铁应被挪到当晚 22:00");
+        assertEquals("07:00 早餐后:华禧益维生@铁叶酸片1粒", created.getTitle());
+    }
+
+    @Test
+    void createTask_铁任务与同日冲突物差1h_自动挪走() {
+        Task turmeric = new Task();
+        turmeric.setId(902L);
+        turmeric.setFamilyId(1L);
+        turmeric.setExecutorId(11L);
+        turmeric.setTitle("11:00 午餐前:姜黄1粒");
+        turmeric.setDeadline(tomorrowAt(11, 0));
+        List<Task> existing = new ArrayList<>();
+        existing.add(turmeric);
+
+        final int[] callCount = {0};
+        when(taskMapper.selectList(any(Wrapper.class))).thenAnswer(inv -> {
+            int n = callCount[0]++;
+            if (n == 0) return existing; // R2/R3 context 查询
+            return Collections.<Task>emptyList(); // 幂等查询
+        });
+
+        // 铁 09:00 与姜黄 11:00 相差 2h(恰好 ≥2h)→ 不挪
+        CreateTaskDTO dto = dto("09:00 早餐后:华禧益维生@铁叶酸片1粒", tomorrowAt(9, 0));
+
+        service.createTask(1L, dto);
+
+        assertEquals(1, insertedTasks.size());
+        Task created = insertedTasks.get(0);
+        Calendar cal = new GregorianCalendar();
+        cal.setTime(created.getDeadline());
+        assertEquals(9, cal.get(Calendar.HOUR_OF_DAY), "差2h 不应挪");
+    }
+}

+ 197 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/TaskHealthRuleHookTest.java

@@ -0,0 +1,197 @@
+package com.etotem.cfc.unit;
+
+import com.etotem.cfc.entity.HealthPlan;
+import com.etotem.cfc.entity.Task;
+import com.etotem.cfc.service.TaskHealthRuleService;
+import com.etotem.cfc.service.impl.HealthPlanServiceImpl;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+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.assertTrue;
+
+/**
+ * 挂点测试:健康方案 → 任务模板生成处应用全局规则。
+ * <ul>
+ *   <li>applyPlanDraftRules(drafts):R1 铁名归一 / R2 铁与钙姜黄错开≥2h / R3 抗凝停姜黄(标题层)</li>
+ *   <li>newPlanTask(draft):R4 按标题附提醒文案(姜黄/铁)</li>
+ * </ul>
+ * applyPlanDraftRules 与 newPlanTask 均为 private,通过反射驱动;TaskDraft 为私有内部类。
+ */
+class TaskHealthRuleHookTest {
+
+    private HealthPlanServiceImpl planService;
+    private final TaskHealthRuleService ruleService = new TaskHealthRuleService();
+    private Method applyMethod;
+    private Method newPlanTaskMethod;
+    private Class<?> draftClass;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        planService = new HealthPlanServiceImpl();
+        Field f = HealthPlanServiceImpl.class.getDeclaredField("taskHealthRuleService");
+        f.setAccessible(true);
+        f.set(planService, ruleService);
+
+        applyMethod = HealthPlanServiceImpl.class.getDeclaredMethod("applyPlanDraftRules", List.class);
+        applyMethod.setAccessible(true);
+        newPlanTaskMethod = HealthPlanServiceImpl.class.getDeclaredMethod(
+                "newPlanTask", HealthPlan.class, Long.class, Long.class, Long.class, Long.class,
+                draftClassOf(), Date.class);
+        newPlanTaskMethod.setAccessible(true);
+
+        draftClass = draftClassOf();
+    }
+
+    private Class<?> draftClassOf() throws ClassNotFoundException {
+        return Class.forName("com.etotem.cfc.service.impl.HealthPlanServiceImpl$TaskDraft");
+    }
+
+    private Object draft(String title, String category, String dimension, String frequency) throws Exception {
+        Constructor<?> ctor = draftClass.getDeclaredConstructor(String.class, String.class, String.class, String.class);
+        ctor.setAccessible(true);
+        return ctor.newInstance(title, category, dimension, frequency);
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<Object> apply(List<Object> drafts) throws Exception {
+        return (List<Object>) applyMethod.invoke(planService, drafts);
+    }
+
+    private String titleOf(Object draft) throws Exception {
+        Field tf = draftClass.getDeclaredField("title");
+        tf.setAccessible(true);
+        return (String) tf.get(draft);
+    }
+
+    // ---------------- R1+R3:标题层规则 ----------------
+
+    @Test
+    void applyPlanDraftRules_铁名归一_方案内铁剂换成铁叶酸片() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("07:00 早餐后:铁剂1粒+维C", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(1, out.size());
+        assertTrue(titleOf(out.get(0)).contains("华禧益维生@铁叶酸片"), "铁名应归一");
+    }
+
+    @Test
+    void applyPlanDraftRules_铁与姜黄同刻_铁挪走姜黄保留() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("07:00 早餐后:铁剂1粒+维C", "使用任务", "body", "daily"),
+                draft("07:00 早餐后:姜黄1粒", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(2, out.size());
+        String turmeric = titleOf(out.get(1));
+        assertTrue(turmeric.startsWith("07:00"), "姜黄保留原时刻");
+        String iron = titleOf(out.get(0));
+        assertFalse(iron.startsWith("07:00"), "铁应被挪离 07:00");
+    }
+
+    @Test
+    void applyPlanDraftRules_含华法林_姜黄草稿被移除() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("07:00 早餐后:姜黄1粒", "使用任务", "body", "daily"),
+                draft("08:00 早餐后:华法林2.5mg", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(1, out.size());
+        assertFalse(titleOf(out.get(0)).contains("姜黄"), "含华法林时姜黄草稿应被移除");
+        assertTrue(titleOf(out.get(0)).contains("华法林"));
+    }
+
+    @Test
+    void applyPlanDraftRules_含阿司匹林_姜黄草稿被移除() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("07:00 早餐后:姜黄1粒", "使用任务", "body", "daily"),
+                draft("08:00 早餐后:阿司匹林100mg", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(1, out.size());
+        assertFalse(titleOf(out.get(0)).contains("姜黄"));
+    }
+
+    @Test
+    void applyPlanDraftRules_无抗凝_姜黄保留() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("07:00 早餐后:姜黄1粒", "使用任务", "body", "daily"),
+                draft("08:00 早餐后:益生菌1袋", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(2, out.size());
+        assertTrue(titleOf(out.get(0)).contains("姜黄"));
+    }
+
+    @Test
+    void applyPlanDraftRules_购买任务不受规则影响() throws Exception {
+        List<Object> drafts = new ArrayList<>(Arrays.asList(
+                draft("购买华禧益维生@铁叶酸片", "购买任务", "wealth", "once"),
+                draft("08:00 早餐后:华法林2.5mg", "使用任务", "body", "daily")));
+
+        List<Object> out = apply(drafts);
+
+        assertEquals(2, out.size(), "购买任务与华法林任务都应保留");
+        assertTrue(titleOf(out.get(0)).contains("铁叶酸片"));
+        assertTrue(titleOf(out.get(1)).contains("华法林"));
+    }
+
+    // ---------------- R4:newPlanTask 附提醒文案 ----------------
+
+    @Test
+    void newPlanTask_姜黄任务_附抗凝提醒文案() throws Exception {
+        HealthPlan plan = new HealthPlan();
+        plan.setId(1L);
+        Object draft = draft("07:00 早餐后:姜黄1粒", "使用任务", "body", "daily");
+
+        Task task = (Task) newPlanTaskMethod.invoke(planService,
+                plan, 1L, 10L, 10L, 10L, draft, new Date());
+
+        assertNotNull(task);
+        assertTrue(task.getDescription().contains(TaskHealthRuleService.TURMERIC_REMINDER),
+                "姜黄任务 description 应附「服阿司匹林或华法林时停止执行」");
+    }
+
+    @Test
+    void newPlanTask_铁任务_附错开提醒文案() throws Exception {
+        HealthPlan plan = new HealthPlan();
+        plan.setId(1L);
+        Object draft = draft("07:00 早餐后:华禧益维生@铁叶酸片1粒", "使用任务", "body", "daily");
+
+        Task task = (Task) newPlanTaskMethod.invoke(planService,
+                plan, 1L, 10L, 10L, 10L, draft, new Date());
+
+        assertNotNull(task);
+        assertTrue(task.getDescription().contains(TaskHealthRuleService.IRON_SEPARATION_REMINDER),
+                "铁任务 description 应附「与钙片、茶、咖啡、姜黄素间隔2小时以上」");
+    }
+
+    @Test
+    void newPlanTask_普通任务_无提醒文案() throws Exception {
+        HealthPlan plan = new HealthPlan();
+        plan.setId(1L);
+        Object draft = draft("08:00 早餐后:益生菌1袋", "使用任务", "body", "daily");
+
+        Task task = (Task) newPlanTaskMethod.invoke(planService,
+                plan, 1L, 10L, 10L, 10L, draft, new Date());
+
+        assertNotNull(task);
+        assertEquals("", task.getDescription(), "普通任务不应附提醒文案");
+    }
+}

+ 246 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/TaskHealthRuleServiceTest.java

@@ -0,0 +1,246 @@
+package com.etotem.cfc.unit;
+
+import com.etotem.cfc.service.TaskHealthRuleService;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+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;
+
+/**
+ * 任务健康规则引擎测试:铁补充剂名归一 + 姜黄素/补铁错开 + 阿司匹林华法林停姜黄 + 提醒文案。
+ */
+class TaskHealthRuleServiceTest {
+
+    private final TaskHealthRuleService service = new TaskHealthRuleService();
+
+    // ---------------- ① 铁名归一(R1:铁补充剂 → 华禧益维生@铁叶酸片) ----------------
+
+    @Test
+    void normalizeIronName_铁剂_替换为铁叶酸片() {
+        assertEquals("华禧益维生@铁叶酸片+维C",
+                service.normalizeIronName("铁剂+维C"));
+    }
+
+    @Test
+    void normalizeIronName_铁剂含剂量_保留剂量文本() {
+        assertEquals("华禧益维生@铁叶酸片1粒(或隔日)+维C",
+                service.normalizeIronName("铁剂1粒(或隔日)+维C"));
+    }
+
+    @Test
+    void normalizeIronName_力蜚能铁_替换并保留剂量() {
+        assertEquals("华禧益维生@铁叶酸片1粒+维C",
+                service.normalizeIronName("力蜚能铁1粒+维C"));
+    }
+
+    @Test
+    void normalizeIronName_铁剂嵌入多成分行_仅替换铁名() {
+        assertEquals("07:00 早餐后:华禧益维生@铁叶酸片1粒+维C / 和安氨基酸1粒",
+                service.normalizeIronName("07:00 早餐后:力蜚能铁1粒+维C / 和安氨基酸1粒"));
+    }
+
+    @Test
+    void normalizeIronName_复查铁蛋白_不替换() {
+        assertEquals("复查血清铁蛋白(评估储存铁恢复)",
+                service.normalizeIronName("复查血清铁蛋白(评估储存铁恢复)"));
+    }
+
+    @Test
+    void normalizeIronName_铁缺乏评估_不替换() {
+        assertEquals("复查血常规(血红蛋白,评估铁缺乏改善)",
+                service.normalizeIronName("复查血常规(血红蛋白,评估铁缺乏改善)"));
+    }
+
+    @Test
+    void normalizeIronName_无铁_原样返回() {
+        assertEquals("早餐后散步15-20分钟",
+                service.normalizeIronName("早餐后散步15-20分钟"));
+    }
+
+    // ---------------- ② 姜黄素识别(R2:姜黄素 vs 铁错开 ≥2h) ----------------
+
+    @Test
+    void containsTurmeric_姜黄任务_识别() {
+        assertTrue(service.containsTurmeric("姜黄1粒"));
+        assertTrue(service.containsTurmeric("【第三阶段】07:00 早餐后:姜黄1粒 / Akk菌1粒"));
+    }
+
+    @Test
+    void containsTurmeric_无姜黄_不识别() {
+        assertFalse(service.containsTurmeric("铁剂1粒+维C"));
+        assertFalse(service.containsTurmeric("乐力畅50+益生菌1袋"));
+    }
+
+    // ---------------- ③ 阿司匹林/华法林识别(R3:服阿司匹林/华法林停姜黄) ----------------
+
+    @Test
+    void containsAnticoagulant_阿司匹林_识别() {
+        assertTrue(service.containsAnticoagulant("阿司匹林100mg"));
+        assertTrue(service.containsAnticoagulant("华法林2.5mg"));
+    }
+
+    @Test
+    void containsAnticoagulant_无_不识别() {
+        assertFalse(service.containsAnticoagulant("姜黄1粒"));
+        assertFalse(service.containsAnticoagulant(""));
+    }
+
+    // ---------------- ④ 铁 vs 钙/姜黄 错开 ≥2h(R2 排期冲突) ----------------
+
+    @Test
+    void resolveIronConflicts_铁与姜黄同刻_铁挪到次日凌晨时段() {
+        List<String> result = service.resolveIronConflicts(Arrays.asList(
+                "07:00 早餐后:铁剂1粒+维C",
+                "07:00 早餐后:姜黄1粒"));
+
+        // 铁为机动方:与姜黄同刻(差0h<2h) → 铁挪走,姜黄保留
+        assertEquals(2, result.size());
+        String ironTitle = result.stream().filter(t -> t.contains("铁叶酸片")).findFirst().orElse("");
+        String turmericTitle = result.stream().filter(t -> t.contains("姜黄")).findFirst().orElse("");
+        assertTrue(ironTitle.contains("华禧益维生@铁叶酸片"), "铁名归一应同时生效");
+        assertTrue(service.isIronSeparatedFromConflicts(ironTitle, result),
+                "铁必须与所有冲突物(钙/姜黄/茶咖啡)间隔≥2h");
+        assertEquals("07:00 早餐后:姜黄1粒", turmericTitle, "姜黄保留原时刻");
+    }
+
+    @Test
+    void resolveIronConflicts_铁与钙片差1h_铁挪走() {
+        List<String> result = service.resolveIronConflicts(Arrays.asList(
+                "08:00 早餐后:铁剂1粒",
+                "09:00 早餐后:钙片1粒"));
+
+        String ironTitle = result.stream().filter(t -> t.contains("铁叶酸片")).findFirst().orElse("");
+        assertTrue(service.isIronSeparatedFromConflicts(ironTitle, result),
+                "铁与钙片差1h<2h 必须自动挪开");
+    }
+
+    @Test
+    void resolveIronConflicts_铁与姜黄差4h_不挪动() {
+        List<String> result = service.resolveIronConflicts(Arrays.asList(
+                "07:00 早餐后:铁剂1粒",
+                "11:00 午餐前:姜黄1粒"));
+
+        String ironTitle = result.stream().filter(t -> t.contains("铁叶酸片")).findFirst().orElse("");
+        assertTrue(service.isIronSeparatedFromConflicts(ironTitle, result),
+                "差4h≥2h 不需要挪动");
+    }
+
+    @Test
+    void resolveIronConflicts_无冲突物_不改变时间() {
+        List<String> result = service.resolveIronConflicts(Arrays.asList(
+                "07:00 早餐后:铁剂1粒",
+                "08:00 早餐后:益生菌1袋"));
+
+        String ironTitle = result.stream().filter(t -> t.contains("铁叶酸片")).findFirst().orElse("");
+        assertTrue(ironTitle.startsWith("07:00"), "无冲突时铁保持原时间");
+    }
+
+    // ---------------- ⑤ R3:阿司匹林/华法林在场时移除姜黄 ----------------
+
+    @Test
+    void suppressTurmericWithAnticoagulant_有华法林_移除姜黄任务() {
+        List<String> result = service.suppressTurmericWithAnticoagulant(Arrays.asList(
+                "07:00 早餐后:姜黄1粒",
+                "08:00 早餐后:华法林2.5mg"));
+
+        assertFalse(result.stream().anyMatch(t -> t.contains("姜黄")),
+                "任务集中含华法林时不得安排姜黄素");
+        assertEquals(1, result.size(), "仅移除姜黄任务,其余保留");
+    }
+
+    @Test
+    void suppressTurmericWithAnticoagulant_有阿司匹林_移除姜黄任务() {
+        List<String> result = service.suppressTurmericWithAnticoagulant(Arrays.asList(
+                "07:00 早餐后:姜黄1粒",
+                "08:00 早餐后:阿司匹林100mg"));
+
+        assertFalse(result.stream().anyMatch(t -> t.contains("姜黄")));
+    }
+
+    @Test
+    void suppressTurmericWithAnticoagulant_无抗凝药_保留姜黄() {
+        List<String> result = service.suppressTurmericWithAnticoagulant(Arrays.asList(
+                "07:00 早餐后:姜黄1粒",
+                "08:00 早餐后:益生菌1袋"));
+
+        assertEquals(2, result.size());
+        assertTrue(result.contains("07:00 早餐后:姜黄1粒"));
+    }
+
+    // ---------------- ⑥ R4:提醒文案 ----------------
+
+    @Test
+    void buildDescription_姜黄任务_附阿司匹林华法林提醒() {
+        String desc = service.buildDescription("07:00 早餐后:姜黄1粒", "");
+        assertTrue(desc.contains(TaskHealthRuleService.TURMERIC_REMINDER));
+    }
+
+    @Test
+    void buildDescription_铁任务_附错开提醒() {
+        String desc = service.buildDescription("07:00 早餐后:华禧益维生@铁叶酸片1粒", "");
+        assertTrue(desc.contains(TaskHealthRuleService.IRON_SEPARATION_REMINDER));
+    }
+
+    @Test
+    void buildDescription_既有描述_追加不覆盖() {
+        String desc = service.buildDescription("07:00 早餐后:姜黄1粒", "原有备注");
+        assertTrue(desc.startsWith("原有备注"));
+        assertTrue(desc.contains(TaskHealthRuleService.TURMERIC_REMINDER));
+    }
+
+    // ---------------- ⑦ R2 手工任务:铁错开档位选择(供 TaskService 手工创建调用) ----------------
+
+    @Test
+    void pickIronFreeSlot_铁与冲突物同为早上_挪到晚上() {
+        // 铁 07:00 与钙片 07:00 冲突(0h)→ 铁挪当晚 22:00(不同半天)
+        Integer slot = service.pickIronFreeSlot(7 * 60, java.util.Arrays.asList(7 * 60));
+        assertNotNull(slot);
+        assertTrue(slot >= 12 * 60, "冲突物在早上半天时铁应挪到晚上");
+    }
+
+    @Test
+    void pickIronFreeSlot_铁与冲突物同为晚上_挪到次日早上() {
+        // 铁 21:00 与姜黄 21:00 冲突 → 铁挪次日 06:30(跨天表示 1440+6.5h)
+        Integer slot = service.pickIronFreeSlot(21 * 60, java.util.Arrays.asList(21 * 60));
+        assertNotNull(slot);
+        assertTrue(slot >= 24 * 60, "冲突物在晚上半天时铁应挪到次日早上(跨天表示)");
+        int nextDayMinute = slot - 24 * 60;
+        assertTrue(nextDayMinute < 12 * 60, "次日档位应为早上半天");
+    }
+
+    @Test
+    void pickIronFreeSlot_铁与冲突物差1h_挪走后保证2h() {
+        // 铁 09:00、钙片 08:00 → 差 1h <2h,必须挪;挪后 22:00 与 08:00 差 14h
+        Integer slot = service.pickIronFreeSlot(9 * 60, java.util.Arrays.asList(8 * 60));
+        assertNotNull(slot);
+        assertEquals(22 * 60, slot, "冲突物在早上半天时挪到 22:00");
+    }
+
+    @Test
+    void pickIronFreeSlot_铁差4h_无需挪保持原档() {
+        // 铁 07:00 与姜黄 11:00 差 4h ≥2h → 保持 07:00
+        Integer slot = service.pickIronFreeSlot(7 * 60, java.util.Arrays.asList(11 * 60));
+        assertEquals(7 * 60, slot, "已错开≥2h 时保持原档位");
+    }
+
+    @Test
+    void pickIronFreeSlot_无冲突物_保持原档() {
+        Integer slot = service.pickIronFreeSlot(7 * 60, java.util.Collections.emptyList());
+        assertEquals(7 * 60, slot);
+    }
+
+    @Test
+    void pickIronFreeSlot_多个冲突物_取全部满足的档位() {
+        // 铁 07:00,当天钙片 07:30 + 姜黄 20:00 → 铁挪到次日 06:30 后与两者均≥2h
+        Integer slot = service.pickIronFreeSlot(7 * 60,
+                java.util.Arrays.asList(7 * 60 + 30, 20 * 60));
+        assertNotNull(slot);
+        assertTrue(slot >= 24 * 60, "存在晚上冲突物时铁挪次日早上");
+    }
+}