feat(scheduler): prefer accounts nearing 7d reset

Prioritize paid accounts whose 7d quota reset is within the urgency window while preserving remaining-quota safeguards.

Fixes #122

Author: james-6-23

admin/handler.go

@@ -450,6 +450,7 @@ type schedulerBreakdownResponse struct {
 	SuccessBonus        float64 `json:"success_bonus"`
 	UsagePenalty7d      float64 `json:"usage_penalty_7d"`
 	UsageUrgencyBonus5h float64 `json:"usage_urgency_bonus_5h"`
+	UsageUrgencyBonus7d float64 `json:"usage_urgency_bonus_7d"`
 	LatencyPenalty      float64 `json:"latency_penalty"`
 	SuccessRatePenalty  float64 `json:"success_rate_penalty"`
 }
@@ -538,6 +539,7 @@ func (h *Handler) ListAccounts(c *gin.Context) {
 				SuccessBonus:        debug.Breakdown.SuccessBonus,
 				UsagePenalty7d:      debug.Breakdown.UsagePenalty7d,
 				UsageUrgencyBonus5h: debug.Breakdown.UsageUrgencyBonus5h,
+				UsageUrgencyBonus7d: debug.Breakdown.UsageUrgencyBonus7d,
 				LatencyPenalty:      debug.Breakdown.LatencyPenalty,
 				SuccessRatePenalty:  debug.Breakdown.SuccessRatePenalty,
 			}

admin/responses_test.go

@@ -436,6 +436,7 @@ func TestSchedulerBreakdownResponse(t *testing.T) {
 		SuccessBonus:        4.0,
 		UsagePenalty7d:      8.0,
 		UsageUrgencyBonus5h: 6.0,
+		UsageUrgencyBonus7d: 7.0,
 		LatencyPenalty:      2.5,
 		SuccessRatePenalty:  1.5,
 	}
@@ -449,6 +450,9 @@ func TestSchedulerBreakdownResponse(t *testing.T) {
 	if resp.UsageUrgencyBonus5h != 6.0 {
 		t.Errorf("UsageUrgencyBonus5h = %v, want 6.0", resp.UsageUrgencyBonus5h)
 	}
+	if resp.UsageUrgencyBonus7d != 7.0 {
+		t.Errorf("UsageUrgencyBonus7d = %v, want 7.0", resp.UsageUrgencyBonus7d)
+	}
 }
 
 // ==================== Usage Logs Response Tests ====================

auth/fast_scheduler.go

