feat(monitor): admin channel monitor MVP with SSRF protection and batch aggregation

新增 admin「渠道监控」模块（参考 BingZi-233/check-cx），独立于现有 Channel 体系。
admin 配置 + 后台定时调用上游 LLM chat completions 健康检查 + 所有登录用户只读可见。

后端：
- ent: channel_monitor + channel_monitor_history（AES-256-GCM 加密 api_key）
- service 按职责拆分：service/aggregator/validate/checker/runner/ssrf
- provider strategy map 替代 switch（openai/anthropic/gemini）
- repository batch 聚合（ListLatestForMonitorIDs + ComputeAvailabilityForMonitors）消除 N+1
- runner: ticker(5s) + pond worker pool(5) + inFlight 防并发 + TrySubmit 防雪崩
  + 凌晨 3 点 cron 清理 30 天历史
- SSRF 防护：强制 https + 私网/loopback/云元数据 IP 拒绝（127/8、10/8、172.16/12、
  192.168/16、169.254/16、100.64/10、::1、fc00::/7、fe80::/10）+ DialContext
  在 socket 层防 DNS rebinding
- API key sanitize：擦除 url.Error 与上游响应 body 中的 sk-/sk-ant-/AIza/JWT 模式
- APIKeyDecryptFailed 标志位 + 单 monitor 路径检测，避免空 key 调用上游

handler:
- admin: CRUD + 手动触发 + 历史接口（api_key 脱敏）
- user: 只读列表 + 状态详情（去除 api_key/endpoint）
- ParseChannelMonitorID 共用 + dto.ChannelMonitorExtraModelStatus 共用

前端：
- 路由 /admin/channels/{pricing,monitor} + /monitor（用户只读）
- AppSidebar 父项 expandOnly 支持
- ChannelMonitorView 拆为 8 个子组件 + ChannelStatusView 拆出 detail dialog
- composables/useChannelMonitorFormat + constants/channelMonitor 共享
- i18n monitorCommon namespace 消除 admin/user 两 view 重复

合规：所有文件符合 CLAUDE.md（Go ≤ 500 行 / Vue ≤ 300 行 / 函数 ≤ 30 行）
CI: go build / gofmt / golangci-lint(0 issues) / make test-unit / pnpm build 全绿

backend/internal/service/channel_monitor_runner.go

+package service
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/alitto/pond/v2"
+)
+
+// ChannelMonitorRunner 渠道监控调度器。
+//
+// 职责：
+//   - 每 monitorTickerInterval 扫描一次"到期需要检测"的监控
+//   - 通过 pond 池（容量 monitorWorkerConcurrency）异步执行检测
+//   - 每小时检查一次时钟，到 monitorCleanupHour 点时执行历史清理
+//   - Stop 时优雅关闭：池 drain + ticker.Stop + wg.Wait
+//
+// 不引入 cron 库；清理调度通过"每小时检查时间"实现，足够 MVP。
+type ChannelMonitorRunner struct {
+	svc *ChannelMonitorService
+
+	pool   pond.Pool
+	stopCh chan struct{}
+	once   sync.Once
+	wg     sync.WaitGroup
+
+	// inFlight 跟踪正在执行的 monitor.ID。tickDueChecks 调度前会检查避免重复提交，
+	// 防止单次检测耗时 > interval 时同一 monitor 被并发执行。
+	inFlight   map[int64]struct{}
+	inFlightMu sync.Mutex
+
+	// 清理状态：lastCleanupDay 记录上次清理的"年-月-日"，避免同一天重复跑。
+	lastCleanupDay string
+	cleanupMu      sync.Mutex
+}
+
+// NewChannelMonitorRunner 构造调度器。Start 在 wire 中调用。
+func NewChannelMonitorRunner(svc *ChannelMonitorService) *ChannelMonitorRunner {
+	return &ChannelMonitorRunner{
+		svc:      svc,
+		stopCh:   make(chan struct{}),
+		inFlight: make(map[int64]struct{}),
+	}
+}
+
+// Start 启动 ticker + worker pool + cleanup loop。
+// 调用方需保证只调一次（wire ProvideChannelMonitorRunner 内只调一次）。
+func (r *ChannelMonitorRunner) Start() {
+	if r == nil || r.svc == nil {
+		return
+	}
+	// 容量 5 的 pond 池：超出时调用方等待，避免调度堆积无限增长。
+	r.pool = pond.NewPool(monitorWorkerConcurrency)
+
+	r.wg.Add(2)
+	go r.dueCheckLoop()
+	go r.cleanupLoop()
+}
+
+// Stop 优雅停止：close stopCh -> 等待两个 loop 退出 -> 池 drain。
+func (r *ChannelMonitorRunner) Stop() {
+	if r == nil {
+		return
+	}
+	r.once.Do(func() {
+		close(r.stopCh)
+	})
+	r.wg.Wait()
+	if r.pool != nil {
+		r.pool.StopAndWait()
+	}
+}
+
+// dueCheckLoop 每 monitorTickerInterval 扫描一次"到期监控"，提交到池。
+func (r *ChannelMonitorRunner) dueCheckLoop() {
+	defer r.wg.Done()
+
+	ticker := time.NewTicker(monitorTickerInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-r.stopCh:
+			return
+		case <-ticker.C:
+			r.tickDueChecks()
+		}
+	}
+}
+
+// tickDueChecks 一次扫描：查询到期监控并逐个提交到池。
+// 已在执行的 monitor 会被跳过（防止单次检测耗时 > interval 时重复调度）。
+// 池满时使用 TrySubmit 跳过（不能阻塞 ticker），同时立即释放已占用的 inFlight 槽。
+func (r *ChannelMonitorRunner) tickDueChecks() {
+	ctx, cancel := context.WithTimeout(context.Background(), monitorListDueTimeout)
+	defer cancel()
+
+	due, err := r.svc.listDueForCheck(ctx)
+	if err != nil {
+		slog.Warn("channel_monitor: list due failed", "error", err)
+		return
+	}
+	for _, m := range due {
+		monitor := m
+		if !r.tryAcquireInFlight(monitor.ID) {
+			slog.Debug("channel_monitor: skip already in-flight",
+				"monitor_id", monitor.ID, "name", monitor.Name)
+			continue
+		}
+		if _, ok := r.pool.TrySubmit(func() {
+			r.runOne(monitor.ID, monitor.Name)
+		}); !ok {
+			// 池满：丢弃本次检测，但必须释放已占用的 inFlight 槽，否则该 monitor 会被永久卡住。
+			r.releaseInFlight(monitor.ID)
+			slog.Warn("channel_monitor: worker pool full, skip submission",
+				"monitor_id", monitor.ID, "name", monitor.Name)
+		}
+	}
+}
+
+// tryAcquireInFlight 原子地占用 monitor 的 in-flight 槽。
+// 已被占用返回 false（调用方应跳过本次提交）。
+func (r *ChannelMonitorRunner) tryAcquireInFlight(id int64) bool {
+	r.inFlightMu.Lock()
+	defer r.inFlightMu.Unlock()
+	if _, exists := r.inFlight[id]; exists {
+		return false
+	}
+	r.inFlight[id] = struct{}{}
+	return true
+}
+
+// releaseInFlight 释放 in-flight 槽。runOne 完成（含 panic recover）后必须调用。
+func (r *ChannelMonitorRunner) releaseInFlight(id int64) {
+	r.inFlightMu.Lock()
+	delete(r.inFlight, id)
+	r.inFlightMu.Unlock()
+}
+
+// runOne 执行单个监控的检测。所有错误只记日志，不熔断。
+// 任务结束时（含 panic recover）必须释放 in-flight 槽。
+//
+// 单次解密路径：调 RunCheckByID，内部统一 Get + APIKeyDecryptFailed 判定 + 跑检测，
+// 避免 runner 自己再 Get 一次造成密文二次解密。
+func (r *ChannelMonitorRunner) runOne(id int64, name string) {
+	// 单次任务上限 = 请求超时 + ping + 一些缓冲。
+	ctx, cancel := context.WithTimeout(context.Background(), monitorRequestTimeout+monitorPingTimeout+monitorRunOneBuffer)
+	defer cancel()
+
+	defer r.releaseInFlight(id)
+
+	defer func() {
+		if rec := recover(); rec != nil {
+			slog.Error("channel_monitor: runner panic",
+				"monitor_id", id, "name", name, "panic", rec)
+		}
+	}()
+
+	if _, err := r.svc.RunCheck(ctx, id); err != nil {
+		// ErrChannelMonitorAPIKeyDecryptFailed 是预期可恢复错误，降为 Warn 即可。
+		slog.Warn("channel_monitor: run check failed",
+			"monitor_id", id, "name", name, "error", err)
+	}
+}
+
+// cleanupLoop 每小时检查当前时间，到 monitorCleanupHour 点（且当天还没清理过）则跑一次清理。
+// 启动时立即检查一次，避免长时间运行才跑首次清理。
+func (r *ChannelMonitorRunner) cleanupLoop() {
+	defer r.wg.Done()
+
+	ticker := time.NewTicker(monitorCleanupCheckInterval)
+	defer ticker.Stop()
+
+	r.maybeRunCleanup()
+	for {
+		select {
+		case <-r.stopCh:
+			return
+		case <-ticker.C:
+			r.maybeRunCleanup()
+		}
+	}
+}
+
+// maybeRunCleanup 如果当前小时是 monitorCleanupHour 且当天未跑过，则执行清理。
+func (r *ChannelMonitorRunner) maybeRunCleanup() {
+	now := time.Now()
+	if now.Hour() != monitorCleanupHour {
+		return
+	}
+	day := now.Format(monitorCleanupDayLayout)
+
+	r.cleanupMu.Lock()
+	if r.lastCleanupDay == day {
+		r.cleanupMu.Unlock()
+		return
+	}
+	r.lastCleanupDay = day
+	r.cleanupMu.Unlock()
+
+	ctx, cancel := context.WithTimeout(context.Background(), monitorCleanupTimeout)
+	defer cancel()
+	if err := r.svc.cleanupOldHistory(ctx); err != nil {
+		slog.Warn("channel_monitor: cleanup history failed", "error", err)
+	}
+}

backend/internal/service/channel_monitor_service.go

