用户意图很明确时，直接路由给子智能体还是主智能体？

意图识别结果 JSON
        │
        ▼
 tryPlanDirectDispatch(intentJson)   ← 判定能否直跳
        │
   ┌────┴─────────────┐
   │ 满足三条件         │ 不满足（任意一条）
   ▼                   ▼
直跳子智能体          走 MasterAgent
dispatchSubAgentDirectly   masterAgent.call(...)
（跳过 MasterAgent）    （统一路由 / 编排 / 整合）

private Mono<Msg> dispatchByIntent(String intentJson, List<Msg> inputMessages,String contextQuestion, String sessionId, String userId) {
    Optional<DirectDispatchPlan> planOpt = tryPlanDirectDispatch(intentJson);
    if (planOpt.isPresent()) {
        // 路径 A：单意图 + 高置信 + 命中白名单 → 直连子智能体，跳过 MasterAgent
        DirectDispatchPlan plan = planOpt.get();
        logger.info("[PIPELINE] 单意图高置信直跳：{} (intent={}, confidence={})，跳过 MasterAgent",
                plan.beanName(), plan.intentCode(), plan.confidence());
        return dispatchSubAgentDirectly(plan, inputMessages, contextQuestion, sessionId, userId);
    }

    // 路径 B：其余一律走 MasterAgent 路由
    ReActAgent masterAgent = agentRegistry.getAgent(MASTER_AGENT_NAME);
    return masterAgent.call(buildMasterInput(inputMessages, contextQuestion, intentJson))
            .doOnSubscribe(s -> executionRegistry.register(sessionId, masterAgent))
            .flatMap(masterResult -> handleMasterResult(masterResult, sessionId));
}

private Optional<DirectDispatchPlan> tryPlanDirectDispatch(String intentJson) {
    if (intentJson == null || intentJson.isBlank()) return Optional.empty();
    try {
        JSONObject obj = JSON.parseObject(extractJsonBlock(intentJson));
        if (obj == null) return Optional.empty();

        // —— 门槛①：必须是单意图 ——
        // 多意图含跨子智能体编排与依赖，没有单个子智能体能独立完成，交给 MasterAgent
        if (Boolean.TRUE.equals(obj.getBoolean("multi_intent"))) {
            logger.debug("[PIPELINE] multi_intent=true，不走直跳");
            return Optional.empty();
        }
        JSONArray intents = obj.getJSONArray("intents");
        if (intents == null || intents.size() != 1) return Optional.empty(); // 冗余保险

        JSONObject primary = intents.getJSONObject(0);
        if (primary == null) return Optional.empty();
        String targetAgent = primary.getString("target_agent");
        String confidence  = primary.getString("confidence");
        String intentCode  = primary.getString("intent");

        // —— 门槛②：必须高置信 ——
        // 中/低置信度即便直跳也可能召错 Agent（如把行程规划误判成机票查询），
        // 多一次 MasterAgent 的 LLM 推理，远比一次错误路由便宜
        if (!IntentRecognitionResult.Confidence.HIGH.name().equalsIgnoreCase(confidence)) {
            logger.info("[PIPELINE] 单意图 confidence={} 非 high，保守起见仍走 MasterAgent (intent={})",
                    confidence, intentCode);
            return Optional.empty();
        }

        // —— 门槛③：target_agent 必须命中"可直跳白名单" ——
        // 用白名单而非 containsBean：masterAgent 本身也是 ReActAgent bean，
        // 单纯 containsBean 会把"跳过 Master 又路由回 Master"的退化路径放行
        String bean = Character.toLowerCase(targetAgent.charAt(0)) + targetAgent.substring(1);
        if (targetAgent == null || !DISPATCHABLE_BEAN_NAMES.contains(bean)) {
            logger.info("[PIPELINE] target_agent={} 不可直跳（不在子智能体白名单中），走 MasterAgent", targetAgent);
            return Optional.empty();
        }

        return Optional.of(new DirectDispatchPlan(targetAgent, intentCode, confidence, targetAgent));
    } catch (Exception e) {
        // 解析失败同样降级 MasterAgent —— 防御式兜底
        logger.warn("[PIPELINE] 解析意图 JSON 失败，降级到 MasterAgent: {}", e.getMessage());
        return Optional.empty();
    }
}

/** 可直跳的子智能体 */
private static final Set<String> DISPATCHABLE_BEAN_NAMES = Set.of("infoAgent");