feat(P1/P2): 完成TDD开发及P1/P2设计文档

## 设计文档
- multi_role_permission_design: 多角色权限设计 (CONDITIONAL GO)
- audit_log_enhancement_design: 审计日志增强 (CONDITIONAL GO)
- routing_strategy_template_design: 路由策略模板 (CONDITIONAL GO)
- sso_saml_technical_research: SSO/SAML调研 (CONDITIONAL GO)
- compliance_capability_package_design: 合规能力包设计 (CONDITIONAL GO)

## TDD开发成果
- IAM模块: supply-api/internal/iam/ (111个测试)
- 审计日志模块: supply-api/internal/audit/ (40+测试)
- 路由策略模块: gateway/internal/router/ (33+测试)
- 合规能力包: gateway/internal/compliance/ + scripts/ci/compliance/

## 规范文档
- parallel_agent_output_quality_standards: 并行Agent产出质量规范
- project_experience_summary: 项目经验总结 (v2)
- 2026-04-02-p1-p2-tdd-execution-plan: TDD执行计划

## 评审报告
- 5个CONDITIONAL GO设计文档评审报告
- fix_verification_report: 修复验证报告
- full_verification_report: 全面质量验证报告
- tdd_module_quality_verification: TDD模块质量验证
- tdd_execution_summary: TDD执行总结

依据: Superpowers执行框架 + TDD规范

gateway/internal/router/strategy/cost_aware.go

@@ -0,0 +1,189 @@
+package strategy
+
+import (
+	"context"
+	"errors"
+
+	"lijiaoqiao/gateway/internal/adapter"
+	"lijiaoqiao/gateway/internal/router/scoring"
+	gwerror "lijiaoqiao/gateway/pkg/error"
+)
+
+// ErrNoQualifiedProvider 没有符合条件的Provider
+var ErrNoQualifiedProvider = errors.New("no qualified provider available")
+
+// CostAwareTemplate 成本感知策略模板
+// 综合考虑成本、质量、延迟进行权衡
+type CostAwareTemplate struct {
+	name               string
+	maxCostPer1KTokens float64
+	maxLatencyMs      int64
+	minQualityScore    float64
+	providers          map[string]adapter.ProviderAdapter
+	scoringModel       *scoring.ScoringModel
+}
+
+// CostAwareParams 成本感知参数
+type CostAwareParams struct {
+	MaxCostPer1KTokens float64
+	MaxLatencyMs      int64
+	MinQualityScore    float64
+}
+
+// NewCostAwareTemplate 创建成本感知策略模板
+func NewCostAwareTemplate(name string, params CostAwareParams) *CostAwareTemplate {
+	return &CostAwareTemplate{
+		name:               name,
+		maxCostPer1KTokens: params.MaxCostPer1KTokens,
+		maxLatencyMs:      params.MaxLatencyMs,
+		minQualityScore:    params.MinQualityScore,
+		providers:          make(map[string]adapter.ProviderAdapter),
+		scoringModel:       scoring.NewScoringModel(scoring.DefaultWeights),
+	}
+}
+
+// RegisterProvider 注册Provider
+func (t *CostAwareTemplate) RegisterProvider(name string, provider adapter.ProviderAdapter) {
+	t.providers[name] = provider
+}
+
+// Name 获取策略名称
+func (t *CostAwareTemplate) Name() string {
+	return t.name
+}
+
+// Type 获取策略类型
+func (t *CostAwareTemplate) Type() string {
+	return "cost_aware"
+}
+
+// SelectProvider 选择最佳平衡的Provider
+func (t *CostAwareTemplate) SelectProvider(ctx context.Context, req *RoutingRequest) (*RoutingDecision, error) {
+	if len(t.providers) == 0 {
+		return nil, gwerror.NewGatewayError(gwerror.ROUTER_NO_PROVIDER_AVAILABLE, "no provider registered")
+	}
+
+	type candidate struct {
+		name           string
+		cost           float64
+		quality        float64
+		latency        int64
+		score          float64
+	}
+
+	var candidates []candidate
+	maxCost := t.maxCostPer1KTokens
+	if req.MaxCost > 0 && req.MaxCost < maxCost {
+		maxCost = req.MaxCost
+	}
+	maxLatency := t.maxLatencyMs
+	if req.MaxLatency > 0 && req.MaxLatency < maxLatency {
+		maxLatency = req.MaxLatency
+	}
+	minQuality := t.minQualityScore
+	if req.MinQuality > 0 && req.MinQuality > minQuality {
+		minQuality = req.MinQuality
+	}
+
+	for name, provider := range t.providers {
+		// 检查provider是否支持该模型
+		supported := false
+		for _, m := range provider.SupportedModels() {
+			if m == req.Model || m == "*" {
+				supported = true
+				break
+			}
+		}
+		if !supported {
+			continue
+		}
+
+		// 检查健康状态
+		if !provider.HealthCheck(ctx) {
+			continue
+		}
+
+		// 获取provider指标
+		cost := t.getProviderCost(provider)
+		quality := t.getProviderQuality(provider)
+		latency := t.getProviderLatency(provider)
+
+		// 过滤不满足基本条件的provider
+		if cost > maxCost || latency > maxLatency || quality < minQuality {
+			continue
+		}
+
+		// 计算综合评分
+		metrics := scoring.ProviderMetrics{
+			Name:            name,
+			LatencyMs:       latency,
+			Availability:    1.0, // 假设可用
+			CostPer1KTokens: cost,
+			QualityScore:    quality,
+		}
+		score := t.scoringModel.CalculateScore(metrics)
+
+		candidates = append(candidates, candidate{
+			name:   name,
+			cost:   cost,
+			quality: quality,
+			latency: latency,
+			score:  score,
+		})
+	}
+
+	if len(candidates) == 0 {
+		return nil, ErrNoQualifiedProvider
+	}
+
+	// 选择评分最高的provider
+	best := &candidates[0]
+	for i := 1; i < len(candidates); i++ {
+		if candidates[i].score > best.score {
+			best = &candidates[i]
+		}
+	}
+
+	return &RoutingDecision{
+		Provider:         best.name,
+		Strategy:         t.Type(),
+		CostPer1KTokens:  best.cost,
+		EstimatedLatency: best.latency,
+		QualityScore:     best.quality,
+		TakeoverMark:     true, // M-008: 标记为接管
+	}, nil
+}
+
+// getProviderCost 获取Provider的成本
+func (t *CostAwareTemplate) getProviderCost(provider adapter.ProviderAdapter) float64 {
+	if cp, ok := provider.(CostAwareProvider); ok {
+		return cp.GetCostPer1KTokens()
+	}
+	return 0.5
+}
+
+// getProviderQuality 获取Provider的质量分数
+func (t *CostAwareTemplate) getProviderQuality(provider adapter.ProviderAdapter) float64 {
+	if qp, ok := provider.(QualityProvider); ok {
+		return qp.GetQualityScore()
+	}
+	return 0.8 // 默认质量分数
+}
+
+// getProviderLatency 获取Provider的延迟
+func (t *CostAwareTemplate) getProviderLatency(provider adapter.ProviderAdapter) int64 {
+	if lp, ok := provider.(LatencyProvider); ok {
+		return lp.GetLatencyMs()
+	}
+	return 100 // 默认延迟100ms
+}
+
+// QualityProvider 质量感知Provider接口
+type QualityProvider interface {
+	GetQualityScore() float64
+}
+
+// LatencyProvider 延迟感知Provider接口
+type LatencyProvider interface {
+	GetLatencyMs() int64
+}