+package service
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+)
+
+// ChannelMonitorRepository 渠道监控数据访问接口。
+// 入参/返回的指针类型均使用 service 包的 ChannelMonitor 模型，
+// repository 实现负责与 ent 模型互转，并保持 api_key_encrypted 字段为密文。
+type ChannelMonitorRepository interface {
+	// CRUD
+	Create(ctx context.Context, m *ChannelMonitor) error
+	GetByID(ctx context.Context, id int64) (*ChannelMonitor, error)
+	Update(ctx context.Context, m *ChannelMonitor) error
+	Delete(ctx context.Context, id int64) error
+	List(ctx context.Context, params ChannelMonitorListParams) ([]*ChannelMonitor, int64, error)
+
+	// 调度器辅助
+	ListEnabled(ctx context.Context) ([]*ChannelMonitor, error)
+	MarkChecked(ctx context.Context, id int64, checkedAt time.Time) error
+	InsertHistoryBatch(ctx context.Context, rows []*ChannelMonitorHistoryRow) error
+	DeleteHistoryBefore(ctx context.Context, before time.Time) (int64, error)
+
+	// 历史记录
+	ListHistory(ctx context.Context, monitorID int64, model string, limit int) ([]*ChannelMonitorHistoryEntry, error)
+
+	// 用户视图聚合
+	ListLatestPerModel(ctx context.Context, monitorID int64) ([]*ChannelMonitorLatest, error)
+	ComputeAvailability(ctx context.Context, monitorID int64, windowDays int) ([]*ChannelMonitorAvailability, error)
+
+	// 批量聚合（admin/user list 用，避免 N+1）
+	ListLatestForMonitorIDs(ctx context.Context, ids []int64) (map[int64][]*ChannelMonitorLatest, error)
+	ComputeAvailabilityForMonitors(ctx context.Context, ids []int64, windowDays int) (map[int64][]*ChannelMonitorAvailability, error)
+}
+
+// ChannelMonitorService 渠道监控管理服务。
+type ChannelMonitorService struct {
+	repo      ChannelMonitorRepository
+	encryptor SecretEncryptor
+}
+
+// NewChannelMonitorService 创建渠道监控服务实例。
+func NewChannelMonitorService(repo ChannelMonitorRepository, encryptor SecretEncryptor) *ChannelMonitorService {
+	return &ChannelMonitorService{repo: repo, encryptor: encryptor}
+}
+
+// ---------- CRUD ----------
+
+// List 列表查询（支持 provider/enabled/search 过滤 + 分页）。
+// 返回的 ChannelMonitor.APIKey 已解密为明文，handler 层负责脱敏。
+func (s *ChannelMonitorService) List(ctx context.Context, params ChannelMonitorListParams) ([]*ChannelMonitor, int64, error) {
+	if params.Page < 1 {
+		params.Page = 1
+	}
+	if params.PageSize < 1 || params.PageSize > 200 {
+		params.PageSize = 20
+	}
+	items, total, err := s.repo.List(ctx, params)
+	if err != nil {
+		return nil, 0, fmt.Errorf("list channel monitors: %w", err)
+	}
+	for _, it := range items {
+		s.decryptInPlace(it)
+	}
+	return items, total, nil
+}
+
+// Get 查询单个监控（解密 API Key）。
+func (s *ChannelMonitorService) Get(ctx context.Context, id int64) (*ChannelMonitor, error) {
+	m, err := s.repo.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	s.decryptInPlace(m)
+	return m, nil
+}
+
+// Create 创建监控（内部加密 api_key）。
+func (s *ChannelMonitorService) Create(ctx context.Context, p ChannelMonitorCreateParams) (*ChannelMonitor, error) {
+	if err := validateCreateParams(p); err != nil {
+		return nil, err
+	}
+	encrypted, err := s.encryptor.Encrypt(p.APIKey)
+	if err != nil {
+		return nil, fmt.Errorf("encrypt api key: %w", err)
+	}
+	m := &ChannelMonitor{
+		Name:            strings.TrimSpace(p.Name),
+		Provider:        p.Provider,
+		Endpoint:        normalizeEndpoint(p.Endpoint),
+		APIKey:          encrypted, // 注意：传入 repository 时该字段为密文
+		PrimaryModel:    strings.TrimSpace(p.PrimaryModel),
+		ExtraModels:     normalizeModels(p.ExtraModels),
+		GroupName:       strings.TrimSpace(p.GroupName),
+		Enabled:         p.Enabled,
+		IntervalSeconds: p.IntervalSeconds,
+		CreatedBy:       p.CreatedBy,
+	}
+	if err := s.repo.Create(ctx, m); err != nil {
+		return nil, fmt.Errorf("create channel monitor: %w", err)
+	}
+	// 不再调 s.Get 重走解密链：已知刚加密的明文，直接构造响应。
+	// 这样可避免 SecretEncryptor 解密失败时 APIKey 被静默清空的问题（见 Fix 4）。
+	m.APIKey = strings.TrimSpace(p.APIKey)
+	return m, nil
+}
+
+// validateCreateParams 把 Create 入参的所有校验聚拢为一个函数，避免 Create 主体超过 30 行。
+func validateCreateParams(p ChannelMonitorCreateParams) error {
+	if err := validateProvider(p.Provider); err != nil {
+		return err
+	}
+	if err := validateInterval(p.IntervalSeconds); err != nil {
+		return err
+	}
+	if err := validateEndpoint(p.Endpoint); err != nil {
+		return err
+	}
+	if strings.TrimSpace(p.APIKey) == "" {
+		return ErrChannelMonitorMissingAPIKey
+	}
+	if strings.TrimSpace(p.PrimaryModel) == "" {
+		return ErrChannelMonitorMissingPrimaryModel
+	}
+	return nil
+}
+
+// Update 更新监控。APIKey 字段：nil 或空字符串 = 不修改；非空 = 加密后覆盖。
+func (s *ChannelMonitorService) Update(ctx context.Context, id int64, p ChannelMonitorUpdateParams) (*ChannelMonitor, error) {
+	existing, err := s.repo.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if err := applyMonitorUpdate(existing, p); err != nil {
+		return nil, err
+	}
+
+	newPlainAPIKey, apiKeyUpdated, err := s.applyAPIKeyUpdate(existing, p.APIKey)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := s.repo.Update(ctx, existing); err != nil {
+		return nil, fmt.Errorf("update channel monitor: %w", err)
+	}
+
+	// 不再调 s.Get 重走解密链：避免二次解密带来的"密文被静默清空"风险（与 Create 一致）。
+	if apiKeyUpdated {
+		existing.APIKey = newPlainAPIKey
+	} else {
+		s.decryptInPlace(existing)
+	}
+	return existing, nil
+}
+
+// applyAPIKeyUpdate 处理 Update 中的 APIKey 字段：
+//   - 入参 raw 为 nil 或空白：不修改 existing.APIKey（仍为密文），返回 updated=false
+//   - 非空：加密后写入 existing.APIKey；同时把明文返回给调用方，
+//     供写库成功后塞回 existing 避免把密文吐回客户端
+func (s *ChannelMonitorService) applyAPIKeyUpdate(existing *ChannelMonitor, raw *string) (plain string, updated bool, err error) {
+	if raw == nil || strings.TrimSpace(*raw) == "" {
+		return "", false, nil
+	}
+	plain = strings.TrimSpace(*raw)
+	encrypted, encErr := s.encryptor.Encrypt(plain)
+	if encErr != nil {
+		return "", false, fmt.Errorf("encrypt api key: %w", encErr)
+	}
+	existing.APIKey = encrypted
+	return plain, true, nil
+}
+
+// Delete 删除监控（历史通过外键 CASCADE 自动清理）。
+func (s *ChannelMonitorService) Delete(ctx context.Context, id int64) error {
+	if err := s.repo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("delete channel monitor: %w", err)
+	}
+	return nil
+}
+
+// ListHistory 列出某个监控最近的检测历史。
+// model 为空表示返回所有模型；limit <= 0 时使用默认值，超过上限会被截断。
+func (s *ChannelMonitorService) ListHistory(ctx context.Context, id int64, model string, limit int) ([]*ChannelMonitorHistoryEntry, error) {
+	if _, err := s.repo.GetByID(ctx, id); err != nil {
+		return nil, err
+	}
+	if limit <= 0 {
+		limit = MonitorHistoryDefaultLimit
+	}
+	if limit > MonitorHistoryMaxLimit {
+		limit = MonitorHistoryMaxLimit
+	}
+	entries, err := s.repo.ListHistory(ctx, id, strings.TrimSpace(model), limit)
+	if err != nil {
+		return nil, fmt.Errorf("list history: %w", err)
+	}
+	return entries, nil
+}
+
+// ---------- 业务 ----------
+
+// RunCheck 同步触发对一个监控的检测：并发跑 primary + extra 模型，
+// 写历史记录并更新 last_checked_at。返回每个模型的检测结果。
+func (s *ChannelMonitorService) RunCheck(ctx context.Context, id int64) ([]*CheckResult, error) {
+	m, err := s.Get(ctx, id) // 已解密 APIKey
+	if err != nil {
+		return nil, err
+	}
+	if m.APIKeyDecryptFailed {
+		return nil, ErrChannelMonitorAPIKeyDecryptFailed
+	}
+	results := s.runChecksConcurrent(ctx, m)
+	s.persistCheckResults(ctx, m, results)
+	return results, nil
+}
+
+// persistCheckResults 写入本次检测的历史记录并更新 last_checked_at。
+// 任一写库失败都只记日志，不影响调用方拿到 results（与 MVP 期望一致：宁可漏记历史也要先返回结果）。
+func (s *ChannelMonitorService) persistCheckResults(ctx context.Context, m *ChannelMonitor, results []*CheckResult) {
+	rows := make([]*ChannelMonitorHistoryRow, 0, len(results))
+	for _, r := range results {
+		rows = append(rows, &ChannelMonitorHistoryRow{
+			MonitorID:     m.ID,
+			Model:         r.Model,
+			Status:        r.Status,
+			LatencyMs:     r.LatencyMs,
+			PingLatencyMs: r.PingLatencyMs,
+			Message:       r.Message,
+			CheckedAt:     r.CheckedAt,
+		})
+	}
+	if err := s.repo.InsertHistoryBatch(ctx, rows); err != nil {
+		slog.Error("channel_monitor: insert history failed",
+			"monitor_id", m.ID, "name", m.Name, "error", err)
+	}
+	if err := s.repo.MarkChecked(ctx, m.ID, time.Now()); err != nil {
+		slog.Error("channel_monitor: mark checked failed",
+			"monitor_id", m.ID, "error", err)
+	}
+}
+
+// runChecksConcurrent 对 primary + extra 模型并发执行检测。
+// errgroup 仅用于等待，不传播错误（每个 model 失败都已打包进 CheckResult）。
+func (s *ChannelMonitorService) runChecksConcurrent(ctx context.Context, m *ChannelMonitor) []*CheckResult {
+	models := append([]string{m.PrimaryModel}, m.ExtraModels...)
+	results := make([]*CheckResult, len(models))
+
+	// ping 共享一次，所有模型记录同一个 ping 延迟。
+	pingMs := pingEndpointOrigin(ctx, m.Endpoint)
+
+	var eg errgroup.Group
+	var mu sync.Mutex
+	for i, model := range models {
+		i, model := i, model
+		eg.Go(func() error {
+			r := runCheckForModel(ctx, m.Provider, m.Endpoint, m.APIKey, model)
+			r.PingLatencyMs = pingMs
+			mu.Lock()
+			results[i] = r
+			mu.Unlock()
+			return nil
+		})
+	}
+	_ = eg.Wait()
+	return results
+}
+
+// ---------- 调度器内部 ----------
+
+// listDueForCheck 返回需要立即检测的监控列表：
+// enabled=true AND (last_checked_at IS NULL OR last_checked_at + interval <= now)。
+// 实现下沉到 repository（用 SQL 表达式比较），减少应用层数据传输。
+func (s *ChannelMonitorService) listDueForCheck(ctx context.Context) ([]*ChannelMonitor, error) {
+	all, err := s.repo.ListEnabled(ctx)
+	if err != nil {
+		return nil, err
+	}
+	now := time.Now()
+	due := make([]*ChannelMonitor, 0, len(all))
+	for _, m := range all {
+		if m.LastCheckedAt == nil {
+			due = append(due, m)
+			continue
+		}
+		nextAt := m.LastCheckedAt.Add(time.Duration(m.IntervalSeconds) * time.Second)
+		if !nextAt.After(now) {
+			due = append(due, m)
+		}
+	}
+	return due, nil
+}
+
+// cleanupOldHistory 删除 monitorHistoryRetentionDays 天之前的历史记录。
+func (s *ChannelMonitorService) cleanupOldHistory(ctx context.Context) error {
+	before := time.Now().AddDate(0, 0, -monitorHistoryRetentionDays)
+	deleted, err := s.repo.DeleteHistoryBefore(ctx, before)
+	if err != nil {
+		return fmt.Errorf("delete history before %s: %w", before.Format(time.RFC3339), err)
+	}
+	if deleted > 0 {
+		slog.Info("channel_monitor: history cleanup",
+			"deleted_rows", deleted, "before", before.Format(time.RFC3339))
+	}
+	return nil
+}
+
+// ---------- helpers ----------
+
+// decryptInPlace 把 ChannelMonitor.APIKey 从密文解密为明文。
+// 解密失败时把字段清空 + 设置 APIKeyDecryptFailed=true（不返回错误，避免阻断列表渲染）。
+// runner / RunCheck 必须读取该标志位并拒绝执行检测。
+func (s *ChannelMonitorService) decryptInPlace(m *ChannelMonitor) {
+	if m == nil || m.APIKey == "" {
+		return
+	}
+	plain, err := s.encryptor.Decrypt(m.APIKey)
+	if err != nil {
+		slog.Warn("channel_monitor: decrypt api key failed",
+			"monitor_id", m.ID, "error", err)
+		m.APIKey = ""
+		m.APIKeyDecryptFailed = true
+		return
+	}
+	m.APIKey = plain
+}
+
+// applyMonitorUpdate 把 update params 中非 nil 的字段应用到 existing 上。
+// APIKey 字段在调用方单独处理（涉及加密）。
+//
+// 行数稍超过 30：这是逐字段平铺的 dispatcher，每个 if 都是 1-3 行的"非 nil 则覆盖"模式，
+// 拆分反而会增加跳转噪音、影响可读性，故保留为单函数。
+func applyMonitorUpdate(existing *ChannelMonitor, p ChannelMonitorUpdateParams) error {
+	if p.Name != nil {
+		existing.Name = strings.TrimSpace(*p.Name)
+	}
+	if p.Provider != nil {
+		if err := validateProvider(*p.Provider); err != nil {
+			return err
+		}
+		existing.Provider = *p.Provider
+	}
+	if p.Endpoint != nil {
+		if err := validateEndpoint(*p.Endpoint); err != nil {
+			return err
+		}
+		existing.Endpoint = normalizeEndpoint(*p.Endpoint)
+	}
+	if p.PrimaryModel != nil {
+		existing.PrimaryModel = strings.TrimSpace(*p.PrimaryModel)
+	}
+	if p.ExtraModels != nil {
+		existing.ExtraModels = normalizeModels(*p.ExtraModels)
+	}
+	if p.GroupName != nil {
+		existing.GroupName = strings.TrimSpace(*p.GroupName)
+	}
+	if p.Enabled != nil {
+		existing.Enabled = *p.Enabled
+	}
+	if p.IntervalSeconds != nil {
+		if err := validateInterval(*p.IntervalSeconds); err != nil {
+			return err
+		}
+		existing.IntervalSeconds = *p.IntervalSeconds
+	}
+	return nil
+}