@@ -30,17 +30,14 @@ type fastSchedulerPosition struct {
 // 它不在请求热路径内重算全量 score，而是直接复用 Account 上已缓存的
 // HealthTier / DispatchScore / DynamicConcurrencyLimit。
 //
-// 调度策略：两阶段扫描
-// 1. 优先在验证过的账号（TotalRequests > 10，排在桶前部）中 round-robin
-// 2. 验证账号全忙时，回退到全量 round-robin
+// 调度策略：按健康层级分桶，桶内按调度分排序后 round-robin。
+// 验证过的账号只作为同分 tie-breaker，避免历史请求量盖过额度快重置优先级。
 type FastScheduler struct {
-	mu           sync.RWMutex
-	baseLimit    int64
-	buckets      map[AccountHealthTier][]fastSchedulerEntry
-	positions    map[int64]fastSchedulerPosition
-	cursors      [3]atomic.Uint64
-	provenBounds [3]int           // 每个 tier 桶中验证过的账号数量（排在前面）
-	provenCurs   [3]atomic.Uint64 // 验证账号专用 round-robin 游标
+	mu        sync.RWMutex
+	baseLimit int64
+	buckets   map[AccountHealthTier][]fastSchedulerEntry
+	positions map[int64]fastSchedulerPosition
+	cursors   [3]atomic.Uint64
 }
 
 func NewFastScheduler(baseLimit int64) *FastScheduler {
@@ -112,24 +109,22 @@ func (s *FastScheduler) Rebuild(accounts []*Account) {
 	}
 
 	// 每个桶只排序一次 + 重建位置索引 + 计算验证账号边界
-	for tierIdx, tier := range fastSchedulerTierOrder {
+	for _, tier := range fastSchedulerTierOrder {
 		entries := s.buckets[tier]
 		if len(entries) == 0 {
-			s.provenBounds[tierIdx] = 0
 			continue
 		}
 		sort.SliceStable(entries, func(i, j int) bool {
-			if entries[i].proven != entries[j].proven {
-				return entries[i].proven
-			}
 			if entries[i].dispatchScore == entries[j].dispatchScore {
+				if entries[i].proven != entries[j].proven {
+					return entries[i].proven
+				}
 				return entries[i].dbID < entries[j].dbID
 			}
 			return entries[i].dispatchScore > entries[j].dispatchScore
 		})
 		s.buckets[tier] = entries
 		s.rebuildPositionsLocked(tier)
-		s.provenBounds[tierIdx] = countProvenEntries(entries)
 	}
 }
 
@@ -172,7 +167,6 @@ func (s *FastScheduler) Acquire() *Account {
 }
 
 // AcquireExcluding 获取下一个可用账号，排除指定的账号 ID 集合
-// 两阶段调度：优先在验证过的账号中选取，全忙时回退到全量扫描
 func (s *FastScheduler) AcquireExcluding(apiKeyID int64, exclude map[int64]bool) *Account {
 	return s.AcquireExcludingWithFilter(apiKeyID, exclude, nil)
 }
@@ -197,20 +191,6 @@ func (s *FastScheduler) AcquireExcludingWithFilter(apiKeyID int64, exclude map[i
 				continue
 			}
 
-			// 阶段 1：优先在验证过的账号（桶前部 provenBound 个）中 round-robin
-			provenBound := s.provenBounds[tierIdx]
-			if provenBound > 0 {
-				acc, stale := s.scanRangeLocked(tier, 0, provenBound, &s.provenCurs[tierIdx], baseLimit, now, apiKeyID, exclude, filter)
-				if acc != nil {
-					return acc
-				}
-				if stale {
-					changed = true
-					break
-				}
-			}
-
-			// 阶段 2：回退到全量 round-robin
 			acc, stale := s.scanRangeLocked(tier, 0, len(bucket), &s.cursors[tierIdx], baseLimit, now, apiKeyID, exclude, filter)
 			if acc != nil {
 				return acc
@@ -309,23 +289,16 @@ func (s *FastScheduler) insertLocked(acc *Account, now time.Time) {
 		proven:        proven,
 	})
 	sort.SliceStable(entries, func(i, j int) bool {
-		if entries[i].proven != entries[j].proven {
-			return entries[i].proven
-		}
 		if entries[i].dispatchScore == entries[j].dispatchScore {
+			if entries[i].proven != entries[j].proven {
+				return entries[i].proven
+			}
 			return entries[i].dbID < entries[j].dbID
 		}
 		return entries[i].dispatchScore > entries[j].dispatchScore
 	})
 	s.buckets[tier] = entries
 	s.rebuildPositionsLocked(tier)
-	// 更新该 tier 的验证账号边界
-	for tierIdx, t := range fastSchedulerTierOrder {
-		if t == tier {
-			s.provenBounds[tierIdx] = countProvenEntries(entries)
-			break
-		}
-	}
 }
 
 func (s *FastScheduler) removeLocked(dbID int64) {
@@ -345,23 +318,6 @@ func (s *FastScheduler) removeLocked(dbID int64) {
 	s.buckets[pos.tier] = entries
 	delete(s.positions, dbID)
 	s.rebuildPositionsLocked(pos.tier)
-	// 更新该 tier 的验证账号边界
-	for tierIdx, t := range fastSchedulerTierOrder {
-		if t == pos.tier {
-			s.provenBounds[tierIdx] = countProvenEntries(entries)
-			break
-		}
-	}
-}
-
-// countProvenEntries 统计桶中验证过的账号数量（TotalRequests > 10，排在前面）
-func countProvenEntries(entries []fastSchedulerEntry) int {
-	for i, e := range entries {
-		if !e.proven {
-			return i
-		}
-	}
-	return len(entries) // 全部都是验证过的
 }
 
 func (s *FastScheduler) rebuildPositionsLocked(tier AccountHealthTier) {
@@ -377,7 +333,8 @@ func (a *Account) fastSchedulerSnapshot(baseLimit int64, now time.Time) (Account
 	a.mu.Lock()
 	defer a.mu.Unlock()
 
-	if isPremium5hPlan(a.PlanType) && a.UsagePercent5hValid {
+	if (isPremium5hPlan(a.PlanType) && a.UsagePercent5hValid) ||
+		(IsPlusOrHigherPlan(a.PlanType) && a.UsagePercent7dValid) {
 		a.recomputeSchedulerLocked(baseLimit)
 	}
 

auth/fast_scheduler_test.go

@@ -362,15 +362,36 @@ func TestBuildFastSchedulerFromStore(t *testing.T) {
 	}
 }
 
-func TestFastSchedulerProvenPhaseUsesTotalRequestsOnly(t *testing.T) {
-	premium := newFastSchedulerTestAccount(1, HealthTierHealthy, 150, 1)
-	atomic.StoreInt64(&premium.TotalRequests, 0)
+func TestFastSchedulerDispatchScoreOutranksProvenHistory(t *testing.T) {
+	highScore := newFastSchedulerTestAccount(1, HealthTierHealthy, 150, 1)
+	atomic.StoreInt64(&highScore.TotalRequests, 0)
 
 	proven := newFastSchedulerTestAccount(2, HealthTierHealthy, 100, 1)
 	atomic.StoreInt64(&proven.TotalRequests, 11)
 
 	scheduler := NewFastScheduler(1)
-	scheduler.Rebuild([]*Account{premium, proven})
+	scheduler.Rebuild([]*Account{highScore, proven})
+
+	got := scheduler.Acquire()
+	if got == nil {
+		t.Fatal("Acquire() returned nil")
+	}
+	defer scheduler.Release(got)
+
+	if got.DBID != highScore.DBID {
+		t.Fatalf("Acquire() picked dbID=%d, want high-score account %d", got.DBID, highScore.DBID)
+	}
+}
+
+func TestFastSchedulerProvenHistoryBreaksDispatchScoreTies(t *testing.T) {
+	unproven := newFastSchedulerTestAccount(1, HealthTierHealthy, 100, 1)
+	atomic.StoreInt64(&unproven.TotalRequests, 0)
+
+	proven := newFastSchedulerTestAccount(2, HealthTierHealthy, 100, 1)
+	atomic.StoreInt64(&proven.TotalRequests, 11)
+
+	scheduler := NewFastScheduler(1)
+	scheduler.Rebuild([]*Account{unproven, proven})
 
 	got := scheduler.Acquire()
 	if got == nil {
@@ -379,7 +400,36 @@ func TestFastSchedulerProvenPhaseUsesTotalRequestsOnly(t *testing.T) {
 	defer scheduler.Release(got)
 
 	if got.DBID != proven.DBID {
-		t.Fatalf("Acquire() picked dbID=%d, want proven account %d", got.DBID, proven.DBID)
+		t.Fatalf("Acquire() picked dbID=%d, want proven tie-breaker account %d", got.DBID, proven.DBID)
+	}
+}
+
+func TestFastSchedulerPrefersPremium7dResetSoonOverProvenAccount(t *testing.T) {
+	now := time.Now()
+	later := newFastSchedulerTestAccount(1, HealthTierHealthy, 150, 1)
+	later.PlanType = "plus"
+	later.UsagePercent7d = 68
+	later.UsagePercent7dValid = true
+	later.Reset7dAt = now.Add(5 * 24 * time.Hour)
+	atomic.StoreInt64(&later.TotalRequests, 450)
+
+	soon := newFastSchedulerTestAccount(2, HealthTierHealthy, 150, 1)
+	soon.PlanType = "plus"
+	soon.UsagePercent7d = 63
+	soon.UsagePercent7dValid = true
+	soon.Reset7dAt = now.Add(36 * time.Hour)
+
+	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 7d reset-soon account %d", got.DBID, soon.DBID)
 	}
 }
 

auth/store.go

@@ -134,6 +134,10 @@ const (
 	premium5hUrgencyMaxBonus         = 25.0
 	premium5hUrgencyMinRemainingPct  = 5.0
 	premium5hUrgencyFullRemainingPct = 50.0
+	premium7dUrgencyWindow           = 72 * time.Hour
+	premium7dUrgencyMaxBonus         = 80.0
+	premium7dUrgencyMinRemainingPct  = 5.0
+	premium7dUrgencyFullRemainingPct = 70.0
 )
 
 // SchedulerBreakdown 调度评分拆解
@@ -147,6 +151,7 @@ type SchedulerBreakdown struct {
 	ProvenBonus         float64 // 经过验证的账号（TotalRequests > 10）加分
 	UsagePenalty7d      float64
 	UsageUrgencyBonus5h float64
+	UsageUrgencyBonus7d float64
 	LatencyPenalty      float64
 	SuccessRatePenalty  float64 // 滑动窗口成功率惩罚
 }
@@ -680,6 +685,49 @@ func (a *Account) premium5hUsageUrgencyBonusLocked(now time.Time) float64 {
 	return premium5hUrgencyMaxBonus * timeFactor * quotaFactor
 }
 
+func (a *Account) premium7dUsageUrgencyBonusLocked(now time.Time) float64 {
+	if !IsPlusOrHigherPlan(a.PlanType) {
+		return 0
+	}
+	if !a.UsagePercent7dValid || a.Reset7dAt.IsZero() {
+		return 0
+	}
+	if a.UsagePercent7d >= 100 {
+		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
+	}
+
+	timeRemaining := a.Reset7dAt.Sub(now)
+	if timeRemaining <= 0 || timeRemaining > premium7dUrgencyWindow {
+		return 0
+	}
+
+	quotaRemaining := 100 - a.UsagePercent7d
+	if quotaRemaining <= premium7dUrgencyMinRemainingPct {
+		return 0
+	}
+
+	timeFactor := 1 - float64(timeRemaining)/float64(premium7dUrgencyWindow)
+	quotaFactor := quotaRemaining / premium7dUrgencyFullRemainingPct
+	if quotaFactor > 1 {
+		quotaFactor = 1
+	}
+	if quotaFactor < 0 {
+		quotaFactor = 0
+	}
+	weightedQuotaFactor := 0.6 + 0.4*quotaFactor
+
+	return premium7dUrgencyMaxBonus * timeFactor * weightedQuotaFactor
+}
+
 func (a *Account) effectiveBaseConcurrencyLocked(storeBaseLimit int64) int64 {
 	if a.BaseConcurrencyOverride != nil && *a.BaseConcurrencyOverride > 0 {
 		return *a.BaseConcurrencyOverride
@@ -770,8 +818,9 @@ func (a *Account) recomputeSchedulerLocked(baseLimit int64) {
 	scoreBiasEffective := a.effectiveScoreBiasLocked(now, tier)
 	if a.dispatchBonusEligibleLocked(now, tier) {
 		breakdown.UsageUrgencyBonus5h = a.premium5hUsageUrgencyBonusLocked(now)
+		breakdown.UsageUrgencyBonus7d = a.premium7dUsageUrgencyBonusLocked(now)
 	}
-	dispatchScore := score + float64(scoreBiasEffective) + breakdown.UsageUrgencyBonus5h
+	dispatchScore := score + float64(scoreBiasEffective) + breakdown.UsageUrgencyBonus5h + breakdown.UsageUrgencyBonus7d
 
 	a.HealthTier = tier
 	a.SchedulerScore = score
@@ -1274,6 +1323,7 @@ func (a *Account) GetSchedulerDebugSnapshot(baseLimit int64) SchedulerDebugSnaps
 	breakdown := a.schedulerBreakdownLocked(now)
 	if a.dispatchBonusEligibleLocked(now, a.HealthTier) {
 		breakdown.UsageUrgencyBonus5h = a.premium5hUsageUrgencyBonusLocked(now)
+		breakdown.UsageUrgencyBonus7d = a.premium7dUsageUrgencyBonusLocked(now)
 	}
 	return SchedulerDebugSnapshot{
 		HealthTier:               string(a.HealthTier),