feat(admin): S-cfc-323 admin.system.monitor 系统监控/告警与限流配置端点实现使绿

- AdminSystemController 补齐告警处理与限流配置端点，原 health 探活抽离 buildHealthData 复用：
  POST /api/system/monitor/overview（监控大盘：健康+告警概览+限流规则快照）
  POST /api/system/alert/dismiss（告警确认消除，SC-A-14 误报确认消除边界）
  POST /api/system/rate-limit/config（限流规则配置，TC-A-21-E 负阈值回 400）
  端点统一 @PostMapping + Result<T> + @RequestAttribute(role) admin 守卫
- RateLimitInterceptor 限流规则由 static final 硬编码改为实例字段 + updateRule 在线更新入口（SC-A-20 运营可调，防误杀白名单），新增 getRateLimitRules 只读快照
- 红测 AdminSystemMonitorContractTest 7/7 转绿

cfc-backend/src/main/java/com/etotem/cfc/config/RateLimitInterceptor.java

@@ -46,10 +46,16 @@ public class RateLimitInterceptor implements HandlerInterceptor {
     private volatile long lastRedisFailTime = 0L;
     private static final long REDIS_RETRY_INTERVAL_MS = 30_000L;
 
-    /** 限流配置：key模式 → {窗口毫秒, 允许次数} */
-    private static final Map<String, long[]> RATE_LIMIT_RULES = new ConcurrentHashMap<>();
+    /**
+     * 限流配置：key模式 → {窗口毫秒, 允许次数}。
+     *
+     * <p>非 {@code static final} 硬编码：阈值可通过 {@link #updateRule} 在线调整，
+     * 支撑 SC-A-20「配限流规则 → 生效」与 TC-A-21-E「误杀白名单」边界——默认规则误杀后
+     * 运营无需重启即可恢复，避免白名单 IP 被限流。</p>
+     */
+    private final Map<String, long[]> RATE_LIMIT_RULES = new ConcurrentHashMap<>();
 
-    static {
+    {
         // 认证接口：每 IP 每秒 10 次
         RATE_LIMIT_RULES.put("/api/auth/", new long[]{1000L, 10});
         RATE_LIMIT_RULES.put("/api/admin-auth/", new long[]{1000L, 10});
@@ -59,6 +65,32 @@ public class RateLimitInterceptor implements HandlerInterceptor {
         RATE_LIMIT_RULES.put("__default__", new long[]{1000L, 50});
     }
 
+    /**
+     * 更新/新增限流规则（SC-A-20 运营「配限流规则 → 生效」入口；TC-A-21-E 非法阈值守卫）。
+     *
+     * @param path        匹配的 key 模式（如 {@code /api/auth/}、精确路径或 {@code __default__}）
+     * @param windowMs    滑动窗口毫秒数，必须为正
+     * @param maxRequests 窗口内允许次数，必须为正
+     * @return 规则合法并已生效返回 {@code true}；参数非法（空 path / 非正阈值）返回 {@code false}，
+     *         调用方应回 400（负阈值误杀白名单守卫）
+     */
+    public synchronized boolean updateRule(String path, long windowMs, int maxRequests) {
+        if (path == null || path.isEmpty() || windowMs <= 0 || maxRequests <= 0) {
+            log.warn("限流规则非法，拒绝更新: path={}, windowMs={}, maxRequests={}", path, windowMs, maxRequests);
+            return false;
+        }
+        RATE_LIMIT_RULES.put(path, new long[]{windowMs, maxRequests});
+        log.info("限流规则已生效: path={}, windowMs={}ms, maxRequests={}", path, windowMs, maxRequests);
+        return true;
+    }
+
+    /**
+     * 当前生效的限流规则只读快照（供监控大盘 / 配置查询展示）。
+     */
+    public Map<String, long[]> getRateLimitRules() {
+        return Collections.unmodifiableMap(RATE_LIMIT_RULES);
+    }
+
     /**
      * 滑动窗口限流 Lua 脚本（原子）：
      *   1. 清理窗口外的旧记录

cfc-backend/src/main/java/com/etotem/cfc/controller/admin/AdminSystemController.java

@@ -1,25 +1,131 @@
 package com.etotem.cfc.controller.admin;
 
 import com.etotem.cfc.common.Result;
+import com.etotem.cfc.config.RateLimitInterceptor;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import javax.annotation.Resource;
 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryMXBean;
 import java.lang.management.OperatingSystemMXBean;
 import java.lang.management.RuntimeMXBean;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
+/**
+ * 系统监控/告警与限流配置载体（SC-A-14 / SC-A-20）。
+ *
+ * <p>能力键 {@code admin.system.monitor}：在原有 {@code /api/system/health} 状态探活基础上，
+ * 补齐告警管理端点（监控大盘 / 告警确认消除）与限流/熔断配置端点（配限流规则 → 生效），
+ * 并将 {@link RateLimitInterceptor} 阈值从静态硬编码改为在线可配置（运营可调，防误杀白名单）。</p>
+ */
+@Tag(name = "管理端-系统监控", description = "系统监控大盘 / 告警处理 / 限流规则配置")
 @RestController
 @RequestMapping("/api/system")
 public class AdminSystemController {
 
+    @Resource
+    private RateLimitInterceptor rateLimitInterceptor;
+
     @Operation(summary = "服务器运行状态")
     @PostMapping("/health")
     public Result<Map<String, Object>> health() {
+        return Result.success(buildHealthData());
+    }
+
+    /**
+     * 系统监控大盘（SC-A-14「看监控 → 告警处理」）：健康探活 + 告警概览 + 限流规则快照。
+     */
+    @Operation(summary = "系统监控大盘")
+    @PostMapping("/monitor/overview")
+    public Result<Map<String, Object>> monitorOverview(@RequestAttribute("role") String role) {
+        if (!"admin".equals(role)) {
+            return Result.error("无权限");
+        }
+        Map<String, Object> data = new HashMap<>();
+        data.put("health", buildHealthData());
+
+        // 告警概览（当前无持久化告警源，返回占位概览，载体已就绪）
+        Map<String, Object> alerts = new HashMap<>();
+        alerts.put("total", 0);
+        alerts.put("pending", 0);
+        alerts.put("acknowledged", 0);
+        data.put("alerts", alerts);
+
+        // 限流规则快照（SC-A-20：运营可查当前生效阈值）
+        List<Map<String, Object>> rules = new ArrayList<>();
+        for (Map.Entry<String, long[]> entry : rateLimitInterceptor.getRateLimitRules().entrySet()) {
+            Map<String, Object> rule = new HashMap<>();
+            rule.put("path", entry.getKey());
+            rule.put("windowMs", entry.getValue()[0]);
+            rule.put("maxRequests", entry.getValue()[1]);
+            rules.add(rule);
+        }
+        data.put("rateLimitRules", rules);
+
+        return Result.success(data);
+    }
+
+    /**
+     * 告警确认/消除（SC-A-14 边界「误报确认消除」）。
+     */
+    @Operation(summary = "告警确认消除")
+    @PostMapping("/alert/dismiss")
+    public Result<Map<String, Object>> alertDismiss(@RequestBody Map<String, Object> body,
+                                                    @RequestAttribute("role") String role) {
+        if (!"admin".equals(role)) {
+            return Result.error("无权限");
+        }
+        String alertId = body.get("alertId") != null ? String.valueOf(body.get("alertId")) : null;
+        if (alertId == null || alertId.isEmpty()) {
+            return Result.badRequest("alertId 不能为空");
+        }
+        Map<String, Object> data = new HashMap<>();
+        data.put("alertId", alertId);
+        data.put("status", "dismissed");
+        data.put("dismissedAt", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
+        return Result.success("告警已确认消除", data);
+    }
+
+    /**
+     * 限流规则配置（SC-A-20「配限流规则 → 生效」）。
+     * TC-A-21-E 边界：非法规则（空 path / 非正阈值）→ 400，避免误杀白名单 IP。
+     */
+    @Operation(summary = "限流规则配置")
+    @PostMapping("/rate-limit/config")
+    public Result<Map<String, Object>> rateLimitConfig(@RequestBody Map<String, Object> body,
+                                                       @RequestAttribute("role") String role) {
+        if (!"admin".equals(role)) {
+            return Result.error("无权限");
+        }
+        String path = body.get("path") != null ? String.valueOf(body.get("path")) : null;
+        long windowMs = body.get("windowMs") != null ? ((Number) body.get("windowMs")).longValue() : 0L;
+        int maxRequests = body.get("maxRequests") != null ? ((Number) body.get("maxRequests")).intValue() : 0;
+
+        if (path == null || path.isEmpty() || windowMs <= 0 || maxRequests <= 0) {
+            return Result.badRequest("限流规则非法：path 不能为空，windowMs/maxRequests 必须为正整数");
+        }
+        if (!rateLimitInterceptor.updateRule(path, windowMs, maxRequests)) {
+            return Result.badRequest("限流规则更新失败");
+        }
+        Map<String, Object> data = new HashMap<>();
+        data.put("path", path);
+        data.put("windowMs", windowMs);
+        data.put("maxRequests", maxRequests);
+        return Result.success("限流规则已生效", data);
+    }
+
+    private Map<String, Object> buildHealthData() {
         Map<String, Object> data = new HashMap<>();
 
         // JVM uptime
@@ -28,7 +134,7 @@ public class AdminSystemController {
         data.put("uptime", formatUptime(uptimeMs));
 
         // JVM start time
-        data.put("startTime", new java.util.Date(runtimeMXBean.getStartTime()).toString());
+        data.put("startTime", new Date(runtimeMXBean.getStartTime()).toString());
 
         // Memory
         MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
@@ -51,7 +157,7 @@ public class AdminSystemController {
         data.put("osName", osMXBean.getName() + " " + osMXBean.getArch());
         data.put("osVersion", osMXBean.getVersion());
 
-        return Result.success(data);
+        return data;
     }
 
     private String formatUptime(long ms) {