maxpool 1.19.8 → 1.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.19.8",
+  "version": "1.20.1",
   "description": "Multi-account Claude Code proxy with adaptive, rate-aware load balancing across Claude accounts",
   "type": "module",
   "main": "src/index.js",

package/src/account-manager.js

@@ -124,8 +124,12 @@ const DEFAULT_SCHEDULER = {
   // CONCURRENCY HEADROOM for the request (an at-cap route cannot serve without
   // deepening the congestion). Congestion-based, not presence-based: an idle provider
   // or reserve account keeps serving and no unlock fires — critical becomes relief
-  // exactly when the fleet is out of headroom, and never preempts an idle route
-  // (cost is also ABOVE reserve's attainable max ~19, pinning the ordering).
+  // exactly when the fleet is out of headroom, and never preempts an idle route.
+  // Ordering vs reserve: reserve's attainable max is floor(5) + band(≤8) + weekly
+  // scarcity(≤6) ≈ 19, PLUS utilization's weekly term (≤3, 2026-09-16) ⇒ up to ~22 —
+  // this 21 sits above a lightly-priced reserve but can sit BELOW a maxed one. The
+  // X3 pin holds for the idle-reserve case (0.90 ⇒ ~10-19); if that regresses, raise
+  // this to 24 (see critical-unlock.test.js X3).
   // -1 disables; 0 = unlock only when every route is at cap.
   criticalPressureUnlockRoutes: 0,
   criticalPressureCost: 21,
@@ -147,6 +151,13 @@ const DEFAULT_SCHEDULER = {
   capPenaltyWeight: 10,            // steep penalty per unit of in-flight depth past D (throttle safety floor)
   paceCostWeight: 1.5,            // soft de-preference of accounts burning ahead of pace (was the ×6 term)
   utilizationWeight: 3,           // RAW utilization cost — drives load balancing in the mid-range
+  // WEEKLY-AWARE SCORING (2026-09-16): when true, _rawUtilization also folds in the
+  // WEEKLY utilization (unified7d / providerWk), not just the 5h session. Before this,
+  // a Claude account at 89% weekly with a freshly-reset 5h window scored as CHEAP —
+  // weekly-burning accounts kept winning the lease all day (backtest: 62%→35% mean
+  // weekly burn once weekly-aware). Boolean; default ON was chosen because the
+  // pre-flag behavior is the bug this fixes.
+  weeklyAwareScoring: true,
   scarcityWeight: 6,              // legacy; superseded by paceCostWeight (kept so old configs don't error)
   // Reserve-account OVERFLOW model. A weekly-RESERVE account (util 0.85-0.95) used to
   // sit idle behind a healthy-only first pass; now it's eligible in the first pass but
@@ -2692,7 +2703,7 @@ export class AccountManager {
    *  _accountScarcity but WITHOUT the elapsed-fraction discount. This is the signal
    *  the load balancer needs: an account at 80% is more expensive than one at 10%,
    *  full stop. */
-  _rawUtilization(account) {
+  _rawUtilization(account, now = Date.now()) {
     const q = account?.quota;
     if (!q) return 0;
     // SESSION windows use raw utilization — headroom is consumed immediately and an
@@ -2708,6 +2719,24 @@ export class AccountManager {
     if (q.tokensLimit != null && q.tokensLimit > 0 && q.tokensRemaining != null) {
       util = Math.max(util, 1 - q.tokensRemaining / q.tokensLimit);
     }
+    // WEEKLY-AWARE (2026-09-16): fold the WEEKLY number in too, behind its own
+    // flag — via _windowScarcity (reset-aware), NEVER raw. v1 of this block used
+    // raw max(), which fixed the 89%-weekly-wins-all-day bug but broke the
+    // near-reset contracts that predate it: the use-it-or-lose-it pin, the
+    // preReset drain (X2/X5), and S10's flag-off parity. Pace-adjusted, a
+    // 60%-weekly account mid-window adds (0.60 − elapsedFrac) here at weight 3
+    // ON TOP of the paceCost's weight-1.5 copy — doubling the weekly steering
+    // signal (the actual fix) while capacity dying at reset stays free (the
+    // invariant the older tests pin). Unknown/absent reset → face value, same as
+    // _accountScarcity. Turn the flag off to restore session-only exactly.
+    if (this.scheduler.weeklyAwareScoring !== false) {
+      if (q.unified7d != null) {
+        util = Math.max(util, this._windowScarcity(q.unified7d, q.unified7dReset, WEEK_MS, now));
+      }
+      if (q.providerWk != null) {
+        util = Math.max(util, this._windowScarcity(q.providerWk, q.providerWkReset, WEEK_MS, now));
+      }
+    }
     return util;
   }
 

package/src/tui.js

@@ -977,6 +977,11 @@ export class TUI {
       // mode — under balance/prefer-* the mode itself controls eligibility. Still
       // safe to set (it'll apply if you switch back to sticky).
       this._cycleProviderClaudeFallback(k === 'g' ? 'zai' : 'kimi');
+    } else if (k === 'w' || k === 'W') {
+      // WEEKLY-AWARE SCORING (2026-09-16): fold weekly utilization into the routing
+      // score, not just the 5h session. Without it, an account at 89% weekly with a
+      // fresh session window scores as cheap and keeps winning all day.
+      this._toggleWeeklyAware();
     } else if (k === 'esc' || k === 'q') {
       this.mode = 'normal';
     }
@@ -1066,6 +1071,32 @@ export class TUI {
         : `Peak cap: bench a GLM account once it passes ${Math.round(next * 100)}% of its weekly quota`);
   }
 
+  /** Toggle weekly-aware routing for the whole fleet. One scheduler flag — when OFF the
+   *  score sees only the 5h session (the pre-2026-09-16 behavior); when ON the weekly
+   *  number is folded in, so a nearly-exhausted account loses to a fresh one at ALL
+   *  hours, not just after its session window resets. */
+  async _toggleWeeklyAware() {
+    const next = this.am.scheduler.weeklyAwareScoring === false;
+    this.am.scheduler.weeklyAwareScoring = next;
+    const sched = { ...(this.config.scheduler || {}) };
+    sched.weeklyAwareScoring = next;
+    this.config.scheduler = sched;
+    try {
+      await this.saveConfig(this.config);
+    } catch (e) {
+      // Roll back both the live flag and the mirror so an unsaved toggle can't
+      // silently revert on the next reload — same pattern as the sibling
+      // _cycleProviderClaudeFallback (tui.js).
+      this.am.scheduler.weeklyAwareScoring = !next;
+      this.config.scheduler = sched.weeklyAwareScoring === next ? { ...sched, weeklyAwareScoring: !next } : sched;
+      this._addLog(`Could not save: ${e.message}`);
+      return;
+    }
+    this._addLog(next
+      ? 'Weekly-aware routing: ON — accounts near their weekly limit rank last, all day'
+      : 'Weekly-aware routing: OFF — score sees only the 5h session window again');
+  }
+
   async _cycleRoutingMode() {
     const modes = TUI.ROUTING_MODES;
     const cur = this.am.scheduler?.routingMode || 'sticky';
@@ -2369,7 +2400,8 @@ export class TUI {
           const now = st?.inPeak ? red(' NOW') : '';
           const dep = ps.depreference ? yellow('GLM last') : cyan('normal');
           const cap = ps.cap >= 1 ? 'off' : ps.cap === 0 ? 'never' : `${Math.round(ps.cap * 100)}%`;
-          peakPart = `  ${dim('│')} ${bold(' d ')}Peak${now}: ${dep} ${bold(' c ')}cap ${cyan(cap)}`;
+          const wk = this.am.scheduler.weeklyAwareScoring === false ? yellow('5h-only') : cyan('weekly');
+          peakPart = `  ${dim('│')} ${bold(' d ')}Peak${now}: ${dep} ${bold(' c ')}cap ${cyan(cap)} ${bold(' w ')}score:${wk}`;
         }
         return ` ${bold('f')} Routing: ${cyan(mode.label)} ↻${provPart}${peakPart}  ${bold('p')} Preference  ${bold('Esc')} Back`;
       }