feat: prioritize premium 5h recovery windows

Author: james-6-23

admin/handler.go

@@ -357,6 +357,7 @@ type schedulerBreakdownResponse struct {
 	FailurePenalty      float64 `json:"failure_penalty"`
 	SuccessBonus        float64 `json:"success_bonus"`
 	UsagePenalty7d      float64 `json:"usage_penalty_7d"`
+	UsageUrgencyBonus5h float64 `json:"usage_urgency_bonus_5h"`
 	LatencyPenalty      float64 `json:"latency_penalty"`
 	SuccessRatePenalty  float64 `json:"success_rate_penalty"`
 }
@@ -430,6 +431,7 @@ func (h *Handler) ListAccounts(c *gin.Context) {
 				FailurePenalty:      debug.Breakdown.FailurePenalty,
 				SuccessBonus:        debug.Breakdown.SuccessBonus,
 				UsagePenalty7d:      debug.Breakdown.UsagePenalty7d,
+				UsageUrgencyBonus5h: debug.Breakdown.UsageUrgencyBonus5h,
 				LatencyPenalty:      debug.Breakdown.LatencyPenalty,
 				SuccessRatePenalty:  debug.Breakdown.SuccessRatePenalty,
 			}

admin/responses_test.go

@@ -384,31 +384,31 @@ func TestAccountsResponse(t *testing.T) {
 
 func TestAccountResponseFields(t *testing.T) {
 	resp := accountResponse{
-		ID:                      1,
-		Name:                    "Test Account",
-		Email:                   "test@example.com",
-		PlanType:                "plus",
-		Status:                  "active",
-		HealthTier:              "healthy",
-		SchedulerScore:          95.5,
-		ConcurrencyCap:          4,
-		ProxyURL:                "http://proxy:8080",
-		CreatedAt:               time.Now().Format(time.RFC3339),
-		UpdatedAt:               time.Now().Format(time.RFC3339),
-		ActiveRequests:          2,
-		TotalRequests:           100,
-		LastUsedAt:              time.Now().Format(time.RFC3339),
-		SuccessRequests:         95,
-		ErrorRequests:           5,
-		UsagePercent7d:          floatPtr(75.5),
-		UsagePercent5h:          floatPtr(50.0),
-		Reset5hAt:               time.Now().Format(time.RFC3339),
-		Reset7dAt:               time.Now().Add(7 * 24 * time.Hour).Format(time.RFC3339),
-		ScoreBreakdown:          schedulerBreakdownResponse{},
-		LastUnauthorizedAt:      time.Now().Format(time.RFC3339),
-		LastRateLimitedAt:       time.Now().Format(time.RFC3339),
-		LastTimeoutAt:           time.Now().Format(time.RFC3339),
-		LastServerErrorAt:       time.Now().Format(time.RFC3339),
+		ID:                 1,
+		Name:               "Test Account",
+		Email:              "test@example.com",
+		PlanType:           "plus",
+		Status:             "active",
+		HealthTier:         "healthy",
+		SchedulerScore:     95.5,
+		ConcurrencyCap:     4,
+		ProxyURL:           "http://proxy:8080",
+		CreatedAt:          time.Now().Format(time.RFC3339),
+		UpdatedAt:          time.Now().Format(time.RFC3339),
+		ActiveRequests:     2,
+		TotalRequests:      100,
+		LastUsedAt:         time.Now().Format(time.RFC3339),
+		SuccessRequests:    95,
+		ErrorRequests:      5,
+		UsagePercent7d:     floatPtr(75.5),
+		UsagePercent5h:     floatPtr(50.0),
+		Reset5hAt:          time.Now().Format(time.RFC3339),
+		Reset7dAt:          time.Now().Add(7 * 24 * time.Hour).Format(time.RFC3339),
+		ScoreBreakdown:     schedulerBreakdownResponse{},
+		LastUnauthorizedAt: time.Now().Format(time.RFC3339),
+		LastRateLimitedAt:  time.Now().Format(time.RFC3339),
+		LastTimeoutAt:      time.Now().Format(time.RFC3339),
+		LastServerErrorAt:  time.Now().Format(time.RFC3339),
 	}
 
 	if resp.Name != "Test Account" {
@@ -435,6 +435,7 @@ func TestSchedulerBreakdownResponse(t *testing.T) {
 		FailurePenalty:      1.0,
 		SuccessBonus:        4.0,
 		UsagePenalty7d:      8.0,
+		UsageUrgencyBonus5h: 6.0,
 		LatencyPenalty:      2.5,
 		SuccessRatePenalty:  1.5,
 	}
@@ -445,6 +446,9 @@ func TestSchedulerBreakdownResponse(t *testing.T) {
 	if resp.SuccessBonus != 4.0 {
 		t.Errorf("SuccessBonus = %v, want 4.0", resp.SuccessBonus)
 	}
+	if resp.UsageUrgencyBonus5h != 6.0 {
+		t.Errorf("UsageUrgencyBonus5h = %v, want 6.0", resp.UsageUrgencyBonus5h)
+	}
 }
 
 // ==================== Usage Logs Response Tests ====================

auth/fast_scheduler.go

@@ -1,6 +1,7 @@
 package auth
 
 import (
+	"math"
 	"sort"
 	"sync"
 	"sync/atomic"
@@ -248,8 +249,8 @@ func (s *FastScheduler) scanRangeLocked(expectedTier AccountHealthTier, rangeSta
 		if filter != nil && !filter(entry.acc) {
 			continue
 		}
-		tier, _, limit, _, available := entry.acc.fastSchedulerSnapshot(baseLimit, now)
-		if tier != expectedTier {
+		tier, dispatchScore, limit, proven, available := entry.acc.fastSchedulerSnapshot(baseLimit, now)
+		if tier != expectedTier || proven != entry.proven || math.Abs(dispatchScore-entry.dispatchScore) >= 1 {
 			s.removeLocked(entry.dbID)
 			if available && limit > 0 {
 				s.insertLocked(entry.acc, now)

auth/fast_scheduler_test.go

@@ -383,6 +383,68 @@ func TestFastSchedulerProvenPhaseUsesTotalRequestsOnly(t *testing.T) {
 	}
 }
 
+func TestFastSchedulerPrefersPremium5hResetSoonWithinTier(t *testing.T) {
+	now := time.Now()
+	later := newFastSchedulerTestAccount(1, HealthTierHealthy, 150, 1)
+	later.PlanType = "plus"
+	later.UsagePercent5h = 25
+	later.UsagePercent5hValid = true
+	later.Reset5hAt = now.Add(5 * time.Hour)
+
+	soon := newFastSchedulerTestAccount(2, HealthTierHealthy, 150, 1)
+	soon.PlanType = "plus"
+	soon.UsagePercent5h = 25
+	soon.UsagePercent5hValid = true
+	soon.Reset5hAt = now.Add(30 * time.Minute)
+
+	scheduler := NewFastScheduler(1)
+	scheduler.Rebuild([]*Account{later, soon})
+
+	got := scheduler.Acquire()
+	if got == nil {
+		t.Fatal("Acquire() returned nil")
+	}
+	defer scheduler.Release(got)
+
+	if got.DBID != soon.DBID {
+		t.Fatalf("Acquire() picked dbID=%d, want reset-soon account %d", got.DBID, soon.DBID)
+	}
+}
+
+func TestPersistUsageSnapshot5hOnlyUpdatesFastSchedulerPriority(t *testing.T) {
+	now := time.Now()
+	later := newFastSchedulerTestAccount(1, HealthTierHealthy, 150, 1)
+	later.PlanType = "plus"
+	later.UsagePercent5h = 25
+	later.UsagePercent5hValid = true
+	later.Reset5hAt = now.Add(5 * time.Hour)
+
+	soon := newFastSchedulerTestAccount(2, HealthTierHealthy, 150, 1)
+	soon.PlanType = "plus"
+	soon.UsagePercent5h = 25
+	soon.UsagePercent5hValid = true
+	soon.Reset5hAt = now.Add(5 * time.Hour)
+
+	store := &Store{
+		accounts:       []*Account{later, soon},
+		maxConcurrency: 1,
+	}
+	store.SetFastSchedulerEnabled(true)
+
+	soon.SetUsageSnapshot5h(25, time.Now().Add(30*time.Minute))
+	store.PersistUsageSnapshot5hOnly(soon)
+
+	got := store.Next()
+	if got == nil {
+		t.Fatal("Next() returned nil")
+	}
+	defer store.Release(got)
+
+	if got.DBID != soon.DBID {
+		t.Fatalf("Next() picked dbID=%d, want reset-soon account %d", got.DBID, soon.DBID)
+	}
+}
+
 func TestStoreFastSchedulerToggle(t *testing.T) {
 	cooling := newFastSchedulerTestAccount(1, HealthTierWarm, 80, 1)
 	cooling.Status = StatusCooldown

auth/premium_rate_limit.go

@@ -98,7 +98,7 @@ func (a *Account) GetUsageSnapshot5h() (pct float64, resetAt time.Time, ok bool)
 
 // PersistUsageSnapshot5hOnly 持久化仅包含 5h 数据的用量快照。
 func (s *Store) PersistUsageSnapshot5hOnly(acc *Account) {
-	if acc == nil || s == nil || s.db == nil {
+	if acc == nil || s == nil {
 		return
 	}
 
@@ -112,6 +112,12 @@ func (s *Store) PersistUsageSnapshot5hOnly(acc *Account) {
 	acc.UsageUpdatedAt = updatedAt
 	acc.mu.Unlock()
 
+	s.fastSchedulerUpdate(acc)
+
+	if s.db == nil {
+		return
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
 	if err := s.db.UpdateUsageSnapshot5h(ctx, acc.DBID, pct5h, reset5hAt, updatedAt); err != nil {

auth/store.go

@@ -122,6 +122,10 @@ const (
 	defaultBackgroundRefreshInterval = 2 * time.Minute
 	defaultUsageProbeMaxAge          = 10 * time.Minute
 	defaultRecoveryProbeInterval     = 30 * time.Minute
+	premium5hUrgencyWindow           = 4 * time.Hour
+	premium5hUrgencyMaxBonus         = 25.0
+	premium5hUrgencyMinRemainingPct  = 5.0
+	premium5hUrgencyFullRemainingPct = 50.0
 )
 
 // SchedulerBreakdown 调度评分拆解
@@ -134,6 +138,7 @@ type SchedulerBreakdown struct {
 	SuccessBonus        float64
 	ProvenBonus         float64 // 经过验证的账号（TotalRequests > 10）加分
 	UsagePenalty7d      float64
+	UsageUrgencyBonus5h float64
 	LatencyPenalty      float64
 	SuccessRatePenalty  float64 // 滑动窗口成功率惩罚
 }
@@ -388,8 +393,7 @@ func linearDecay(base float64, elapsed, window time.Duration) float64 {
 	return base * (1.0 - float64(elapsed)/float64(window))
 }
 
-func (a *Account) schedulerBreakdownLocked() SchedulerBreakdown {
-	now := time.Now()
+func (a *Account) schedulerBreakdownLocked(now time.Time) SchedulerBreakdown {
 	breakdown := SchedulerBreakdown{}
 	premium5hLimited := a.premium5hRateLimitedLocked(now)
 
@@ -457,6 +461,51 @@ func (a *Account) schedulerBreakdownLocked() SchedulerBreakdown {
 	return breakdown
 }
 
+func (a *Account) premium5hUsageUrgencyBonusLocked(now time.Time) float64 {
+	if !isPremium5hPlan(a.PlanType) {
+		return 0
+	}
+	if !a.UsagePercent5hValid || a.Reset5hAt.IsZero() {
+		return 0
+	}
+	if a.UsagePercent5h >= 100 || a.premium5hRateLimitedLocked(now) {
+		return 0
+	}
+	if a.AccessToken == "" || a.Status == StatusError || a.HealthTier == HealthTierBanned {
+		return 0
+	}
+	if atomic.LoadInt32(&a.DispatchPaused) != 0 {
+		return 0
+	}
+	if a.Status == StatusCooldown && now.Before(a.CooldownUtil) {
+		return 0
+	}
+	if a.usageExhaustedLocked() {
+		return 0
+	}
+
+	timeRemaining := a.Reset5hAt.Sub(now)
+	if timeRemaining <= 0 || timeRemaining > premium5hUrgencyWindow {
+		return 0
+	}
+
+	quotaRemaining := 100 - a.UsagePercent5h
+	if quotaRemaining <= premium5hUrgencyMinRemainingPct {
+		return 0
+	}
+
+	timeFactor := 1 - float64(timeRemaining)/float64(premium5hUrgencyWindow)
+	quotaFactor := quotaRemaining / premium5hUrgencyFullRemainingPct
+	if quotaFactor > 1 {
+		quotaFactor = 1
+	}
+	if quotaFactor < 0 {
+		quotaFactor = 0
+	}
+
+	return premium5hUrgencyMaxBonus * timeFactor * quotaFactor
+}
+
 func (a *Account) effectiveBaseConcurrencyLocked(storeBaseLimit int64) int64 {
 	if a.BaseConcurrencyOverride != nil && *a.BaseConcurrencyOverride > 0 {
 		return *a.BaseConcurrencyOverride
@@ -501,7 +550,7 @@ func (a *Account) effectiveScoreBiasLocked(now time.Time, tier AccountHealthTier
 
 func (a *Account) recomputeSchedulerLocked(baseLimit int64) {
 	now := time.Now()
-	breakdown := a.schedulerBreakdownLocked()
+	breakdown := a.schedulerBreakdownLocked(now)
 	score := 100.0 -
 		breakdown.UnauthorizedPenalty -
 		breakdown.RateLimitPenalty -
@@ -545,7 +594,10 @@ func (a *Account) recomputeSchedulerLocked(baseLimit int64) {
 
 	baseConcurrencyEffective := a.effectiveBaseConcurrencyLocked(baseLimit)
 	scoreBiasEffective := a.effectiveScoreBiasLocked(now, tier)
-	dispatchScore := score + float64(scoreBiasEffective)
+	if a.dispatchBonusEligibleLocked(now, tier) {
+		breakdown.UsageUrgencyBonus5h = a.premium5hUsageUrgencyBonusLocked(now)
+	}
+	dispatchScore := score + float64(scoreBiasEffective) + breakdown.UsageUrgencyBonus5h
 
 	a.HealthTier = tier
 	a.SchedulerScore = score
@@ -1045,6 +1097,11 @@ func (a *Account) GetSchedulerDebugSnapshot(baseLimit int64) SchedulerDebugSnaps
 	defer a.mu.Unlock()
 
 	a.recomputeSchedulerLocked(baseLimit)
+	now := time.Now()
+	breakdown := a.schedulerBreakdownLocked(now)
+	if a.dispatchBonusEligibleLocked(now, a.HealthTier) {
+		breakdown.UsageUrgencyBonus5h = a.premium5hUsageUrgencyBonusLocked(now)
+	}
 	return SchedulerDebugSnapshot{
 		HealthTier:               string(a.HealthTier),
 		SchedulerScore:           a.SchedulerScore,
@@ -1054,7 +1111,7 @@ func (a *Account) GetSchedulerDebugSnapshot(baseLimit int64) SchedulerDebugSnaps
 		BaseConcurrencyOverride:  cloneInt64Ptr(a.BaseConcurrencyOverride),
 		BaseConcurrencyEffective: a.BaseConcurrencyEffective,
 		DynamicConcurrencyLimit:  a.DynamicConcurrencyLimit,
-		Breakdown:                a.schedulerBreakdownLocked(),
+		Breakdown:                breakdown,
 		LastUnauthorizedAt:       a.LastUnauthorizedAt,
 		LastRateLimitedAt:        a.LastRateLimitedAt,
 		LastTimeoutAt:            a.LastTimeoutAt,
@@ -2665,6 +2722,7 @@ func (s *Store) PersistUsageSnapshot(acc *Account, pct7d float64) {
 
 	now := time.Now()
 	acc.SetUsageSnapshot(pct7d, now)
+	s.fastSchedulerUpdate(acc)
 
 	if s.db == nil {
 		return