backend/internal/service/channel_monitor_ssrf.go

+package service
+
+import (
+	"context"
+	"net"
+	"strings"
+)
+
+// SSRF 防护 helper：
+//   - validateEndpoint 在 admin 提交时阻止 http/loopback/私网/云元数据 URL
+//   - safeDialContext 在 socket 层再次校验真实 IP，防止 DNS rebinding
+//
+// 已知 cloud metadata hostname 拒绝列表（小写比较）。
+var monitorBlockedHostnames = map[string]struct{}{
+	"localhost":                  {},
+	"localhost.localdomain":      {},
+	"metadata":                   {},
+	"metadata.google.internal":   {},
+	"metadata.goog":              {},
+	"instance-data":              {},
+	"instance-data.ec2.internal": {},
+}
+
+// CIDR 列表：包含所有需要拒绝的 IPv4/IPv6 段。
+// 解析时只 panic 一次（启动时确认），生产路径只做 Contains。
+var monitorBlockedCIDRs = mustParseCIDRs([]string{
+	"127.0.0.0/8",    // IPv4 loopback
+	"10.0.0.0/8",     // RFC1918
+	"172.16.0.0/12",  // RFC1918
+	"192.168.0.0/16", // RFC1918
+	"169.254.0.0/16", // link-local（含云元数据 169.254.169.254）
+	"100.64.0.0/10",  // CGNAT
+	"0.0.0.0/8",      // "this network"
+	"::1/128",        // IPv6 loopback
+	"fc00::/7",       // IPv6 ULA
+	"fe80::/10",      // IPv6 link-local
+	"::/128",         // IPv6 unspecified
+})
+
+// monitorDialer 共享 Dialer，与 net/http 默认值对齐。
+var monitorDialer = &net.Dialer{
+	Timeout:   monitorDialTimeout,
+	KeepAlive: monitorDialKeepAlive,
+}
+
+// mustParseCIDRs 在包初始化时解析 CIDR 字符串，失败 panic。
+func mustParseCIDRs(cidrs []string) []*net.IPNet {
+	out := make([]*net.IPNet, 0, len(cidrs))
+	for _, c := range cidrs {
+		_, n, err := net.ParseCIDR(c)
+		if err != nil {
+			panic("channel_monitor_ssrf: invalid CIDR " + c + ": " + err.Error())
+		}
+		out = append(out, n)
+	}
+	return out
+}
+
+// isBlockedHostname 判断 hostname 是否命中黑名单。
+func isBlockedHostname(hostname string) bool {
+	if hostname == "" {
+		return true
+	}
+	_, blocked := monitorBlockedHostnames[strings.ToLower(hostname)]
+	return blocked
+}
+
+// isPrivateIP 判断 IP 是否落在禁止段（loopback/RFC1918/link-local/ULA 等）。
+func isPrivateIP(ip net.IP) bool {
+	if ip == nil {
+		return true
+	}
+	if ip.IsUnspecified() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsInterfaceLocalMulticast() {
+		return true
+	}
+	for _, n := range monitorBlockedCIDRs {
+		if n.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}
+
+// isPrivateOrLoopbackHost 解析 hostname 的所有 A/AAAA 记录，
+// 任一 IP 落在私网/loopback 段即认为不安全。
+//
+// hostname 是 IP 字面量时也走同一路径。
+func isPrivateOrLoopbackHost(ctx context.Context, hostname string) (bool, error) {
+	if isBlockedHostname(hostname) {
+		return true, nil
+	}
+	// IP 字面量直接判断。
+	if ip := net.ParseIP(hostname); ip != nil {
+		return isPrivateIP(ip), nil
+	}
+	resolver := net.DefaultResolver
+	addrs, err := resolver.LookupIPAddr(ctx, hostname)
+	if err != nil {
+		return false, err
+	}
+	if len(addrs) == 0 {
+		return true, nil
+	}
+	for _, a := range addrs {
+		if isPrivateIP(a.IP) {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// safeDialContext 在真实 dial 前再次校验目标 IP，防止 DNS rebinding。
+// 解析 hostname 后逐个 IP 尝试连接，命中私网即拒绝（即便 validateEndpoint 时返回的是公网 IP）。
+func safeDialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+	// 字面量 IP 走快速路径。
+	if ip := net.ParseIP(host); ip != nil {
+		if isPrivateIP(ip) {
+			return nil, &net.AddrError{Err: "blocked by SSRF policy", Addr: address}
+		}
+		return monitorDialer.DialContext(ctx, network, address)
+	}
+	if isBlockedHostname(host) {
+		return nil, &net.AddrError{Err: "blocked by SSRF policy", Addr: address}
+	}
+	addrs, err := net.DefaultResolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return nil, err
+	}
+	if len(addrs) == 0 {
+		return nil, &net.AddrError{Err: "no addresses for host", Addr: host}
+	}
+	var lastErr error
+	for _, a := range addrs {
+		if isPrivateIP(a.IP) {
+			lastErr = &net.AddrError{Err: "blocked by SSRF policy", Addr: a.IP.String()}
+			continue
+		}
+		conn, err := monitorDialer.DialContext(ctx, network, net.JoinHostPort(a.IP.String(), port))
+		if err == nil {
+			return conn, nil
+		}
+		lastErr = err
+	}
+	if lastErr == nil {
+		lastErr = &net.AddrError{Err: "no usable addresses", Addr: host}
+	}
+	return nil, lastErr
+}

backend/internal/service/channel_monitor_types.go

+package service
+
+import "time"
+
+// ChannelMonitor 渠道监控配置（service 层模型，不直接暴露 ent 类型）。
+type ChannelMonitor struct {
+	ID              int64
+	Name            string
+	Provider        string
+	Endpoint        string
+	APIKey          string // 解密后的明文 API Key（仅在 service 内部使用，handler 层不应直接序列化返回）
+	PrimaryModel    string
+	ExtraModels     []string
+	GroupName       string
+	Enabled         bool
+	IntervalSeconds int
+	LastCheckedAt   *time.Time
+	CreatedBy       int64
+	CreatedAt       time.Time
+	UpdatedAt       time.Time
+
+	// APIKeyDecryptFailed 表示 APIKey 字段无法解密（密钥不一致或损坏）。
+	// 此时 APIKey 为空字符串，runner / RunCheck 必须跳过该监控并提示重填。
+	APIKeyDecryptFailed bool
+}
+
+// ChannelMonitorListParams 列表查询过滤参数。
+type ChannelMonitorListParams struct {
+	Page     int
+	PageSize int
+	Provider string
+	Enabled  *bool
+	Search   string
+}
+
+// ChannelMonitorCreateParams 创建参数。
+type ChannelMonitorCreateParams struct {
+	Name            string
+	Provider        string
+	Endpoint        string
+	APIKey          string
+	PrimaryModel    string
+	ExtraModels     []string
+	GroupName       string
+	Enabled         bool
+	IntervalSeconds int
+	CreatedBy       int64
+}
+
+// ChannelMonitorUpdateParams 更新参数（指针字段表示"未提供则不更新"）。
+type ChannelMonitorUpdateParams struct {
+	Name            *string
+	Provider        *string
+	Endpoint        *string
+	APIKey          *string // 空字符串表示不修改；非空字符串覆盖
+	PrimaryModel    *string
+	ExtraModels     *[]string
+	GroupName       *string
+	Enabled         *bool
+	IntervalSeconds *int
+}
+
+// CheckResult 单个模型一次检测的结果。
+type CheckResult struct {
+	Model         string
+	Status        string // operational / degraded / failed / error
+	LatencyMs     *int
+	PingLatencyMs *int
+	Message       string
+	CheckedAt     time.Time
+}
+
+// UserMonitorView 用户只读视图：监控概览（含主模型最近状态 + 7d 可用率 + 附加模型最近状态）。
+type UserMonitorView struct {
+	ID               int64
+	Name             string
+	Provider         string
+	GroupName        string
+	PrimaryModel     string
+	PrimaryStatus    string
+	PrimaryLatencyMs *int
+	Availability7d   float64 // 0-100
+	ExtraModels      []ExtraModelStatus
+}
+
+// ExtraModelStatus 附加模型最近一次状态。
+type ExtraModelStatus struct {
+	Model     string
+	Status    string
+	LatencyMs *int
+}
+
+// UserMonitorDetail 用户只读视图：监控详情（含全部模型 7d/15d/30d 可用率与平均延迟）。
+type UserMonitorDetail struct {
+	ID        int64
+	Name      string
+	Provider  string
+	GroupName string
+	Models    []ModelDetail
+}
+
+// ModelDetail 单个模型的可用率/延迟统计。
+type ModelDetail struct {
+	Model           string
+	LatestStatus    string
+	LatestLatencyMs *int
+	Availability7d  float64 // 0-100
+	Availability15d float64
+	Availability30d float64
+	AvgLatency7dMs  *int
+}
+
+// ChannelMonitorHistoryRow 历史记录入库行（service 层向 repository 提交的数据）。
+type ChannelMonitorHistoryRow struct {
+	MonitorID     int64
+	Model         string
+	Status        string
+	LatencyMs     *int
+	PingLatencyMs *int
+	Message       string
+	CheckedAt     time.Time
+}
+
+// ChannelMonitorHistoryEntry 历史记录查询返回行（含 ent 主键 ID）。
+type ChannelMonitorHistoryEntry struct {
+	ID            int64
+	Model         string
+	Status        string
+	LatencyMs     *int
+	PingLatencyMs *int
+	Message       string
+	CheckedAt     time.Time
+}
+
+// ChannelMonitorLatest 最近一次检测的简明信息（用于 UserMonitorView 聚合）。
+type ChannelMonitorLatest struct {
+	Model     string
+	Status    string
+	LatencyMs *int
+	CheckedAt time.Time
+}
+
+// ChannelMonitorAvailability 单个模型在某窗口内的可用率与平均延迟（用于 UserMonitorDetail 聚合）。
+type ChannelMonitorAvailability struct {
+	Model             string
+	WindowDays        int
+	TotalChecks       int
+	OperationalChecks int // operational + degraded 视为可用
+	AvailabilityPct   float64
+	AvgLatencyMs      *int
+}
+
+// MonitorStatusSummary 监控状态聚合（admin list 用，单次 repo 查询消除前端 N+1）。
+// PrimaryStatus / PrimaryLatencyMs 描述主模型最近状态；Availability7d 是主模型 7 天可用率；
+// ExtraModels 描述附加模型最近状态（用于 hover 展示）。
+type MonitorStatusSummary struct {
+	PrimaryStatus    string // 空字符串表示无历史
+	PrimaryLatencyMs *int
+	Availability7d   float64 // 0-100，无历史时为 0
+	ExtraModels      []ExtraModelStatus
+}

backend/internal/service/channel_monitor_validate.go

+package service
+
+import (
+	"context"
+	"net/url"
+	"strings"
+)
+
+// 渠道监控参数校验与归一化辅助函数。
+// 校验失败一律返回 channel_monitor_const.go 中预定义的 Err* 错误，错误信息不含具体 IP/hostname，避免泄露内网拓扑。
+
+// validateProvider 校验 provider 字符串。
+// 唯一来源于 providerAdapters：新增 provider 只需要在 channel_monitor_checker.go 注册 adapter。
+func validateProvider(p string) error {
+	if !isSupportedProvider(p) {
+		return ErrChannelMonitorInvalidProvider
+	}
+	return nil
+}
+
+// validateInterval 校验 interval_seconds 范围。
+func validateInterval(sec int) error {
+	if sec < monitorMinIntervalSeconds || sec > monitorMaxIntervalSeconds {
+		return ErrChannelMonitorInvalidInterval
+	}
+	return nil
+}
+
+// validateEndpoint 校验 endpoint：
+//   - scheme 强制 https（拒绝 http，避免明文凭证 + 部分 SSRF 利用面）
+//   - 必须为 origin（无 path/query/fragment），防止用户填 https://api.openai.com/v1
+//     导致 joinURL 拼出 /v1/v1/chat/completions
+//   - hostname 不能是 localhost/metadata 等已知元数据 hostname
+//   - 解析所有 IP，任一落在 loopback/RFC1918/link-local/ULA 段即拒绝（防 SSRF）
+//
+// 错误信息不暴露具体 IP / hostname，避免泄露内网拓扑。
+func validateEndpoint(ep string) error {
+	ep = strings.TrimSpace(ep)
+	if ep == "" {
+		return ErrChannelMonitorInvalidEndpoint
+	}
+	u, err := url.Parse(ep)
+	if err != nil {
+		return ErrChannelMonitorInvalidEndpoint
+	}
+	if u.Scheme != "https" {
+		return ErrChannelMonitorEndpointScheme
+	}
+	if u.Host == "" {
+		return ErrChannelMonitorInvalidEndpoint
+	}
+	if u.Path != "" && u.Path != "/" {
+		return ErrChannelMonitorEndpointPath
+	}
+	if u.RawQuery != "" || u.Fragment != "" {
+		return ErrChannelMonitorEndpointPath
+	}
+
+	hostname := u.Hostname()
+	ctx, cancel := context.WithTimeout(context.Background(), monitorEndpointResolveTimeout)
+	defer cancel()
+	blocked, err := isPrivateOrLoopbackHost(ctx, hostname)
+	if err != nil {
+		return ErrChannelMonitorEndpointUnreachable
+	}
+	if blocked {
+		return ErrChannelMonitorEndpointPrivate
+	}
+	return nil
+}
+
+// normalizeEndpoint 去除前后空白与末尾 `/`，保证存储统一为 origin。
+// validateEndpoint 已确保格式合法（仅 origin），这里只做最终归一化。
+func normalizeEndpoint(ep string) string {
+	ep = strings.TrimSpace(ep)
+	ep = strings.TrimRight(ep, "/")
+	return ep
+}
+
+// normalizeModels 去除空白、重复模型名。保留输入顺序（map 的迭代顺序无关）。
+func normalizeModels(in []string) []string {
+	if len(in) == 0 {
+		return []string{}
+	}
+	seen := make(map[string]struct{}, len(in))
+	out := make([]string, 0, len(in))
+	for _, m := range in {
+		m = strings.TrimSpace(m)
+		if m == "" {
+			continue
+		}
+		if _, ok := seen[m]; ok {
+			continue
+		}
+		seen[m] = struct{}{}
+		out = append(out, m)
+	}
+	return out
+}

backend/internal/service/wire.go

@@ -467,6 +467,8 @@ var ProviderSet = wire.NewSet(
 	NewPaymentService,
 	ProvidePaymentOrderExpiryService,
 	ProvideBalanceNotifyService,
+	ProvideChannelMonitorService,
+	ProvideChannelMonitorRunner,
 )
 
 // ProvidePaymentConfigService wraps NewPaymentConfigService to accept the named
@@ -486,3 +488,20 @@ func ProvidePaymentOrderExpiryService(paymentSvc *PaymentService) *PaymentOrderE
 	svc.Start()
 	return svc
 }
+
+// ProvideChannelMonitorService 创建渠道监控服务（CRUD + RunCheck + 用户视图聚合）。
+// 加密器复用 wire 中已注入的 SecretEncryptor（AES-256-GCM）。
+func ProvideChannelMonitorService(
+	repo ChannelMonitorRepository,
+	encryptor SecretEncryptor,
+) *ChannelMonitorService {
+	return NewChannelMonitorService(repo, encryptor)
+}
+
+// ProvideChannelMonitorRunner 创建并启动渠道监控调度器。
+// Runner.Stop 由 cleanup function 调用。
+func ProvideChannelMonitorRunner(svc *ChannelMonitorService) *ChannelMonitorRunner {
+	r := NewChannelMonitorRunner(svc)
+	r.Start()
+	return r
+}

backend/migrations/125_add_channel_monitors.sql

+-- Migration: 125_add_channel_monitors
+-- 渠道监控 MVP：周期性对外部 provider/endpoint/api_key 做模型心跳测试。
+--
+-- 表结构说明：
+--   - channel_monitors        渠道配置表（一行 = 一个监控对象）
+--   - channel_monitor_histories 检测历史明细表（一次检测一个模型 = 一行）
+--
+-- 设计要点：
+--   - api_key_encrypted 列存放 AES-256-GCM 密文（base64），由 service 层加密。
+--   - extra_models 用 JSONB 存储字符串数组，便于扩展（后续可加权重等元数据）。
+--   - history 表通过 ON DELETE CASCADE 自动清理已删除监控的历史。
+--   - (enabled, last_checked_at) 索引服务于调度器扫描“到期需要检测”的监控。
+--   - histories 上 (monitor_id, model, checked_at DESC) 服务用户视图聚合查询；
+--     单独的 (checked_at) 索引服务定期清理 30 天前数据的 DELETE。
+
+CREATE TABLE IF NOT EXISTS channel_monitors (
+    id                BIGSERIAL PRIMARY KEY,
+    name              VARCHAR(100) NOT NULL,
+    provider          VARCHAR(20)  NOT NULL,    -- openai / anthropic / gemini
+    endpoint          VARCHAR(500) NOT NULL,    -- base origin
+    api_key_encrypted TEXT         NOT NULL,    -- AES-256-GCM (base64)
+    primary_model     VARCHAR(200) NOT NULL,
+    extra_models      JSONB        NOT NULL DEFAULT '[]'::jsonb,
+    group_name        VARCHAR(100) NOT NULL DEFAULT '',
+    enabled           BOOLEAN      NOT NULL DEFAULT TRUE,
+    interval_seconds  INT          NOT NULL,
+    last_checked_at   TIMESTAMPTZ,
+    created_by        BIGINT       NOT NULL,
+    created_at        TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+    updated_at        TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+    CONSTRAINT channel_monitors_provider_check CHECK (provider IN ('openai', 'anthropic', 'gemini')),
+    CONSTRAINT channel_monitors_interval_check CHECK (interval_seconds BETWEEN 15 AND 3600)
+);
+
+CREATE INDEX IF NOT EXISTS idx_channel_monitors_enabled_last_checked
+    ON channel_monitors (enabled, last_checked_at);
+CREATE INDEX IF NOT EXISTS idx_channel_monitors_provider
+    ON channel_monitors (provider);
+CREATE INDEX IF NOT EXISTS idx_channel_monitors_group_name
+    ON channel_monitors (group_name);
+
+CREATE TABLE IF NOT EXISTS channel_monitor_histories (
+    id              BIGSERIAL PRIMARY KEY,
+    monitor_id      BIGINT      NOT NULL REFERENCES channel_monitors(id) ON DELETE CASCADE,
+    model           VARCHAR(200) NOT NULL,
+    status          VARCHAR(20)  NOT NULL,
+    latency_ms      INT,
+    ping_latency_ms INT,
+    message         VARCHAR(500) NOT NULL DEFAULT '',
+    checked_at      TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+    CONSTRAINT channel_monitor_histories_status_check
+        CHECK (status IN ('operational', 'degraded', 'failed', 'error'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_channel_monitor_histories_monitor_model_checked
+    ON channel_monitor_histories (monitor_id, model, checked_at DESC);
+CREATE INDEX IF NOT EXISTS idx_channel_monitor_histories_checked_at
+    ON channel_monitor_histories (checked_at);

frontend/src/api/admin/channelMonitor.ts

+/**
+ * Admin Channel Monitor API endpoints
+ * Handles channel monitor (uptime/health) management for administrators
+ */
+
+import { apiClient } from '../client'
+
+export type Provider = 'openai' | 'anthropic' | 'gemini'
+export type MonitorStatus = 'operational' | 'degraded' | 'failed' | 'error'
+
+export interface ChannelMonitor {
+  id: number
+  name: string
+  provider: Provider
+  endpoint: string
+  api_key_masked: string
+  /**
+   * True when the stored encrypted API key cannot be decrypted (e.g. the
+   * encryption key has changed). Admin must re-edit the monitor to provide
+   * a fresh key. Backend skips checks for these monitors.
+   */
+  api_key_decrypt_failed?: boolean
+  primary_model: string
+  extra_models: string[]
+  group_name: string
+  enabled: boolean
+  interval_seconds: number
+  last_checked_at: string | null
+  created_by: number
+  created_at: string
+  updated_at: string
+  /** Latest status of the primary model (empty when no history yet) */
+  primary_status: MonitorStatus | ''
+  /** Latest latency of the primary model in ms (null when no history yet) */
+  primary_latency_ms: number | null
+  /** Primary model 7-day availability percentage (0-100) */
+  availability_7d: number
+  /** Latest status per extra model (used for hover tooltip) */
+  extra_models_status: ExtraModelStatus[]
+}
+
+export interface ExtraModelStatus {
+  model: string
+  status: MonitorStatus | ''
+  latency_ms: number | null
+}
+
+export interface ListParams {
+  page?: number
+  page_size?: number
+  provider?: Provider
+  enabled?: boolean
+  search?: string
+}
+
+export interface ListResponse {
+  items: ChannelMonitor[]
+  total: number
+  page: number
+  page_size: number
+  pages: number
+}
+
+export interface CreateParams {
+  name: string
+  provider: Provider
+  endpoint: string
+  api_key: string
+  primary_model: string
+  extra_models?: string[]
+  group_name?: string
+  enabled?: boolean
+  interval_seconds: number
+}
+
+// Update request: api_key empty string means "do not modify"
+export type UpdateParams = Partial<CreateParams>
+
+export interface CheckResult {
+  model: string
+  status: MonitorStatus
+  latency_ms: number | null
+  ping_latency_ms: number | null
+  message: string
+  checked_at: string
+}
+
+export interface RunNowResponse {
+  results: CheckResult[]
+}
+
+export interface HistoryItem {
+  id: number
+  model: string
+  status: MonitorStatus
+  latency_ms: number | null
+  ping_latency_ms: number | null
+  message: string
+  checked_at: string
+}
+
+export interface HistoryParams {
+  model?: string
+  limit?: number
+}
+
+export interface HistoryResponse {
+  items: HistoryItem[]
+}
+
+/**
+ * List channel monitors with pagination and filters
+ */
+export async function list(
+  params: ListParams = {},
+  options?: { signal?: AbortSignal }
+): Promise<ListResponse> {
+  const { data } = await apiClient.get<ListResponse>('/admin/channel-monitors', {
+    params,
+    signal: options?.signal,
+  })
+  return data
+}
+
+/**
+ * Get a channel monitor by ID
+ */
+export async function get(id: number): Promise<ChannelMonitor> {
+  const { data } = await apiClient.get<ChannelMonitor>(`/admin/channel-monitors/${id}`)
+  return data
+}
+
+/**
+ * Create a new channel monitor
+ */
+export async function create(params: CreateParams): Promise<ChannelMonitor> {
+  const { data } = await apiClient.post<ChannelMonitor>('/admin/channel-monitors', params)
+  return data
+}
+
+/**
+ * Update an existing channel monitor.
+ * api_key field: empty string means "do not modify".
+ */
+export async function update(id: number, params: UpdateParams): Promise<ChannelMonitor> {
+  const { data } = await apiClient.put<ChannelMonitor>(`/admin/channel-monitors/${id}`, params)
+  return data
+}
+
+/**
+ * Delete a channel monitor
+ */
+export async function del(id: number): Promise<void> {
+  await apiClient.delete(`/admin/channel-monitors/${id}`)
+}
+
+/**
+ * Trigger an immediate manual check for a channel monitor.
+ * Returns the latest check results for primary + extra models.
+ */
+export async function runNow(id: number): Promise<RunNowResponse> {
+  const { data } = await apiClient.post<RunNowResponse>(`/admin/channel-monitors/${id}/run`)
+  return data
+}
+
+/**
+ * List historical check results for a monitor.
+ */
+export async function listHistory(
+  id: number,
+  params: HistoryParams = {}
+): Promise<HistoryResponse> {
+  const { data } = await apiClient.get<HistoryResponse>(
+    `/admin/channel-monitors/${id}/history`,
+    { params }
+  )
+  return data
+}
+
+export const channelMonitorAPI = {
+  list,
+  get,
+  create,
+  update,
+  del,
+  runNow,
+  listHistory,
+}
+
+export default channelMonitorAPI

frontend/src/api/admin/index.ts

@@ -26,6 +26,7 @@ import scheduledTestsAPI from './scheduledTests'
 import backupAPI from './backup'
 import tlsFingerprintProfileAPI from './tlsFingerprintProfile'
 import channelsAPI from './channels'
+import channelMonitorAPI from './channelMonitor'
 import adminPaymentAPI from './payment'
 
 /**
@@ -55,6 +56,7 @@ export const adminAPI = {
   backup: backupAPI,
   tlsFingerprintProfiles: tlsFingerprintProfileAPI,
   channels: channelsAPI,
+  channelMonitor: channelMonitorAPI,
   payment: adminPaymentAPI
 }
 
@@ -82,6 +84,7 @@ export {
   backupAPI,
   tlsFingerprintProfileAPI,
   channelsAPI,
+  channelMonitorAPI,
   adminPaymentAPI
 }
 

frontend/src/api/channelMonitor.ts

+/**
+ * User-facing Channel Monitor API endpoints
+ * Read-only views for end users to inspect channel availability/status.
+ */
+
+import { apiClient } from './client'
+import type { Provider, MonitorStatus } from './admin/channelMonitor'
+
+export type { Provider, MonitorStatus } from './admin/channelMonitor'
+
+export interface UserMonitorExtraModel {
+  model: string
+  status: MonitorStatus
+  latency_ms: number | null
+}
+
+export interface UserMonitorView {
+  id: number
+  name: string
+  provider: Provider
+  group_name: string
+  primary_model: string
+  primary_status: MonitorStatus
+  primary_latency_ms: number | null
+  availability_7d: number
+  extra_models: UserMonitorExtraModel[]
+}
+
+export interface UserMonitorListResponse {
+  items: UserMonitorView[]
+}
+
+export interface UserMonitorModelDetail {
+  model: string
+  latest_status: MonitorStatus
+  latest_latency_ms: number | null
+  availability_7d: number
+  availability_15d: number
+  availability_30d: number
+  avg_latency_7d_ms: number | null
+}
+
+export interface UserMonitorDetail {
+  id: number
+  name: string
+  provider: Provider
+  group_name: string
+  models: UserMonitorModelDetail[]
+}
+
+/**
+ * List all monitor views available to the current user.
+ */
+export async function list(options?: { signal?: AbortSignal }): Promise<UserMonitorListResponse> {
+  const { data } = await apiClient.get<UserMonitorListResponse>('/channel-monitors', {
+    signal: options?.signal,
+  })
+  return data
+}
+
+/**
+ * Get detailed status (multi-window availability + latency) for a single monitor.
+ */
+export async function status(id: number): Promise<UserMonitorDetail> {
+  const { data } = await apiClient.get<UserMonitorDetail>(`/channel-monitors/${id}/status`)
+  return data
+}
+
+export const channelMonitorUserAPI = {
+  list,
+  status,
+}
+
+export default channelMonitorUserAPI

frontend/src/api/index.ts

@@ -18,6 +18,7 @@ export { paymentAPI } from './payment'
 export { userGroupsAPI } from './groups'
 export { totpAPI } from './totp'
 export { default as announcementsAPI } from './announcements'
+export { channelMonitorUserAPI } from './channelMonitor'
 
 // Admin APIs
 export { adminAPI } from './admin'

frontend/src/components/admin/monitor/MonitorActionsCell.vue

+<template>
+  <div class="flex items-center gap-1">
+    <button
+      @click="$emit('run', row)"
+      :disabled="running"
+      class="flex flex-col items-center gap-0.5 rounded-lg p-1.5 text-gray-500 transition-colors hover:bg-gray-100 hover:text-primary-600 dark:hover:bg-dark-700 dark:hover:text-primary-400"
+    >
+      <Icon name="refresh" size="sm" :class="running ? 'animate-spin' : ''" />
+      <span class="text-xs">{{ t('admin.channelMonitor.runNow') }}</span>
+    </button>
+    <button
+      @click="$emit('edit', row)"
+      class="flex flex-col items-center gap-0.5 rounded-lg p-1.5 text-gray-500 transition-colors hover:bg-gray-100 hover:text-primary-600 dark:hover:bg-dark-700 dark:hover:text-primary-400"
+    >
+      <Icon name="edit" size="sm" />
+      <span class="text-xs">{{ t('common.edit') }}</span>
+    </button>
+    <button
+      @click="$emit('delete', row)"
+      class="flex flex-col items-center gap-0.5 rounded-lg p-1.5 text-gray-500 transition-colors hover:bg-red-50 hover:text-red-600 dark:hover:bg-red-900/20 dark:hover:text-red-400"
+    >
+      <Icon name="trash" size="sm" />
+      <span class="text-xs">{{ t('common.delete') }}</span>
+    </button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { ChannelMonitor } from '@/api/admin/channelMonitor'
+import Icon from '@/components/icons/Icon.vue'
+
+defineProps<{
+  row: ChannelMonitor
+  running: boolean
+}>()
+
+defineEmits<{
+  (e: 'run', row: ChannelMonitor): void
+  (e: 'edit', row: ChannelMonitor): void
+  (e: 'delete', row: ChannelMonitor): void
+}>()
+
+const { t } = useI18n()
+</script>

frontend/src/components/admin/monitor/MonitorFiltersBar.vue

+<template>
+  <div class="flex flex-col justify-between gap-4 lg:flex-row lg:items-start">
+    <!-- Left: Search + Filters -->
+    <div class="flex flex-1 flex-wrap items-center gap-3">
+      <div class="relative w-full sm:w-64">
+        <Icon
+          name="search"
+          size="md"
+          class="absolute left-3 top-1/2 -translate-y-1/2 text-gray-400 dark:text-gray-500"
+        />
+        <input
+          v-model="search"
+          type="text"
+          :placeholder="t('admin.channelMonitor.searchPlaceholder')"
+          class="input pl-10"
+          @input="$emit('search-input')"
+        />
+      </div>
+
+      <Select
+        v-model="provider"
+        :options="providerFilterOptions"
+        :placeholder="t('admin.channelMonitor.allProviders')"
+        class="w-44"
+        @change="$emit('reload')"
+      />
+
+      <Select
+        v-model="enabled"
+        :options="enabledFilterOptions"
+        :placeholder="t('admin.channelMonitor.enabledFilter')"
+        class="w-40"
+        @change="$emit('reload')"
+      />
+    </div>
+
+    <!-- Right: Actions -->
+    <div class="flex w-full flex-shrink-0 flex-wrap items-center justify-end gap-3 lg:w-auto">
+      <button
+        @click="$emit('reload')"
+        :disabled="loading"
+        class="btn btn-secondary"
+        :title="t('common.refresh')"
+      >
+        <Icon name="refresh" size="md" :class="loading ? 'animate-spin' : ''" />
+      </button>
+      <button @click="$emit('create')" class="btn btn-primary">
+        <Icon name="plus" size="md" class="mr-2" />
+        {{ t('admin.channelMonitor.createButton') }}
+      </button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import type { Provider } from '@/api/admin/channelMonitor'
+import Select from '@/components/common/Select.vue'
+import Icon from '@/components/icons/Icon.vue'
+import {
+  PROVIDER_OPENAI,
+  PROVIDER_ANTHROPIC,
+  PROVIDER_GEMINI,
+} from '@/constants/channelMonitor'
+
+defineProps<{
+  loading: boolean
+}>()
+
+defineEmits<{
+  (e: 'reload'): void
+  (e: 'create'): void
+  (e: 'search-input'): void
+}>()
+
+const search = defineModel<string>('search', { required: true })
+const provider = defineModel<Provider | ''>('provider', { required: true })
+const enabled = defineModel<'' | 'true' | 'false'>('enabled', { required: true })
+
+const { t } = useI18n()
+
+const providerFilterOptions = computed(() => [
+  { value: '', label: t('admin.channelMonitor.allProviders') },
+  { value: PROVIDER_OPENAI, label: t('monitorCommon.providers.openai') },
+  { value: PROVIDER_ANTHROPIC, label: t('monitorCommon.providers.anthropic') },
+  { value: PROVIDER_GEMINI, label: t('monitorCommon.providers.gemini') },
+])
+
+const enabledFilterOptions = computed(() => [
+  { value: '', label: t('admin.channelMonitor.allStatus') },
+  { value: 'true', label: t('admin.channelMonitor.onlyEnabled') },
+  { value: 'false', label: t('admin.channelMonitor.onlyDisabled') },
+])
+</script>

frontend/src/components/admin/monitor/MonitorFormDialog.vue

+<template>
+  <BaseDialog
+    :show="show"
+    :title="editing ? t('admin.channelMonitor.editTitle') : t('admin.channelMonitor.createTitle')"
+    width="wide"
+    @close="$emit('close')"
+  >
+    <form id="channel-monitor-form" @submit.prevent="handleSubmit" class="space-y-5">
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.name') }} <span class="text-red-500">*</span></label>
+        <input v-model="form.name" type="text" required class="input" :placeholder="t('admin.channelMonitor.form.namePlaceholder')" />
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.provider') }} <span class="text-red-500">*</span></label>
+        <Select v-model="form.provider" :options="providerOptions" />
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.endpoint') }} <span class="text-red-500">*</span></label>
+        <div class="flex gap-2">
+          <input v-model="form.endpoint" type="text" required class="input flex-1" :placeholder="t('admin.channelMonitor.form.endpointPlaceholder')" />
+          <button type="button" @click="useCurrentDomain" class="btn btn-secondary whitespace-nowrap">
+            {{ t('admin.channelMonitor.form.useCurrentDomain') }}
+          </button>
+        </div>
+      </div>
+
+      <div>
+        <label class="input-label">
+          {{ t('admin.channelMonitor.form.apiKey') }}<span v-if="!editing" class="text-red-500"> *</span>
+        </label>
+        <div class="flex gap-2">
+          <input
+            v-model="form.api_key"
+            type="password"
+            :required="!editing"
+            class="input flex-1"
+            :placeholder="editing ? t('admin.channelMonitor.form.apiKeyEditPlaceholder') : t('admin.channelMonitor.form.apiKeyPlaceholder')"
+          />
+          <button type="button" @click="openMyKeyPicker" class="btn btn-secondary whitespace-nowrap">
+            {{ t('admin.channelMonitor.form.useMyKey') }}
+          </button>
+        </div>
+        <p v-if="editing && editing.api_key_masked" class="mt-1 text-xs text-gray-400">{{ editing.api_key_masked }}</p>
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.primaryModel') }} <span class="text-red-500">*</span></label>
+        <input v-model="form.primary_model" type="text" required class="input" :placeholder="t('admin.channelMonitor.form.primaryModelPlaceholder')" />
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.extraModels') }}</label>
+        <ModelTagInput
+          :models="form.extra_models"
+          :placeholder="t('admin.channelMonitor.form.extraModelsPlaceholder')"
+          @update:models="form.extra_models = $event"
+        />
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.groupName') }}</label>
+        <input v-model="form.group_name" type="text" class="input" :placeholder="t('admin.channelMonitor.form.groupNamePlaceholder')" />
+      </div>
+
+      <div>
+        <label class="input-label">{{ t('admin.channelMonitor.form.intervalSeconds') }} <span class="text-red-500">*</span></label>
+        <input v-model.number="form.interval_seconds" type="number" min="15" max="3600" required class="input" />
+        <p class="mt-1 text-xs text-gray-400">{{ t('admin.channelMonitor.form.intervalSecondsHint') }}</p>
+      </div>
+
+      <div class="flex items-center justify-between">
+        <label class="input-label mb-0">{{ t('admin.channelMonitor.form.enabled') }}</label>
+        <Toggle v-model="form.enabled" />
+      </div>
+    </form>
+
+    <template #footer>
+      <div class="flex justify-end gap-3">
+        <button @click="$emit('close')" type="button" class="btn btn-secondary">
+          {{ t('common.cancel') }}
+        </button>
+        <button
+          type="submit"
+          form="channel-monitor-form"
+          :disabled="submitting"
+          class="btn btn-primary"
+        >
+          {{ submitting
+            ? t('common.submitting')
+            : editing ? t('common.update') : t('common.create') }}
+        </button>
+      </div>
+    </template>
+  </BaseDialog>
+
+  <MonitorKeyPickerDialog
+    :show="showKeyPicker"
+    :loading="myKeysLoading"
+    :keys="myActiveKeys"
+    @close="showKeyPicker = false"
+    @pick="pickMyKey"
+  />
+</template>
+
+<script setup lang="ts">
+import { ref, reactive, computed, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useAppStore } from '@/stores/app'
+import { extractApiErrorMessage } from '@/utils/apiError'
+import { adminAPI } from '@/api/admin'
+import { keysAPI } from '@/api/keys'
+import type {
+  ChannelMonitor,
+  CreateParams,
+  Provider,
+  UpdateParams,
+} from '@/api/admin/channelMonitor'
+import type { ApiKey } from '@/types'
+import BaseDialog from '@/components/common/BaseDialog.vue'
+import Select from '@/components/common/Select.vue'
+import Toggle from '@/components/common/Toggle.vue'
+import ModelTagInput from '@/components/admin/channel/ModelTagInput.vue'
+import MonitorKeyPickerDialog from '@/components/admin/monitor/MonitorKeyPickerDialog.vue'
+import {
+  PROVIDER_OPENAI,
+  PROVIDER_ANTHROPIC,
+  PROVIDER_GEMINI,
+  DEFAULT_INTERVAL_SECONDS,
+} from '@/constants/channelMonitor'
+
+const props = defineProps<{
+  show: boolean
+  monitor: ChannelMonitor | null
+}>()
+
+const emit = defineEmits<{
+  (e: 'close'): void
+  (e: 'saved'): void
+}>()
+
+const { t } = useI18n()
+const appStore = useAppStore()
+
+// editing is true when we have an existing monitor
+const editing = computed<ChannelMonitor | null>(() => props.monitor)
+
+const submitting = ref(false)
+
+// API key picker
+const showKeyPicker = ref(false)
+const myKeysLoading = ref(false)
+const myActiveKeys = ref<ApiKey[]>([])
+
+interface MonitorForm {
+  name: string
+  provider: Provider
+  endpoint: string
+  api_key: string
+  primary_model: string
+  extra_models: string[]
+  group_name: string
+  interval_seconds: number
+  enabled: boolean
+}
+
+const form = reactive<MonitorForm>({
+  name: '',
+  provider: PROVIDER_OPENAI,
+  endpoint: '',
+  api_key: '',
+  primary_model: '',
+  extra_models: [],
+  group_name: '',
+  interval_seconds: DEFAULT_INTERVAL_SECONDS,
+  enabled: true,
+})
+
+const providerOptions = computed(() => [
+  { value: PROVIDER_OPENAI, label: t('monitorCommon.providers.openai') },
+  { value: PROVIDER_ANTHROPIC, label: t('monitorCommon.providers.anthropic') },
+  { value: PROVIDER_GEMINI, label: t('monitorCommon.providers.gemini') },
+])
+
+function resetForm() {
+  form.name = ''
+  form.provider = PROVIDER_OPENAI
+  form.endpoint = ''
+  form.api_key = ''
+  form.primary_model = ''
+  form.extra_models = []
+  form.group_name = ''
+  form.interval_seconds = DEFAULT_INTERVAL_SECONDS
+  form.enabled = true
+}
+
+function loadFromMonitor(m: ChannelMonitor) {
+  form.name = m.name
+  form.provider = m.provider
+  form.endpoint = m.endpoint
+  form.api_key = ''
+  form.primary_model = m.primary_model
+  form.extra_models = [...(m.extra_models || [])]
+  form.group_name = m.group_name || ''
+  form.interval_seconds = m.interval_seconds || DEFAULT_INTERVAL_SECONDS
+  form.enabled = m.enabled
+}
+
+// Re-sync form whenever the dialog is opened or the target monitor changes.
+watch(
+  () => [props.show, props.monitor] as const,
+  ([show, m]) => {
+    if (!show) return
+    if (m) loadFromMonitor(m)
+    else resetForm()
+  },
+  { immediate: true },
+)
+
+function useCurrentDomain() {
+  form.endpoint = window.location.origin
+}
+
+async function openMyKeyPicker() {
+  showKeyPicker.value = true
+  if (myActiveKeys.value.length > 0) return
+  myKeysLoading.value = true
+  try {
+    const res = await keysAPI.list(1, 100, { status: 'active' })
+    const items = res.items || []
+    const now = Date.now()
+    myActiveKeys.value = items.filter(k => {
+      if (k.status !== 'active') return false
+      if (!k.expires_at) return true
+      return new Date(k.expires_at).getTime() > now
+    })
+  } catch (err: unknown) {
+    appStore.showError(extractApiErrorMessage(err, t('admin.channelMonitor.form.noActiveKey')))
+  } finally {
+    myKeysLoading.value = false
+  }
+}
+
+function pickMyKey(k: ApiKey) {
+  form.api_key = k.key
+  showKeyPicker.value = false
+}
+
+function buildPayload(): CreateParams {
+  return {
+    name: form.name.trim(),
+    provider: form.provider,
+    endpoint: form.endpoint.trim(),
+    api_key: form.api_key.trim(),
+    primary_model: form.primary_model.trim(),
+    extra_models: form.extra_models,
+    group_name: form.group_name.trim(),
+    enabled: form.enabled,
+    interval_seconds: form.interval_seconds,
+  }
+}
+
+async function handleSubmit() {
+  if (submitting.value) return
+  if (!form.name.trim()) {
+    appStore.showError(t('admin.channelMonitor.nameRequired'))
+    return
+  }
+  if (!form.primary_model.trim()) {
+    appStore.showError(t('admin.channelMonitor.primaryModelRequired'))
+    return
+  }
+
+  submitting.value = true
+  try {
+    const target = editing.value
+    if (target) {
+      const { api_key, ...rest } = buildPayload()
+      const req: UpdateParams = rest
+      // Only send api_key if user typed a new value
+      if (api_key) req.api_key = api_key
+      await adminAPI.channelMonitor.update(target.id, req)
+      appStore.showSuccess(t('admin.channelMonitor.updateSuccess'))
+    } else {
+      await adminAPI.channelMonitor.create(buildPayload())
+      appStore.showSuccess(t('admin.channelMonitor.createSuccess'))
+    }
+    emit('saved')
+    emit('close')
+  } catch (err: unknown) {
+    appStore.showError(extractApiErrorMessage(err, t('common.error')))
+  } finally {
+    submitting.value = false
+  }
+}
+</script>

frontend/src/components/admin/monitor/MonitorKeyPickerDialog.vue

+<template>
+  <BaseDialog
+    :show="show"
+    :title="t('admin.channelMonitor.form.selectKeyTitle')"
+    width="normal"
+    @close="$emit('close')"
+  >
+    <div class="space-y-3">
+      <p class="text-xs text-gray-500 dark:text-gray-400">
+        {{ t('admin.channelMonitor.form.selectKeyHint') }}
+      </p>
+      <div v-if="loading" class="py-6 text-center text-sm text-gray-500">
+        {{ t('common.loading') }}
+      </div>
+      <div v-else-if="keys.length === 0" class="py-6 text-center text-sm text-gray-500">
+        {{ t('admin.channelMonitor.form.noActiveKey') }}
+      </div>
+      <div v-else class="max-h-72 space-y-1 overflow-auto">
+        <button
+          v-for="k in keys"
+          :key="k.id"
+          type="button"
+          @click="$emit('pick', k)"
+          class="block w-full rounded-lg border border-gray-200 px-3 py-2 text-left text-sm transition-colors hover:bg-gray-50 dark:border-dark-600 dark:hover:bg-dark-700"
+        >
+          <div class="font-medium text-gray-900 dark:text-white">{{ k.name }}</div>
+          <div class="font-mono text-xs text-gray-500 dark:text-gray-400">{{ maskKey(k.key) }}</div>
+        </button>
+      </div>
+    </div>
+    <template #footer>
+      <div class="flex justify-end">
+        <button @click="$emit('close')" class="btn btn-secondary">
+          {{ t('common.cancel') }}
+        </button>
+      </div>
+    </template>
+  </BaseDialog>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { ApiKey } from '@/types'
+import BaseDialog from '@/components/common/BaseDialog.vue'
+
+defineProps<{
+  show: boolean
+  loading: boolean
+  keys: ApiKey[]
+}>()
+
+defineEmits<{
+  (e: 'close'): void
+  (e: 'pick', key: ApiKey): void
+}>()
+
+const { t } = useI18n()
+
+function maskKey(key: string): string {
+  if (!key) return ''
+  if (key.length <= 12) return `${key.slice(0, 4)}***`
+  return `${key.slice(0, 6)}...${key.slice(-4)}`
+}
+</script>

frontend/src/components/admin/monitor/MonitorPrimaryModelCell.vue

+<template>
+  <div class="flex items-center gap-2">
+    <span class="text-sm text-gray-900 dark:text-gray-100">{{ row.primary_model }}</span>
+    <HelpTooltip>
+      <template #trigger>
+        <span
+          class="inline-flex items-center rounded-full px-2 py-0.5 text-[11px] font-medium"
+          :class="statusBadgeClass(row.primary_status)"
+        >
+          {{ statusLabel(row.primary_status) }}
+        </span>
+      </template>
+      <div class="space-y-2">
+        <div class="text-xs font-semibold text-gray-100">
+          {{ row.primary_model }}
+          <span
+            class="ml-1 inline-flex items-center rounded-full px-1.5 py-0.5 text-[10px] font-medium"
+            :class="statusBadgeClass(row.primary_status)"
+          >
+            {{ statusLabel(row.primary_status) }}
+          </span>
+        </div>
+        <div v-if="(row.extra_models?.length ?? 0) === 0" class="text-[11px] text-gray-300">
+          {{ t('monitorCommon.extraModelsEmpty') }}
+        </div>
+        <div v-else class="space-y-1">
+          <div class="text-[11px] font-semibold uppercase tracking-wide text-gray-400">
+            {{ t('monitorCommon.extraModelsHeader') }}
+          </div>
+          <table class="w-full text-left text-[11px]">
+            <thead>
+              <tr class="text-gray-400">
+                <th class="py-0.5 pr-2 font-medium">{{ t('admin.channelMonitor.columns.primaryModel') }}</th>
+                <th class="py-0.5 pr-2 font-medium">{{ t('admin.channelMonitor.columns.actions') }}</th>
+                <th class="py-0.5 font-medium">{{ t('admin.channelMonitor.columns.latency') }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="m in (row.extra_models_status || [])" :key="m.model">
+                <td class="py-0.5 pr-2 text-gray-100">{{ m.model }}</td>
+                <td class="py-0.5 pr-2">
+                  <span
+                    class="inline-flex items-center rounded-full px-1.5 py-0.5 text-[10px]"
+                    :class="statusBadgeClass(m.status)"
+                  >
+                    {{ statusLabel(m.status) }}
+                  </span>
+                </td>
+                <td class="py-0.5 text-gray-100">{{ formatLatency(m.latency_ms) }}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </HelpTooltip>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { ChannelMonitor } from '@/api/admin/channelMonitor'
+import HelpTooltip from '@/components/common/HelpTooltip.vue'
+import { useChannelMonitorFormat } from '@/composables/useChannelMonitorFormat'
+
+defineProps<{
+  row: ChannelMonitor
+}>()
+
+const { t } = useI18n()
+const { statusLabel, statusBadgeClass, formatLatency } = useChannelMonitorFormat()
+</script>

frontend/src/components/admin/monitor/MonitorRunResultDialog.vue

+<template>
+  <BaseDialog
+    :show="show"
+    :title="t('admin.channelMonitor.runResultTitle')"
+    width="normal"
+    @close="$emit('close')"
+  >
+    <div class="space-y-2">
+      <div
+        v-for="r in results"
+        :key="r.model"
+        class="flex items-center justify-between rounded-lg border border-gray-200 px-3 py-2 text-sm dark:border-dark-600"
+      >
+        <div class="flex flex-col">
+          <span class="font-medium text-gray-900 dark:text-white">{{ r.model }}</span>
+          <span v-if="r.message" class="text-xs text-gray-500 dark:text-gray-400">{{ r.message }}</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <span
+            class="inline-flex items-center rounded-full px-2 py-0.5 text-[11px]"
+            :class="statusBadgeClass(r.status)"
+          >
+            {{ statusLabel(r.status) }}
+          </span>
+          <span class="text-xs text-gray-500 dark:text-gray-400">{{ formatLatency(r.latency_ms) }} ms</span>
+        </div>
+      </div>
+    </div>
+    <template #footer>
+      <div class="flex justify-end">
+        <button @click="$emit('close')" class="btn btn-primary">
+          {{ t('common.close') }}
+        </button>
+      </div>
+    </template>
+  </BaseDialog>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { CheckResult } from '@/api/admin/channelMonitor'
+import BaseDialog from '@/components/common/BaseDialog.vue'
+import { useChannelMonitorFormat } from '@/composables/useChannelMonitorFormat'
+
+defineProps<{
+  show: boolean
+  results: CheckResult[]
+}>()
+
+defineEmits<{
+  (e: 'close'): void
+}>()
+
+const { t } = useI18n()
+const { statusLabel, statusBadgeClass, formatLatency } = useChannelMonitorFormat()
+</script>

frontend/src/components/layout/AppSidebar.vue

@@ -38,7 +38,7 @@
                   'sidebar-link-collapsed': sidebarCollapsed
                 }"
                 :title="sidebarCollapsed ? item.label : undefined"
-                @click="sidebarCollapsed ? undefined : toggleGroup(item)"
+                @click="handleGroupClick(item)"
               >
                 <component :is="item.icon" class="h-5 w-5 flex-shrink-0" />
                 <span
@@ -181,7 +181,7 @@
 
 <script setup lang="ts">
 import { computed, h, onMounted, ref, watch } from 'vue'
-import { useRoute } from 'vue-router'
+import { useRoute, useRouter } from 'vue-router'
 import { useI18n } from 'vue-i18n'
 import { useAdminSettingsStore, useAppStore, useAuthStore, useOnboardingStore } from '@/stores'
 import VersionBadge from '@/components/common/VersionBadge.vue'
@@ -194,11 +194,17 @@ interface NavItem {
   iconSvg?: string
   hideInSimpleMode?: boolean
   children?: NavItem[]
+  /**
+   * When true, the parent item only toggles the expand/collapse state and
+   * does NOT navigate to its `path`. The `path` is purely a stable key.
+   */
+  expandOnly?: boolean
 }
 
 const { t } = useI18n()
 
 const route = useRoute()
+const router = useRouter()
 const appStore = useAppStore()
 const authStore = useAuthStore()
 const onboardingStore = useOnboardingStore()
@@ -549,6 +555,41 @@ const ChevronDoubleRightIcon = {
     )
 }
 
+const SignalIcon = {
+  render: () =>
+    h(
+      'svg',
+      { fill: 'none', viewBox: '0 0 24 24', stroke: 'currentColor', 'stroke-width': '1.5' },
+      [
+        h('path', {
+          'stroke-linecap': 'round',
+          'stroke-linejoin': 'round',
+          d: 'M9.348 14.651a3.75 3.75 0 010-5.303m5.304 0a3.75 3.75 0 010 5.303m-7.425 2.122a6.75 6.75 0 010-9.546m9.546 0a6.75 6.75 0 010 9.546M5.106 18.894c-3.808-3.807-3.808-9.98 0-13.788m13.788 0c3.808 3.807 3.808 9.98 0 13.788M12 12h.008v.008H12V12zm.375 0a.375.375 0 11-.75 0 .375.375 0 01.75 0z'
+        })
+      ]
+    )
+}
+
+const PriceTagIcon = {
+  render: () =>
+    h(
+      'svg',
+      { fill: 'none', viewBox: '0 0 24 24', stroke: 'currentColor', 'stroke-width': '1.5' },
+      [
+        h('path', {
+          'stroke-linecap': 'round',
+          'stroke-linejoin': 'round',
+          d: 'M9.568 3H5.25A2.25 2.25 0 003 5.25v4.318c0 .597.237 1.17.659 1.591l9.581 9.581c.699.699 1.78.872 2.607.33a18.095 18.095 0 005.223-5.223c.542-.827.369-1.908-.33-2.607L11.16 3.66A2.25 2.25 0 009.568 3z'
+        }),
+        h('path', {
+          'stroke-linecap': 'round',
+          'stroke-linejoin': 'round',
+          d: 'M6 6h.008v.008H6V6z'
+        })
+      ]
+    )
+}
+
 const ChevronDownIcon = {
   render: () =>
     h(
@@ -570,6 +611,7 @@ const userNavItems = computed((): NavItem[] => {
     { path: '/dashboard', label: t('nav.dashboard'), icon: DashboardIcon },
     { path: '/keys', label: t('nav.apiKeys'), icon: KeyIcon },
     { path: '/usage', label: t('nav.usage'), icon: ChartIcon, hideInSimpleMode: true },
+    { path: '/monitor', label: t('nav.channelStatus'), icon: SignalIcon },
     { path: '/subscriptions', label: t('nav.mySubscriptions'), icon: CreditCardIcon, hideInSimpleMode: true },
     ...(appStore.cachedPublicSettings?.payment_enabled
       ? [
@@ -608,6 +650,7 @@ const personalNavItems = computed((): NavItem[] => {
   const items: NavItem[] = [
     { path: '/keys', label: t('nav.apiKeys'), icon: KeyIcon },
     { path: '/usage', label: t('nav.usage'), icon: ChartIcon, hideInSimpleMode: true },
+    { path: '/monitor', label: t('nav.channelStatus'), icon: SignalIcon },
     { path: '/subscriptions', label: t('nav.mySubscriptions'), icon: CreditCardIcon, hideInSimpleMode: true },
     ...(appStore.cachedPublicSettings?.payment_enabled
       ? [
@@ -664,7 +707,17 @@ const adminNavItems = computed((): NavItem[] => {
       : []),
     { path: '/admin/users', label: t('nav.users'), icon: UsersIcon, hideInSimpleMode: true },
     { path: '/admin/groups', label: t('nav.groups'), icon: FolderIcon, hideInSimpleMode: true },
-    { path: '/admin/channels', label: t('nav.channels', '渠道管理'), icon: ChannelIcon, hideInSimpleMode: true },
+    {
+      path: '/admin/channels',
+      label: t('nav.channelManagement'),
+      icon: ChannelIcon,
+      hideInSimpleMode: true,
+      expandOnly: true,
+      children: [
+        { path: '/admin/channels/pricing', label: t('nav.channelPricing'), icon: PriceTagIcon },
+        { path: '/admin/channels/monitor', label: t('nav.channelMonitor'), icon: SignalIcon },
+      ],
+    },
     { path: '/admin/subscriptions', label: t('nav.subscriptions'), icon: CreditCardIcon, hideInSimpleMode: true },
     { path: '/admin/accounts', label: t('nav.accounts'), icon: GlobeIcon },
     { path: '/admin/announcements', label: t('nav.announcements'), icon: BellIcon },
@@ -678,6 +731,7 @@ const adminNavItems = computed((): NavItem[] => {
             label: t('nav.orderManagement'),
             icon: OrderIcon,
             hideInSimpleMode: true,
+            expandOnly: true,
             children: [
               { path: '/admin/orders/dashboard', label: t('nav.paymentDashboard'), icon: ChartIcon },
               { path: '/admin/orders', label: t('nav.orderManagement'), icon: OrderIcon },
@@ -764,6 +818,28 @@ function toggleGroup(item: NavItem) {
   }
 }
 
+/**
+ * Click handler for collapsible parent items.
+ * - When sidebar is collapsed: do nothing (children are not visible).
+ * - When `expandOnly` is true: only toggle expand state.
+ * - Otherwise (default, e.g. /admin/orders): navigate to the parent path
+ *   (router-link semantics) and ensure the group is expanded.
+ */
+function handleGroupClick(item: NavItem) {
+  if (sidebarCollapsed.value) return
+  if (item.expandOnly) {
+    toggleGroup(item)
+    return
+  }
+  // Push to path and ensure expanded
+  if (route.path !== item.path) {
+    router.push(item.path)
+  }
+  if (!expandedGroups.value.has(item.path)) {
+    expandedGroups.value.add(item.path)
+  }
+}
+
 // Initialize theme
 const savedTheme = localStorage.getItem('theme')
 if (

frontend/src/components/user/MonitorDetailDialog.vue

+<template>
+  <BaseDialog
+    :show="show"
+    :title="title"
+    width="wide"
+    @close="$emit('close')"
+  >
+    <div v-if="loading" class="py-8 text-center text-sm text-gray-500">
+      {{ t('common.loading') }}
+    </div>
+    <div v-else-if="!detail" class="py-8 text-center text-sm text-gray-500">
+      {{ t('channelStatus.detailLoadError') }}
+    </div>
+    <div v-else class="overflow-x-auto">
+      <table class="w-full text-left text-sm">
+        <thead class="border-b border-gray-200 dark:border-dark-700">
+          <tr class="text-xs uppercase tracking-wider text-gray-500 dark:text-gray-400">
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.model') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.latestStatus') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.latestLatency') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.availability7d') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.availability15d') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.availability30d') }}</th>
+            <th class="py-2 pr-3">{{ t('channelStatus.detailColumns.avgLatency7d') }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="m in detail.models"
+            :key="m.model"
+            class="border-b border-gray-100 dark:border-dark-800"
+          >
+            <td class="py-2 pr-3 font-medium text-gray-900 dark:text-gray-100">{{ m.model }}</td>
+            <td class="py-2 pr-3">
+              <span
+                class="inline-flex items-center rounded-full px-2 py-0.5 text-[11px]"
+                :class="statusBadgeClass(m.latest_status)"
+              >
+                {{ statusLabel(m.latest_status) }}
+              </span>
+            </td>
+            <td class="py-2 pr-3 text-gray-700 dark:text-gray-300">{{ formatLatency(m.latest_latency_ms) }}</td>
+            <td class="py-2 pr-3 text-gray-700 dark:text-gray-300">{{ formatPercent(m.availability_7d) }}</td>
+            <td class="py-2 pr-3 text-gray-700 dark:text-gray-300">{{ formatPercent(m.availability_15d) }}</td>
+            <td class="py-2 pr-3 text-gray-700 dark:text-gray-300">{{ formatPercent(m.availability_30d) }}</td>
+            <td class="py-2 pr-3 text-gray-700 dark:text-gray-300">{{ formatLatency(m.avg_latency_7d_ms) }}</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <template #footer>
+      <div class="flex justify-end">
+        <button @click="$emit('close')" class="btn btn-secondary">
+          {{ t('channelStatus.closeDetail') }}
+        </button>
+      </div>
+    </template>
+  </BaseDialog>
+</template>
+
+<script setup lang="ts">
+import { ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useAppStore } from '@/stores/app'
+import { extractApiErrorMessage } from '@/utils/apiError'
+import {
+  status as fetchChannelMonitorDetail,
+  type UserMonitorDetail,
+} from '@/api/channelMonitor'
+import BaseDialog from '@/components/common/BaseDialog.vue'
+import { useChannelMonitorFormat } from '@/composables/useChannelMonitorFormat'
+
+const props = defineProps<{
+  show: boolean
+  monitorId: number | null
+  title: string
+}>()
+
+defineEmits<{
+  (e: 'close'): void
+}>()
+
+const { t } = useI18n()
+const appStore = useAppStore()
+const { statusLabel, statusBadgeClass, formatLatency, formatPercent } = useChannelMonitorFormat()
+
+const detail = ref<UserMonitorDetail | null>(null)
+const loading = ref(false)
+
+async function load(id: number) {
+  detail.value = null
+  loading.value = true
+  try {
+    detail.value = await fetchChannelMonitorDetail(id)
+  } catch (err: unknown) {
+    appStore.showError(extractApiErrorMessage(err, t('channelStatus.detailLoadError')))
+  } finally {
+    loading.value = false
+  }
+}
+
+watch(
+  () => [props.show, props.monitorId] as const,
+  ([show, id]) => {
+    if (!show) {
+      detail.value = null
+      return
+    }
+    if (id != null) void load(id)
+  },
+  { immediate: true },
+)
+</script>

frontend/src/components/user/MonitorPrimaryModelCell.vue

+<template>
+  <div class="flex items-center gap-2">
+    <span class="text-sm text-gray-900 dark:text-gray-100">{{ row.primary_model }}</span>
+    <HelpTooltip>
+      <template #trigger>
+        <span
+          class="inline-flex items-center rounded-full px-2 py-0.5 text-[11px] font-medium"
+          :class="statusBadgeClass(row.primary_status)"
+        >
+          {{ statusLabel(row.primary_status) }}
+        </span>
+      </template>
+      <div class="space-y-2">
+        <div class="text-xs font-semibold text-gray-100">
+          {{ row.primary_model }}
+          <span
+            class="ml-1 inline-flex items-center rounded-full px-1.5 py-0.5 text-[10px] font-medium"
+            :class="statusBadgeClass(row.primary_status)"
+          >
+            {{ statusLabel(row.primary_status) }}
+          </span>
+        </div>
+        <div v-if="(row.extra_models?.length ?? 0) === 0" class="text-[11px] text-gray-300">
+          {{ t('monitorCommon.extraModelsEmpty') }}
+        </div>
+        <div v-else class="space-y-1">
+          <div class="text-[11px] font-semibold uppercase tracking-wide text-gray-400">
+            {{ t('monitorCommon.extraModelsHeader') }}
+          </div>
+          <table class="w-full text-left text-[11px]">
+            <thead>
+              <tr class="text-gray-400">
+                <th class="py-0.5 pr-2 font-medium">{{ t('channelStatus.detailColumns.model') }}</th>
+                <th class="py-0.5 pr-2 font-medium">{{ t('channelStatus.detailColumns.latestStatus') }}</th>
+                <th class="py-0.5 font-medium">{{ t('channelStatus.detailColumns.latestLatency') }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="m in row.extra_models" :key="m.model">
+                <td class="py-0.5 pr-2 text-gray-100">{{ m.model }}</td>
+                <td class="py-0.5 pr-2">
+                  <span
+                    class="inline-flex items-center rounded-full px-1.5 py-0.5 text-[10px]"
+                    :class="statusBadgeClass(m.status)"
+                  >
+                    {{ statusLabel(m.status) }}
+                  </span>
+                </td>
+                <td class="py-0.5 text-gray-100">{{ formatLatency(m.latency_ms) }}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </HelpTooltip>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { UserMonitorView } from '@/api/channelMonitor'
+import HelpTooltip from '@/components/common/HelpTooltip.vue'
+import { useChannelMonitorFormat } from '@/composables/useChannelMonitorFormat'
+
+defineProps<{
+  row: UserMonitorView
+}>()
+
+const { t } = useI18n()
+const { statusLabel, statusBadgeClass, formatLatency } = useChannelMonitorFormat()
+</script>