merge(S-cfc-88): sync cfclub (S-cfc-85/86 noPathMap/noSupplement) into task/S-cfc-88 before push

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

@@ -0,0 +1,293 @@
+package com.etotem.cfc.unit;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * 契约级单测：谷禾知识库既有键新字段暴露（能力键 {@code guhe.kb.fieldExpose}，L2-3/T10）。
+ *
+ * <p><b>需求/设计锚点</b>（{@code docs/superpowers/plans/2026-11-08-浠艾福平台程序修改计划.md}）：
+ * <ul>
+ *   <li>§三 任务分解 · P1 · <b>T10 既有键新字段暴露（L2-3）</b>：菌属功能库 [40]/[72]/[73]
+ *       {@code 偏高影响}/{@code 偏低影响}、菌种综合信息「埃希氏菌属」{@code 偏低侧影响}、
+ *       艾德范思大肠杆菌 {@code 健康定植说明} <b>入 L2 查询返回</b>。</li>
+ *   <li>§2.2 既有键补齐（只填空、不覆盖，幂等）：菌属功能库 [40] 埃希氏菌属 / [72] 大肠杆菌 /
+ *       [73] 脆弱拟杆菌（8 字段）、菌种综合信息「埃希氏菌属」{@code 偏低侧影响}、
+ *       艾德范思大肠杆菌 {@code 健康定植说明}。</li>
+ * </ul></p>
+ *
+ * <p><b>C 档平台探测（2026-11-08 自主核实，不假定包路径）</b>：
+ * <ul>
+ *   <li><b>#2 KB 服务加载方式</b>：平台已封装服务层 ——
+ *       {@code com.etotem.cfc.service.UnifiedKnowledgeBaseService}（12 个顶层模块，classpath
+ *       种子 {@code /knowledge-base/统一知识库.json} 兜底；查询入口 {@code getSection} /
+ *       {@code lookupBacteria}（菌属功能库，学名主键 + 属级回退）/ {@code lookupSpeciesInfo}
+ *       （菌种综合信息）/ {@code lookupIndicator} / {@code lookupNutrient}）。</li>
+ *   <li><b>#1 Adapter 形态</b>、<b>#3 L4 引擎</b>、<b>#4 合规门禁挂载点</b>：与本键（L2-3 字段暴露）
+ *       无直接耦合，不进入本契约。</li>
+ * </ul></p>
+ *
+ * <p><b>实现现状（RED 依据）</b>：宿主 {@code UnifiedKnowledgeBaseService} 类已存在，但<b>契约要求
+ * 的新字段数据未落地</b>——种子 {@code 统一知识库.json} 中：
+ * <ul>
+ *   <li>菌属功能库 {@code Escherichia}（埃希氏菌属）/ {@code Escherichia coli}（大肠杆菌）/
+ *       {@code Bacteroides fragilis}（脆弱拟杆菌）的 {@code 偏高影响}/{@code 偏低影响} 键<b>存在但为空字符串</b>；</li>
+ *   <li>菌种综合信息「埃希氏菌属 Escherichia」<b>缺少</b> {@code 偏低侧影响} 键；</li>
+ *   <li>「艾德范思」来源知识及 {@code 健康定植说明} 键<b>全库缺失</b>。</li>
+ * </ul>
+ * 因此本测试以「L2 查询返回必须暴露上述新字段（非空）」为契约断言，当前实现未满足 → 断言失败（红）；
+ * GREEN 阶段由实现方回填种子数据（只填空、不覆盖），服务查询即自动暴露。</p>
+ *
+ * <p><b>测试范围</b>：纯契约级单测 —— 无 Spring 容器 / 无 DB / 无真实微信，仅读 classpath 种子
+ * JSON（与宿主服务加载同源），反射锚定宿主类（避免 import 编译耦合）。</p>
+ *
+ * <p><b>权限流</b>：本能力为后端内部知识库查询（L2 字段暴露），无用户权限维度，权限流不适用，
+ * 以说明性用例标注。</p>
+ *
+ * <p><b>RED 预期</b>：正常流 3 用例在「字段非空」断言处失败（红）——{@code 偏高影响}/{@code 偏低影响}
+ * 为空、{@code 偏低侧影响} 与 {@code 健康定植说明} 缺失；边界流「只填空、不覆盖」守卫生效、
+ * 宿主结构锚点存在（二者当前通过，作为契约不变式/锚点）。</p>
+ */
+class GuheKbFieldExposeContractTest {
+
+    /** L2 宿主（统一知识库服务，12 模块）——契约查询返回承载者。 */
+    private static final String HOST_CLASS = "com.etotem.cfc.service.UnifiedKnowledgeBaseService";
+
+    /** classpath 种子文件（宿主加载源，与 docs 同源）。 */
+    private static final String KB_SEED_CLASSPATH = "knowledge-base/统一知识库.json";
+
+    /** 菌属功能库目标：{学名, 中文名} —— [40]埃希氏菌属 / [72]大肠杆菌 / [73]脆弱拟杆菌（§2.2）。 */
+    private static final String[][] TARGET_BACTERIA = {
+            {"Escherichia", "埃希氏菌属"},
+            {"Escherichia coli", "大肠杆菌"},
+            {"Bacteroides fragilis", "脆弱拟杆菌"}
+    };
+
+    /** 菌种综合信息目标菌种键（§2.2）。 */
+    private static final String SPECIES_INFO_KEY = "埃希氏菌属 Escherichia";
+
+    /** 艾德范思品牌来源标记（§2.2 艾德范思大肠杆菌 健康定植说明）。 */
+    private static final String AIDEFANSI_BRAND = "艾德范思";
+
+    // ==================== 正常流：L2 查询返回必须暴露新字段（T10 L2-3） ====================
+
+    @Test
+    @DisplayName("正常流-1：菌属功能库 [40]/[72]/[73] 应暴露非空 偏高影响/偏低影响")
+    void bacteriaGenus_highLowImpact_exposed() {
+        Map<String, Object> flora = section("菌属功能库");
+        assertNotNull(flora, "[guhe.kb.fieldExpose] 菌属功能库 模块缺失（L2 查询返回承载者）。");
+        for (String[] target : TARGET_BACTERIA) {
+            Map<String, Object> entry = findBacteria(flora, target[0], target[1]);
+            assertNotNull(entry,
+                    "[guhe.kb.fieldExpose] 菌属功能库缺少目标菌属: " + target[1]
+                            + "（学名 " + target[0] + "，契约 [40]/[72]/[73]）。");
+            String high = text(entry.get("偏高影响"));
+            String low = text(entry.get("偏低影响"));
+            assertTrue(high != null && !high.trim().isEmpty(),
+                    "[guhe.kb.fieldExpose] 菌属功能库[" + target[1] + "] 偏高影响 应为非空"
+                            + "（契约 §2.2 既有键补齐，T10 L2-3 入 L2 查询返回）；当前=" + high);
+            assertTrue(low != null && !low.trim().isEmpty(),
+                    "[guhe.kb.fieldExpose] 菌属功能库[" + target[1] + "] 偏低影响 应为非空"
+                            + "（契约 §2.2 既有键补齐，T10 L2-3 入 L2 查询返回）；当前=" + low);
+        }
+    }
+
+    @Test
+    @DisplayName("正常流-2：菌种综合信息「埃希氏菌属」应暴露非空 偏低侧影响")
+    void speciesInfo_escherichia_lowSideImpact_exposed() {
+        Map<String, Object> speciesInfo = section("菌种综合信息");
+        assertNotNull(speciesInfo, "[guhe.kb.fieldExpose] 菌种综合信息 模块缺失。");
+        Object raw = speciesInfo.get("菌种");
+        assertNotNull(raw, "[guhe.kb.fieldExpose] 菌种综合信息 缺少 菌种 节点。");
+        Map<?, ?> species = (Map<?, ?>) raw;
+        Object entryObj = species.get(SPECIES_INFO_KEY);
+        assertNotNull(entryObj,
+                "[guhe.kb.fieldExpose] 菌种综合信息缺少目标菌种: " + SPECIES_INFO_KEY + "。");
+        Map<?, ?> entry = (Map<?, ?>) entryObj;
+        String lowSide = text(entry.get("偏低侧影响"));
+        assertTrue(lowSide != null && !lowSide.trim().isEmpty(),
+                "[guhe.kb.fieldExpose] 菌种综合信息「埃希氏菌属」偏低侧影响 应为非空"
+                        + "（契约 §2.2，T10 L2-3 入 L2 查询返回）；当前=" + lowSide);
+    }
+
+    @Test
+    @DisplayName("正常流-3：艾德范思大肠杆菌应暴露非空 健康定植说明")
+    void aidefansiEcoli_colonizationNote_exposed() {
+        Map<String, Object> root = kbRoot();
+        assertTrue(containsBrand(root, AIDEFANSI_BRAND),
+                "[guhe.kb.fieldExpose] 平台知识库缺少「艾德范思」来源知识"
+                        + "（契约 §2.2 艾德范思大肠杆菌 健康定植说明）；艾德范思品牌未落地。");
+        String note = findNonEmptyStringValue(root, "健康定植说明");
+        assertTrue(note != null && !note.trim().isEmpty(),
+                "[guhe.kb.fieldExpose] 艾德范思大肠杆菌 健康定植说明 应为非空"
+                        + "（契约 §2.2，T10 L2-3 入 L2 查询返回）；当前缺失。");
+    }
+
+    // ==================== 边界流：只填空、不覆盖（幂等） ====================
+
+    @Test
+    @DisplayName("边界流-1：既有键补齐只填空、不覆盖（既有 功能说明 不得被回填清空）")
+    void backfill_additive_doesNotClobberExisting() {
+        Map<String, Object> flora = section("菌属功能库");
+        Map<String, Object> escherichia = findBacteria(flora, "Escherichia", "埃希氏菌属");
+        assertNotNull(escherichia, "菌属功能库缺少 Escherichia。");
+        String func = text(escherichia.get("功能说明"));
+        assertTrue(func != null && !func.trim().isEmpty(),
+                "[guhe.kb.fieldExpose] 既有 功能说明 不得被回填覆盖"
+                        + "（契约 §2.2 只填空、不覆盖，幂等）；功能说明=" + func);
+    }
+
+    // ==================== 宿主契约锚点：L2 查询承载者存在 ====================
+
+    @Test
+    @DisplayName("宿主锚点：UnifiedKnowledgeBaseService 应存在并提供 L2 查询入口")
+    void l2Host_serviceAndQuery_exist() {
+        Class<?> host = loadClass(HOST_CLASS);
+        assertNotNull(host,
+                "[guhe.kb.fieldExpose] L2 宿主 UnifiedKnowledgeBaseService 不存在（T10 L2-3 查询返回承载者）。");
+        assertTrue(hasMethod(host, "getSection"), "应提供 getSection（模块级查询）。");
+        assertTrue(hasMethod(host, "lookupBacteria"), "应提供 lookupBacteria（菌属功能库查询）。");
+        assertTrue(hasMethod(host, "lookupSpeciesInfo"), "应提供 lookupSpeciesInfo（菌种综合信息查询）。");
+    }
+
+    // ==================== 权限流（不适用）：内部知识库查询，无用户权限维度 ====================
+
+    @Test
+    @DisplayName("权限流：本能力为后端内部知识库查询（L2 字段暴露），权限流不适用")
+    void permissionFlow_notApplicable() {
+        // 说明性用例：契约 AC 为「L2 查询返回暴露新字段」内部链路，无用户权限校验维度。
+        assertTrue(true, "权限流不适用：guhe.kb.fieldExpose 为内部知识库查询，无用户权限维度。");
+    }
+
+    // ==================== 数据读取与解析（无 Spring / 无 DB） ====================
+
+    /** 读 classpath 种子 KB 根（与宿主加载同源）。 */
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> kbRoot() {
+        try (InputStream is = getClass().getClassLoader().getResourceAsStream(KB_SEED_CLASSPATH)) {
+            assertNotNull(is, "classpath 种子不存在: " + KB_SEED_CLASSPATH);
+            return new ObjectMapper().readValue(is, new TypeReference<Map<String, Object>>() {});
+        } catch (Exception e) {
+            throw new IllegalStateException("解析种子KB失败: " + e.getMessage(), e);
+        }
+    }
+
+    /** 取指定顶层模块（sectionMap.get(moduleKey)）。 */
+    private Map<String, Object> section(String moduleKey) {
+        Map<String, Object> root = kbRoot();
+        Object obj = root.get(moduleKey);
+        if (obj instanceof Map) {
+            return (Map<String, Object>) obj;
+        }
+        return null;
+    }
+
+    /** 在 菌属功能库.菌属 数组中按 学名/中文名 定位条目。 */
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> findBacteria(Map<String, Object> flora, String latin, String cnName) {
+        Object raw = flora.get("菌属");
+        if (!(raw instanceof List)) {
+            return null;
+        }
+        for (Object item : (List<Object>) raw) {
+            if (!(item instanceof Map)) {
+                continue;
+            }
+            Map<String, Object> entry = (Map<String, Object>) item;
+            if (latin.equals(entry.get("学名")) || cnName.equals(entry.get("中文名"))) {
+                return entry;
+            }
+        }
+        return null;
+    }
+
+    /** 深度遍历：任一 字符串值/键 包含品牌标记。 */
+    @SuppressWarnings("unchecked")
+    private boolean containsBrand(Object node, String brand) {
+        if (node == null) {
+            return false;
+        }
+        if (node instanceof Map) {
+            for (Map.Entry<?, ?> e : ((Map<?, ?>) node).entrySet()) {
+                if (String.valueOf(e.getKey()).contains(brand)) {
+                    return true;
+                }
+                if (containsBrand(e.getValue(), brand)) {
+                    return true;
+                }
+            }
+        } else if (node instanceof List) {
+            for (Object item : (List<Object>) node) {
+                if (containsBrand(item, brand)) {
+                    return true;
+                }
+            }
+        } else if (node instanceof String) {
+            return ((String) node).contains(brand);
+        }
+        return false;
+    }
+
+    /** 深度遍历：返回首个指定键的非空字符串值。 */
+    @SuppressWarnings("unchecked")
+    private String findNonEmptyStringValue(Object node, String fieldKey) {
+        if (node == null) {
+            return null;
+        }
+        if (node instanceof Map) {
+            for (Map.Entry<?, ?> e : ((Map<?, ?>) node).entrySet()) {
+                if (fieldKey.equals(String.valueOf(e.getKey()))) {
+                    String v = text(e.getValue());
+                    if (v != null && !v.trim().isEmpty()) {
+                        return v;
+                    }
+                }
+                String found = findNonEmptyStringValue(e.getValue(), fieldKey);
+                if (found != null) {
+                    return found;
+                }
+            }
+        } else if (node instanceof List) {
+            for (Object item : (List<Object>) node) {
+                String found = findNonEmptyStringValue(item, fieldKey);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    // ==================== 反射辅助 ====================
+
+    private Class<?> loadClass(String name) {
+        try {
+            return Class.forName(name, false, Thread.currentThread().getContextClassLoader());
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    private boolean hasMethod(Class<?> clazz, String methodName) {
+        for (Method m : clazz.getDeclaredMethods()) {
+            if (m.getName().equals(methodName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private String text(Object v) {
+        return v == null ? null : String.valueOf(v);
+    }
+}

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

@@ -0,0 +1,225 @@
+package com.etotem.cfc.unit;
+
+import com.etotem.cfc.constant.AttributionLowSideRules;
+import com.etotem.cfc.service.attribution.AttributionComplianceGate;
+import com.etotem.cfc.service.attribution.IndicatorInterpretEngine;
+import com.etotem.cfc.service.attribution.model.IndicatorReading;
+import com.etotem.cfc.service.attribution.model.MemberAttribution;
+import com.etotem.cfc.service.attribution.model.MemberProfile;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * 契约级单测：谷禾 v2 低侧口径「低位补菌红线」（能力键 {@code guhe.lowSide.noSupplement}）。
+ *
+ * <p>契约来源（2026-11-08《浠艾福平台程序修改计划（guhe_v2 兼容 · 知识库低侧口径 · 专家同步）》§三任务分解 T4，P0）：
+ * <blockquote>
+ *   T4 低位补菌红线（L4-3）：<b>无成熟证据支持「缺大肠杆菌→补大肠杆菌」</b>；
+ *   ⛔ 禁「报告缺 X → 买含 X 菌株产品」桥接（叠加 §5.2 16S 粒度声明）。
+ *   <br>验收：任意「偏低」归因节点 {@code association_only==true}；存量无「缺大肠杆菌→补菌」措辞；
+ *   低侧机制证据全部标 PUB/KB。
+ * </blockquote></p>
+ *
+ * <p><b>契约语义</b>：本能力键不是「事后文本扫描」而是 <b>L4 归因引擎层面的禁补菌红线</b> ——
+ * 归因引擎对任意「偏低」归因节点（含条件致病菌如大肠杆菌）<b>不生成补菌建议</b>，
+ * 并在解读产出中显式携带「偏低不推荐补菌」口径（无成熟证据支持缺X→补X），
+ * 使「报告缺 X → 买含 X 菌株产品」桥接在 <b>源头</b>被拦截，而非仅靠门禁事后回扫。</p>
+ *
+ * <p><b>实现现状（src/main 探测，2026-11-08）</b>：L4 归因引擎与 G-1 门禁已落地
+ * （{@code IndicatorInterpretEngine} / {@code AttributionComplianceGate} / {@code AttributionLowSideRules}），
+ * 但已落地的是 <b>T5 G-1 低侧红线组</b>（{@code association_only} / {@code no_causal_bridge} /
+ * {@code no_prescription} 三规则码 + 措辞白名单 + 门禁文本回扫 {@code scan}）。
+ * <b>T4 低位补菌红线（L4-3）未落地</b>：{@code AttributionLowSideRules} 无独立
+ * {@code no_supplement} 规则码、无「偏低不推荐补菌」口径常量；{@code LowSideNode} 无节点级
+ * 禁补菌标记；{@code IndicatorInterpretEngine} 对偏低节点仅产通用「先医后补」含义，未产
+ * 「不推荐补菌」口径。故本测试以「反射结构 + 纯规则行为」双通道探测实现缺失：能编译、
+ * 能运行、断言失败（红），失败断言原文清晰可贴。</p>
+ *
+ * <p><b>GREEN 升级指引</b>：实现者在 {@code AttributionLowSideRules} 增加
+ * {@code RULE_NO_SUPPLEMENT="no_supplement"} 与 {@code NO_SUPPLEMENT_HINT}（含「不推荐补菌」），
+ * 在 {@code AttributionComplianceGate.LowSideNode} 暴露 {@code isNoSupplement()}（低侧节点恒 true），
+ * 并在 {@code IndicatorInterpretEngine} 的偏低含义生成路径注入「偏低不推荐补菌」口径后，本测试自动转绿。</p>
+ *
+ * <p><b>权限流说明</b>：本能力为后端内部 L4 归因规则，无用户权限维度，权限流不适用，以说明性用例标注。</p>
+ */
+class GuheLowSideNoSupplementContractTest {
+
+    /** T4 期望的独立规则码（区别于 T5 的 no_causal_bridge） */
+    private static final String RULE_NO_SUPPLEMENT = "no_supplement";
+
+    /** T4 期望的「偏低不推荐补菌」口径常量名 */
+    private static final String HINT_FIELD = "NO_SUPPLEMENT_HINT";
+
+    /** T4 期望的节点级禁补菌标记方法名 */
+    private static final String NODE_FLAG_METHOD = "isNoSupplement";
+
+    // ------------------------------------------------------------------
+    // 正常流：规则层应暴露独立的 low-side 禁补菌红线（T4 规则码 + 口径）
+    // ------------------------------------------------------------------
+
+    @Test
+    @DisplayName("正常流-1：AttributionLowSideRules 应暴露 RULE_NO_SUPPLEMENT 规则码")
+    void lowSideRules_exposesNoSupplementRuleCode() {
+        Field f = declaredField(AttributionLowSideRules.class, "RULE_NO_SUPPLEMENT");
+        assertNotNull(f,
+                "[guhe.lowSide.noSupplement] AttributionLowSideRules 缺少 RULE_NO_SUPPLEMENT 规则码："
+                        + "T4（L4-3）要求独立「低位补菌红线」——无成熟证据支持「缺大肠杆菌→补大肠杆菌」。"
+                        + "当前仅落地 T5 的 no_causal_bridge，未区分「引擎不产出补菌建议」与「文本回扫」。");
+        try {
+            Object v = f.get(null);
+            assertNotNull(v, "[guhe.lowSide.noSupplement] RULE_NO_SUPPLEMENT 常量值不应为 null。");
+            assertTrue(RULE_NO_SUPPLEMENT.equals(String.valueOf(v)),
+                    "[guhe.lowSide.noSupplement] RULE_NO_SUPPLEMENT 应取值为 \"" + RULE_NO_SUPPLEMENT
+                            + "\"，实际为 \"" + v + "\"。");
+        } catch (IllegalAccessException e) {
+            assertTrue(false, "[guhe.lowSide.noSupplement] 读取 RULE_NO_SUPPLEMENT 失败：" + e.getMessage());
+        }
+    }
+
+    @Test
+    @DisplayName("正常流-2：AttributionLowSideRules 应暴露「偏低不推荐补菌」口径常量")
+    void lowSideRules_exposesNoSupplementHintWording() {
+        Field f = declaredField(AttributionLowSideRules.class, HINT_FIELD);
+        assertNotNull(f,
+                "[guhe.lowSide.noSupplement] AttributionLowSideRules 缺少 " + HINT_FIELD
+                        + " 口径常量：T4 要求「偏低不推荐补菌」显式口径（无成熟证据支持缺X→补X），"
+                        + "供 L4 引擎与报告侧引用，而非仅通用「先医后补」。");
+        try {
+            Object v = f.get(null);
+            assertNotNull(v, "[guhe.lowSide.noSupplement] " + HINT_FIELD + " 常量值不应为 null。");
+            String text = String.valueOf(v);
+            assertTrue(text.contains("不推荐补菌"),
+                    "[guhe.lowSide.noSupplement] " + HINT_FIELD + " 应含「不推荐补菌」口径（§5.1.1 专家口径第四条），"
+                            + "实际为：「" + text + "」。");
+            assertTrue(text.contains("缺"),
+                    "[guhe.lowSide.noSupplement] " + HINT_FIELD + " 应含「无成熟证据支持缺X→补X」表述，"
+                            + "实际为：「" + text + "」。");
+        } catch (IllegalAccessException e) {
+            assertTrue(false, "[guhe.lowSide.noSupplement] 读取 " + HINT_FIELD + " 失败：" + e.getMessage());
+        }
+    }
+
+    @Test
+    @DisplayName("正常流-3：低侧节点应暴露节点级禁补菌标记 isNoSupplement()")
+    void lowSideNode_exposesNoSupplementFlag() {
+        boolean hasFlag = false;
+        for (Method m : AttributionComplianceGate.LowSideNode.class.getDeclaredMethods()) {
+            if (NODE_FLAG_METHOD.equals(m.getName())) {
+                hasFlag = true;
+                break;
+            }
+        }
+        assertTrue(hasFlag,
+                "[guhe.lowSide.noSupplement] AttributionComplianceGate.LowSideNode 缺少 " + NODE_FLAG_METHOD
+                        + "() 节点级禁补菌标记：T4 要求「偏低」归因节点在源头即标注不推荐补菌，"
+                        + "而非仅门禁事后回扫。");
+    }
+
+    // ------------------------------------------------------------------
+    // 边界流：L4 解读引擎对「偏低」条件致病菌节点不产补菌建议（源头拦截）
+    // ------------------------------------------------------------------
+
+    @Test
+    @DisplayName("边界流-1：偏低大肠杆菌节点的干预含义应携带「不推荐补菌」口径")
+    void interpret_lowSideEColi_meaningCarriesNoSupplementRedline() {
+        IndicatorReading reading = lowSideEColi();
+        MemberProfile member = profile();
+        IndicatorInterpretEngine engine = new IndicatorInterpretEngine();
+
+        List<MemberAttribution> attrs = engine.interpret(Collections.singletonList(reading),
+                Collections.singletonList(member));
+        assertNotNull(attrs, "[guhe.lowSide.noSupplement] interpret 不应返回 null。");
+        assertFalse(attrs.isEmpty(), "[guhe.lowSide.noSupplement] interpret 应产出至少 1 人归因。");
+        IndicatorReading out = attrs.get(0).getReadings().get(0);
+        String meaning = out.getMeaning() == null ? "" : out.getMeaning();
+        assertTrue(meaning.contains("不推荐补菌"),
+                "[guhe.lowSide.noSupplement] 偏低大肠杆菌节点干预含义应携带「偏低不推荐补菌」口径"
+                        + "（T4 L4-3，无成熟证据支持缺X→补X），实际为：「" + meaning + "」。"
+                        + "当前仅产通用「先医后补」，未落地 T4 源头禁补菌。");
+    }
+
+    @Test
+    @DisplayName("边界流-2：偏低大肠杆菌节点的应对方向不得含补菌产品桥接措辞")
+    void interpret_lowSideEColi_actionsContainNoSupplementBridge() {
+        IndicatorReading reading = lowSideEColi();
+        MemberProfile member = profile();
+        IndicatorInterpretEngine engine = new IndicatorInterpretEngine();
+
+        List<MemberAttribution> attrs = engine.interpret(Collections.singletonList(reading),
+                Collections.singletonList(member));
+        for (String action : attrs.get(0).getActions()) {
+            assertFalse(containsSupplementBridge(action),
+                    "[guhe.lowSide.noSupplement] 偏低大肠杆菌节点应对方向不得含「补菌产品」桥接措辞"
+                            + "（⛔ 禁「报告缺 X → 买含 X 菌株产品」），实际为：「" + action + "」。");
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // 权限流（不适用）：后端内部 L4 归因规则，无用户权限维度
+    // ------------------------------------------------------------------
+
+    @Test
+    @DisplayName("权限流：本能力为后端内部 L4 归因规则，无用户权限维度，权限流不适用")
+    void permissionFlow_notApplicable() {
+        // 说明性用例：契约 AC 为「L4 归因引擎 → 低侧禁补菌」内部规则，无权限校验维度。
+        assertTrue(true, "权限流不适用：guhe.lowSide.noSupplement 为后端内部 L4 归因规则，无用户权限维度。");
+    }
+
+    // ------------------------------------------------------------------
+    // 反射与数据构造辅助
+    // ------------------------------------------------------------------
+
+    private static Field declaredField(Class<?> clazz, String name) {
+        for (Field f : clazz.getDeclaredFields()) {
+            if (f.getName().equals(name)) {
+                f.setAccessible(true);
+                return f;
+            }
+        }
+        return null;
+    }
+
+    /** 偏低条件致病菌读数（大肠杆菌，P3，参考下限 0 / ND 口径） */
+    private static IndicatorReading lowSideEColi() {
+        IndicatorReading r = new IndicatorReading();
+        r.setMemberId(1L);
+        r.setMemberName("妈妈");
+        r.setCode("Escherichia_coli");
+        r.setDisplayName("大肠杆菌");
+        r.setValue("0.5%");
+        r.setPercentile("P3");
+        r.setStatus(IndicatorReading.STATUS_LOW);
+        r.setBand(IndicatorReading.BAND_LOW);
+        return r;
+    }
+
+    private static MemberProfile profile() {
+        MemberProfile p = new MemberProfile();
+        p.setMemberId(1L);
+        p.setName("妈妈");
+        p.setRole("mom");
+        p.setRoleLabel("妈妈");
+        return p;
+    }
+
+    /** 补菌产品桥接措辞（「报告缺 X → 买含 X 菌株产品」） */
+    private static boolean containsSupplementBridge(String text) {
+        if (text == null) {
+            return false;
+        }
+        String t = text;
+        return t.contains("补大肠杆菌") || t.contains("补充大肠杆菌")
+                || t.contains("补菌") || t.contains("需要补充") || t.contains("需补充")
+                || t.contains("买含") || t.contains("购买") || t.contains("选购")
+                || t.contains("下单") || t.contains("菌株产品");
+    }
+}

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

@@ -0,0 +1,322 @@
+package com.etotem.cfc.unit;
+
+import com.etotem.cfc.constant.AttributionLowSideRules;
+import com.etotem.cfc.constant.AttributionWeights;
+import com.etotem.cfc.service.attribution.FiveDimAttributionEngine;
+import com.etotem.cfc.service.attribution.model.IndicatorReading;
+import com.etotem.cfc.service.attribution.model.MemberAttribution;
+import com.etotem.cfc.service.attribution.model.MemberProfile;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+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.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * 契约级单测：五维 no_path 映射（能力键 {@code guhe.l4.noPathMap}，单元 l4）。
+ *
+ * <p><b>需求/设计锚点</b>：
+ * {@code docs/superpowers/plans/2026-11-08-浠艾福平台程序修改计划.md} §三任务分解
+ * §T14（P1，L4-4）：菌群观测对「富/行」自动标 {@code no_path}；心/智介导链自动阶梯并锁
+ * 关联措辞；低侧口径归身维主战场。（对齐 v1.1 验收 7/9/10）</p>
+ *
+ * <p><b>平台现状探测（C 档 4 项，会话实现前自主探测）</b></p>
+ * <ul>
+ *   <li><b>Adapter 形态（#1）</b>：报告解析侧存在 {@code ReportParserDispatchService} /
+ *       {@code LangGraphReportParseService};guhe_v2 采集为 Python 侧 {@code extract_guhe_v2.py}，
+ *       Java 侧以 {@code HealthGutFlora} + {@code AttributionInput.gutReportIds} 进入归因，
+ *       L4 段消费与采集 Adapter 解耦。</li>
+ *   <li><b>KB 加载方式（#2）</b>：{@code 统一知识库.json}（Python/LangGraph 侧,{@code +guhe2026.2}），
+ *       Java 侧 L4 归因不直接读 KB,L2 查询走 LangGraph——T14 不涉及 KB 装载。</li>
+ *   <li><b>L4 引擎存在性（#3）</b>：{@link FiveDimAttributionEngine} 已存在（纯 Java 确定性规则引擎，
+ *       {@code attribute()} 计算五维 0-100 相对刻度）→ T14 为「补规则」而非「新建引擎」。</li>
+ *   <li><b>合规门禁挂载点（#4）</b>：{@code AttributionComplianceGate} + {@code AttributionLowSideRules}
+ *       （G-1 association_only,措辞白名单）已存在,L4 结论前 enforce → 心/智介导链措辞锁定复用白名单。</li>
+ * </ul>
+ *
+ * <p><b>被校验的契约行为（T14：L4-4 五维 no_path 映射）</b></p>
+ * <ul>
+ *   <li>菌群观测（{@code source=gut_flora}）对「富/行」两维自动标 {@code no_path}：菌群为生物观测,
+ *       与「富(经济)/行(行为习惯)」维度无直接归因路径,异常不应对该两维产生扣分/弱维。</li>
+ *   <li>菌群观测对「心/智」走介导链（mediation chain,如肠脑轴）：自动生成阶梯式表述,
+ *       且每级措辞锁定为关联措辞（命中 {@link AttributionLowSideRules#WORDING_WHITELIST} 白名单,
+ *       禁因果/禁补菌桥接）。</li>
+ *   <li>菌群低侧（偏低）判读口径归「身」维主战场:其五维弱维不应出现「富/行」。</li>
+ * </ul>
+ *
+ * <p><b>宿主契约（TDD-RED 锚点）</b>：{@code com.etotem.cfc.service.attribution.FiveDimAttributionEngine}
+ * —— 引擎类已存在（ATT-S2-B1 合入）,但 T14 的 no_path 映射 <b>尚未实现</b>（cfclub 全仓
+ * {@code no_path}/{@code noPath} 零命中）。本测试通过反射锚定契约方法（避免直接 import 不存在方法
+ * 导致编译失败）,运行时契约方法缺失即断言失败（红）;GREEN 阶段实现方按
+ * 「契约方法签名」落地后转为验证真实行为（绿）。</p>
+ *
+ * <p><b>契约方法签名（实现方按此落地,落在 {@code FiveDimAttributionEngine} 上）</b></p>
+ * <ul>
+ *   <li>{@code Map<String, Set<String>> noPathMap()} —— 数据源 → no_path 维度集合;
+ *       契约期望含 {@code "gut_flora" → {"富","行"}}</li>
+ *   <li>{@code boolean isNoPath(String source, String dimension)} —— 指定数据源/维度是否 no_path;
+ *       期望 {@code isNoPath("gut_flora","富")==true}、{@code isNoPath("gut_flora","行")==true},
+ *       {@code isNoPath("gut_flora","身")==false}（身维为主战场）、
+ *       {@code isNoPath("gut_flora","心")==false}（心走介导链非 no_path）</li>
+ *   <li>{@code List<String> mediationChain(String source, String dimension)} —— 心/智介导链阶梯表述;
+ *       期望非空、≥2 级,且每级措辞命中关联措辞白名单</li>
+ * </ul>
+ *
+ * <p><b>测试范围</b>：纯契约级单测,无 Spring / 无 DB / 无外部服务;直接实例化纯规则引擎
+ * 或反射调用契约方法（与同批 TeamProfitHookContractTest / TeamStarMultiplierContractTest 风格一致）。</p>
+ *
+ * <p><b>RED 预期</b>：契约方法 {@code noPathMap()}/{@code isNoPath()}/{@code mediationChain()}
+ * 未实现 → 用例在反射探测处失败（红）;另 3 个真实引擎用例断言现有 {@code attribute()} 对
+ * 菌群读数的富/行扣分行为违反 no_path 契约 → 断言失败（红）。</p>
+ */
+class GuheNoPathMapContractTest {
+
+    /** 宿主契约类（已存在,ATT-S2-B1 合入;no_path 映射规则未落地）。 */
+    private static final String HOST_CLASS = "com.etotem.cfc.service.attribution.FiveDimAttributionEngine";
+
+    // ==================== 契约行为 1：菌群观测对「富/行」自动标 no_path ====================
+
+    @Test
+    void noPathMap_gutFlora_wealthAndActionMarked() {
+        Object host = contractHost();
+        Map<?, ?> map = callMap(host, "noPathMap");
+        assertNotNull(map, "noPathMap() 应返回数据源 → no_path 维度集合");
+        assertTrue(map.containsKey("gut_flora"), "noPathMap 应含 gut_flora 菌群数据源");
+        Object dims = map.get("gut_flora");
+        assertTrue(dims instanceof Set, "gut_flora 的 no_path 维度应为 Set");
+        Set<?> set = (Set<?>) dims;
+        assertTrue(set.contains("富"), "菌群观测对「富」应自动标 no_path（无直接归因路径）");
+        assertTrue(set.contains("行"), "菌群观测对「行」应自动标 no_path（无直接归因路径）");
+    }
+
+    @Test
+    void isNoPath_gutFloraWealth_true() {
+        Object host = contractHost();
+        assertTrue(callBoolean(host, "isNoPath", "gut_flora", "富"),
+                "菌群观测 → 富维应判定为 no_path");
+    }
+
+    @Test
+    void isNoPath_gutFloraAction_true() {
+        Object host = contractHost();
+        assertTrue(callBoolean(host, "isNoPath", "gut_flora", "行"),
+                "菌群观测 → 行维应判定为 no_path");
+    }
+
+    @Test
+    void isNoPath_gutFloraBody_false() {
+        Object host = contractHost();
+        assertFalse(callBoolean(host, "isNoPath", "gut_flora", "身"),
+                "身维是菌群（低侧口径）主战场,不应标 no_path");
+    }
+
+    @Test
+    void isNoPath_gutFloraMind_false() {
+        Object host = contractHost();
+        assertFalse(callBoolean(host, "isNoPath", "gut_flora", "心"),
+                "心维走介导链（非 no_path,措辞锁关联）");
+    }
+
+    // ==================== 契约行为 2：心/智介导链自动阶梯 + 锁关联措辞 ====================
+
+    @Test
+    void mediationChain_gutFloraMind_ladderLockedWording() {
+        Object host = contractHost();
+        List<String> ladder = callListString(host, "mediationChain", "gut_flora", "心");
+        assertNotNull(ladder, "介导链应返回阶梯表述列表");
+        assertTrue(ladder.size() >= 2, "心介导链应为阶梯式自动生成（≥2 级）,实际 " + ladder.size());
+        for (String step : ladder) {
+            assertTrue(usesWhitelistWording(step),
+                    "介导链每级措辞必须锁定为关联措辞（白名单）,实际: " + step);
+        }
+    }
+
+    @Test
+    void mediationChain_gutFloraWisdom_ladderLockedWording() {
+        Object host = contractHost();
+        List<String> ladder = callListString(host, "mediationChain", "gut_flora", "智");
+        assertNotNull(ladder, "介导链应返回阶梯表述列表");
+        assertTrue(ladder.size() >= 2, "智介导链应为阶梯式自动生成（≥2 级）,实际 " + ladder.size());
+        for (String step : ladder) {
+            assertTrue(usesWhitelistWording(step),
+                    "介导链每级措辞必须锁定为关联措辞（白名单）,实际: " + step);
+        }
+    }
+
+    // ==================== 契约行为 3：低侧口径归身维主战场（真实引擎违约断言） ====================
+
+    @Test
+    void attribute_gutFloraReading_wealthNoPenalty_red() {
+        // 菌群源读数（显示名命中「富」关键词「饮食」;注意读数必须不命中更靠前的身/心/智/行关键词）;
+        // 契约要求按 source=gut_flora 对「富」标 no_path → 不按关键词归因扣分（保持基数）
+        MemberAttribution attr = new MemberAttribution();
+        attr.setMemberId(1L);
+        attr.setReadings(Collections.singletonList(reading("gut_flora", "外食饮食习惯观测",
+                IndicatorReading.STATUS_LOW, IndicatorReading.BAND_VERY_LOW)));
+        Map<String, List<String>> evidence = new LinkedHashMap<>();
+        evidence.put("富", Collections.singletonList("外食饮食习惯观测"));
+        attr.setDimensionEvidence(evidence);
+
+        FiveDimAttributionEngine.FiveDimResult result =
+                new FiveDimAttributionEngine().attribute(
+                        Collections.singletonList(attr), Collections.singletonList(profile(1L)));
+
+        Double wealth = result.attributions.get(0).getFiveDim().get("富");
+        double baseWealth = AttributionWeights.BASE_SCORE.getOrDefault("富", 78.0);
+        assertEquals(baseWealth, wealth, 1e-9,
+                "菌群观测对「富」维 no_path:异常菌群读数不应使富维扣分（保持基数 " + baseWealth + "）,实际 " + wealth);
+    }
+
+    @Test
+    void attribute_gutFloraReading_actionNoPenalty_red() {
+        // 菌群源读数（显示名命中「行」关键词「运动」;不命中更靠前的身/心/智关键词）;
+        // 契约要求按 source=gut_flora 对「行」标 no_path → 不按关键词归因扣分（保持基数）
+        MemberAttribution attr = new MemberAttribution();
+        attr.setMemberId(2L);
+        attr.setReadings(Collections.singletonList(reading("gut_flora", "运动作息习惯观测",
+                IndicatorReading.STATUS_LOW, IndicatorReading.BAND_VERY_LOW)));
+        Map<String, List<String>> evidence = new LinkedHashMap<>();
+        evidence.put("行", Collections.singletonList("运动作息习惯观测"));
+        attr.setDimensionEvidence(evidence);
+
+        FiveDimAttributionEngine.FiveDimResult result =
+                new FiveDimAttributionEngine().attribute(
+                        Collections.singletonList(attr), Collections.singletonList(profile(2L)));
+
+        Double action = result.attributions.get(0).getFiveDim().get("行");
+        double baseAction = AttributionWeights.BASE_SCORE.getOrDefault("行", 70.0);
+        assertEquals(baseAction, action, 1e-9,
+                "菌群观测对「行」维 no_path:异常菌群读数不应使行维扣分（保持基数 " + baseAction + "）,实际 " + action);
+    }
+
+    @Test
+    void attribute_lowSideGutFlora_weakExcludesWealthAndAction_red() {
+        // 低侧口径归身维主战场:多条菌群低侧读数（身/行/富三路关键词各一）→
+        // no_path 契约下弱维（<阈值）只应在身维;现有关键词引擎会把行/富误打成弱维
+        MemberAttribution attr = new MemberAttribution();
+        attr.setMemberId(3L);
+        attr.setReadings(Arrays.asList(
+                reading("gut_flora", "大肠杆菌偏低", IndicatorReading.STATUS_LOW, IndicatorReading.BAND_VERY_LOW),
+                reading("gut_flora", "运动作息习惯观测", IndicatorReading.STATUS_LOW, IndicatorReading.BAND_VERY_LOW),
+                reading("gut_flora", "外食饮食习惯观测", IndicatorReading.STATUS_LOW, IndicatorReading.BAND_VERY_LOW)));
+        Map<String, List<String>> evidence = new LinkedHashMap<>();
+        evidence.put("身", Collections.singletonList("大肠杆菌偏低"));
+        evidence.put("行", Collections.singletonList("运动作息习惯观测"));
+        evidence.put("富", Collections.singletonList("外食饮食习惯观测"));
+        attr.setDimensionEvidence(evidence);
+
+        FiveDimAttributionEngine.FiveDimResult result =
+                new FiveDimAttributionEngine().attribute(
+                        Collections.singletonList(attr), Collections.singletonList(profile(3L)));
+
+        List<String> weak = result.attributions.get(0).getWeakDimensions();
+        assertNotNull(weak, "应输出五维短板标签");
+        assertTrue(weak.contains("身"), "低侧菌群判读主战场应为身维,weak=" + weak);
+        assertFalse(weak.contains("富"), "非身维遮挡:菌群低侧读数不应使「富」成弱维（no_path）,weak=" + weak);
+        assertFalse(weak.contains("行"), "非身维遮挡:菌群低侧读数不应使「行」成弱维（no_path）,weak=" + weak);
+    }
+
+    // ==================== 反射辅助（锚定宿主契约方法,避免编译期依赖不存在方法） ====================
+
+    /** 措辞是否命中关联措辞白名单（G-1 关联非因果口径）。 */
+    private static boolean usesWhitelistWording(String text) {
+        if (text == null) {
+            return false;
+        }
+        for (String wl : AttributionLowSideRules.WORDING_WHITELIST) {
+            if (text.contains(wl)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static IndicatorReading reading(String source, String displayName, String status, String band) {
+        IndicatorReading r = new IndicatorReading();
+        r.setSource(source);
+        r.setCode(displayName);
+        r.setDisplayName(displayName);
+        r.setStatus(status);
+        r.setBand(band);
+        return r;
+    }
+
+    private static MemberProfile profile(long memberId) {
+        MemberProfile p = new MemberProfile();
+        p.setMemberId(memberId);
+        p.setName("成员" + memberId);
+        p.setRole("mom");
+        return p;
+    }
+
+    private Object contractHost() {
+        try {
+            Class<?> clazz = Class.forName(HOST_CLASS);
+            return clazz.getDeclaredConstructor().newInstance();
+        } catch (ClassNotFoundException e) {
+            fail("RED[guhe.l4.noPathMap] 契约宿主 FiveDimAttributionEngine 未实现（实现未落地）："
+                    + e.getMessage());
+            throw new IllegalStateException("unreachable");
+        } catch (Exception e) {
+            fail("契约宿主 FiveDimAttributionEngine 实例化失败：" + e.getMessage());
+            throw new IllegalStateException("unreachable");
+        }
+    }
+
+    /** 按方法名 + 参数个数匹配并调用,契约方法缺失即断言失败（红）。 */
+    private Object call(Object host, String method, Object... args) {
+        for (Method m : host.getClass().getMethods()) {
+            if (m.getName().equals(method) && m.getParameterCount() == args.length) {
+                try {
+                    return m.invoke(host, args);
+                } catch (Exception e) {
+                    fail("契约方法 " + HOST_CLASS + "#" + method + " 调用失败：" + e.getMessage());
+                    throw new IllegalStateException("unreachable");
+                }
+            }
+        }
+        fail("RED[guhe.l4.noPathMap] 契约方法 " + HOST_CLASS + "#"
+                + method + " 未实现（T14 五维 no_path 映射未落地）");
+        throw new IllegalStateException("unreachable");
+    }
+
+    private boolean callBoolean(Object host, String method, Object... args) {
+        Object r = call(host, method, args);
+        if (r instanceof Boolean) {
+            return (Boolean) r;
+        }
+        fail("契约方法 " + method + " 应返回布尔,实际 " + r);
+        throw new IllegalStateException("unreachable");
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<?, ?> callMap(Object host, String method) {
+        Object r = call(host, method);
+        if (r instanceof Map) {
+            return (Map<?, ?>) r;
+        }
+        fail("契约方法 " + method + " 应返回 Map,实际 " + r);
+        throw new IllegalStateException("unreachable");
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<String> callListString(Object host, String method, Object... args) {
+        Object r = call(host, method, args);
+        if (r instanceof List) {
+            return (List<String>) r;
+        }
+        fail("契约方法 " + method + " 应返回 List<String>,实际 " + r);
+        throw new IllegalStateException("unreachable");
+    }
+}

docs/tdd/orchestration/hub-migration-2026-11-08.md

@@ -299,4 +299,26 @@ T1/T2/T3 互不相干可并行（三组代码隔离在不同脚本）；T5 必
 
 **下一步**：T8（巡检并入 WorkBuddy automation）→ 第二步 hub 退役归档（T1–T8 稳定 ≥3 日）。
 
+---
+
+### T8 巡检并入 WorkBuddy automation —— ✅ 已落地 + 验证通过（2026-11-08 用户拍板「立即实施 T8」，实际收尾于 11-09 00:15）
+
+**目标**：现有 `CF 研发负责人·闭环巡检（每时45分）`（id `5c32f42a-...`）prompt 去 hub 化，改为纯 skill 命令；停用 Windows 计划任务 `XAFHubCheck_01..06` + `xaf_hub_watchdog`（停前 kill 运行中的 `loop_resume.py`/`watchdog.py`）。
+
+**落实**：
+- **automation prompt 收尾（id `5c32f42a`）**：§2 只读盘点新增 `tdd_orchestrate.py --resume --dry-run`（T7 只读识别恢复候选）；§3 恢复动作统一 `tdd_orchestrate.py --resume`（T7 直连 skill，注明「已停用 hub 计划任务/看护进程」）；§6 清掉 `tasks_backlog.json` 风险提及，改为「任务池单一事实源 `.workbuddy/tasks.json`（本地私有不入库），跨会话以 origin/cfclub 的 docs/tdd/*.md 为准」。§4 派发 `tdd_orchestrate.py --auto --role 开发 --limit 2`（T5 直连，不再调 hub.py dispatch）。
+- **计划任务核验**：`schtasks /Query /TN XAFHubCheck_01..06` + `xaf_hub_watchdog` → **7 个全部 MISSING**（当前系统已无这些任务，无需停；历史上由 `setup_scheduled_tasks.py` 的幂等清理逻辑沉淀）。
+- **进程核验**：`loop_resume.py`/`watchdog.py` 无运行进程，无需 kill。
+- **并行 CF automation 抽查**：`CF 研发负责人1`（54247bf9）、`CF 研发闭环任务·巡检10分错峰02`（856ff81f）均为 generic prompt（"处理闭环开发任务/汇报"），**无 hub.py / setup_scheduled_tasks.py / XAFHubCheck_* 显式引用**——不属 T8 改造对象，保持原样。
+
+**⚠ 记录（非 T8 目标，第二步退役时清理）**：发现 PID 108156 运行 `hub.py watch --interval 30`（**只读状态监控**：轮询打印 CFC 会话运行状态变化，不派发、不调度），非 T8 要停的调度看护进程，未 kill；第二步 hub 归档时一并终止。
+
+**验证（T8 完成判据全过）**：
+- automation prompt 全文无 `hub.py / setup_scheduled_tasks.py / XAFHubCheck_* / loop_resume.py` 命令引用（§4 留一句「不再调 hub.py dispatch」的说明性文案，语义明确）。
+- `schtasks /Query` 7 目标任务 MISSING（计划任务清理已符合 T8 目标）。
+- skill 侧（tdd_orchestrate.py）grep `hub.py / setup_scheduled_tasks / XAFHubCheck / loop_resume / xaf_hub_watchdog` → 0 命中。
+- 无运行中的 loop_resume.py / watchdog.py 进程。
+
+**下一步**：**性能注意**——`enumerate_sessions` 全量枚举在部分远端实例连接超时时很慢（>250s 实弹），影响 `--auto` 首步；已被 T5 直连改造部分缓解（dispatch 复用已建会话），建议后续轮次并行化/短路不可达实例。**第二步 hub 退役归档**前置：T1–T8 全部落地并通过 N ≥ 3 日闭环稳定验证（至少覆盖一次 429 黑窗 + 一次 08:00 解禁 + 一次多实例并发）。退役动作见「二、第二步」：tasks_backlog 待办迁移、停 setup_scheduled_tasks 关联 automation、归档 `tools/xaf_agent_hub/` → `docs/archive/xaf-agent-hub-legacy/`、最终验收完整 TDD 闭环期间零 hub 退回。
+