maxpool 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "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

@@ -1,6 +1,10 @@
 import { refreshAccessToken, isTokenExpiringSoon, modelFamily, tokenFingerprint } from './oauth.js';
 import { CapacityLedger } from './capacity-ledger.js';
 
+// Nominal window length per kind — mirrors capacity-ledger's WINDOW_MS (kept here as a
+// local table so account-manager does not import a private constant).
+const WINDOW_MS_BY_KIND = { ses: 5 * 3600_000, wk: 7 * 86400_000 };
+
 // A capacity window boundary must move by at least this much to count as a real
 // window ADVANCE rather than reset-stamp jitter (see noteCapacityWindowAdvance).
 const WINDOW_ADVANCE_EPSILON_MS = 60_000;
@@ -2701,9 +2705,12 @@ export class AccountManager {
     }
     this.noteCapacityWindowAdvance(account.name, 'ses', prevSesReset, usage.fiveHour?.resetAt);
     this.noteCapacityWindowAdvance(account.name, 'wk', prevWkReset, usage.sevenDay?.resetAt);
-    // Utilization readings feed the capacity ESTIMATE (tokens ÷ fullness). Noted even
-    // when null — a probe that carries no utilization is not evidence of anything.
-    this.capacity.noteUtilizationObserved();
+    // Utilization readings feed the capacity ESTIMATE. The probe path passes per-window
+    // marks so the DELTA method can difference consecutive readings.
+    this.capacity.noteUtilizationObserved(Date.now(), [
+      { name: account.name, window: 'ses', utilization: usage.fiveHour?.utilization },
+      { name: account.name, window: 'wk', utilization: usage.sevenDay?.utilization },
+    ]);
     // Only a SUCCESSFUL probe carrying the flag speaks to this. A header-driven update
     // can't see the limits[] array, and a FAILED read knows nothing about the account's
     // caps — either one claiming "uncapped" would mislabel a capped account as having no
@@ -2846,12 +2853,12 @@ export class AccountManager {
       q.weeklyAbsent = true;
     }
     q.lastProbeOkAt = Date.now();
-    // Stamp-advance close: a FRESHER reset stamp means the old window rolled over —
-    // the tokens accrued since the last close belong to the cycle that just ended.
-    // noteCapacityWindowAdvance already no-ops on a missing/unchanged/older stamp
-    // (same-window re-report, clock-skew backward re-report) — pass values through.
     this.noteCapacityWindowAdvance(account.name, 'ses', prevSesReset, usage.ses?.resetAt);
     this.noteCapacityWindowAdvance(account.name, 'wk', prevWkReset, usage.wk?.resetAt);
+    this.capacity.noteUtilizationObserved(Date.now(), [
+      { name: account.name, window: 'ses', utilization: usage.ses?.utilization },
+      { name: account.name, window: 'wk', utilization: usage.wk?.utilization },
+    ]);
   }
 
   /**
@@ -2878,6 +2885,17 @@ export class AccountManager {
     const account = this.accounts[accountIndex];
     if (!account) return;
 
+    // Utilization from RESPONSE HEADERS (every request) feeds the capacity estimate's
+    // delta marks too — header-driven moves arrive far more often than probe cycles.
+    const hdrU5 = parseFloat(headers['anthropic-ratelimit-unified-5h-utilization']);
+    const hdrU7 = parseFloat(headers['anthropic-ratelimit-unified-7d-utilization']);
+    if (!isNaN(hdrU5) || !isNaN(hdrU7)) {
+      this.capacity.noteUtilizationObserved(Date.now(), [
+        { name: account.name, window: 'ses', utilization: isNaN(hdrU5) ? undefined : clamp01(hdrU5) },
+        { name: account.name, window: 'wk', utilization: isNaN(hdrU7) ? undefined : clamp01(hdrU7) },
+      ]);
+    }
+
     // Unified rate limits (Claude Max)
     const u5h = parseFloat(headers['anthropic-ratelimit-unified-5h-utilization']);
     const u7d = parseFloat(headers['anthropic-ratelimit-unified-7d-utilization']);
@@ -3046,6 +3064,16 @@ export class AccountManager {
       const pairs = a.type === 'provider'
         ? [['ses', 'providerSesReset'], ['wk', 'providerWkReset']]
         : [['ses', 'unified5hReset'], ['wk', 'unified7dReset']];
+      // Keep the open cycle's windowStartedAt fresh: a NEW reset stamp whose window
+      // start precedes the cycle's open means we joined mid-window (the absolute
+      // estimate is then only a lower bound — see the delta method).
+      for (const [win, stampKey] of pairs) {
+        const resetAt = q[stampKey];
+        const open = this.capacity.openCycle(a.name, win);
+        if (resetAt && open && open.startedAt > resetAt - WINDOW_MS_BY_KIND[win]) {
+          open.windowStartedAt = resetAt - WINDOW_MS_BY_KIND[win];
+        }
+      }
       for (const [win, stampKey] of pairs) {
         const resetAt = q[stampKey];
         // Close ONLY. This path deliberately does NOT null the stamp: the rollover

package/src/capacity-ledger.js

@@ -250,18 +250,71 @@ export class CapacityLedger {
     if (!(utilization > 0) || !(utilization < 1)) return null;
     const open = this.openCycle(name, window);
     if (!open || !(open.tokensSoFar > 0)) return null;
+
+    // DELTA METHOD (preferred). The absolute form (tokens ÷ utilization) silently
+    // assumes we watched the WHOLE window — false whenever the ledger joined late (a
+    // restart, a migration, a new account). Measured 2026-08-24: all four weekly
+    // estimates joined 8.9-95h into their window, so every one understated the tank,
+    // max@dubner.io by ~2x.
+    //
+    // Between two readings the tank is invariant, so pre-join usage cancels:
+    //     tank = (tokens observed between them) / (u2 - u1)
+    // No assumption about what happened before we started counting. Requires a rising
+    // utilization AND tokens accrued across the same span; falls back to absolute when
+    // we genuinely did watch from the start.
+    const mark = this._utilMarks?.get(`${name}:${window}`);
+    if (mark && utilization > mark.utilization) {
+      const deltaTokens = open.tokensSoFar - mark.tokensSoFar;
+      const deltaUtil = utilization - mark.utilization;
+      // A meaningful denominator only: a 0.5pp move on a coarse-rounded percentage
+      // (vendors report whole percents) turns rounding noise into a 200x multiplier.
+      if (deltaTokens > 0 && deltaUtil >= 0.02) {
+        return {
+          tokens: Math.round(deltaTokens / deltaUtil),
+          utilization, fresh: true, method: 'delta',
+          basis: { deltaTokens, deltaUtil },
+        };
+      }
+    }
     // Fresh = we can prove the reading and the accrual describe the SAME window: the
     // reading arrived after the open cycle began. A reading that predates the cycle (or
     // was never noted at all) describes the previous window — mark it and let the UI
     // caveat it, never silently trust it.
     const fresh = this._utilObservedAt > 0 && open.startedAt != null && this._utilObservedAt >= open.startedAt;
-    return { tokens: Math.round(open.tokensSoFar / utilization), utilization, fresh };
+    // ABSOLUTE fallback. Only a LOWER BOUND unless we observed the window from its very
+    // start — flagged so the UI can say "≥" rather than present a floor as the answer.
+    const wholeWindow = open.startedAt != null && open.windowStartedAt != null
+      && open.startedAt <= open.windowStartedAt + 60_000;
+    return {
+      tokens: Math.round(open.tokensSoFar / utilization),
+      utilization, fresh, method: 'absolute', lowerBound: !wholeWindow,
+    };
   }
 
   /** Record when a utilization reading arrived, so estimateFromUtilization can tell
    *  same-window freshness from a stale previous-window reading. */
-  noteUtilizationObserved(at = this._now()) {
+  noteUtilizationObserved(at = this._now(), marks = null) {
     this._utilObservedAt = at;
+    // Snapshot (utilization, tokensSoFar) per account+window so the NEXT reading can be
+    // differenced against it. `marks` is [{name, window, utilization}] from the caller,
+    // which owns the per-account-type quota fields.
+    if (!marks) return;
+    this._utilMarks = this._utilMarks || new Map();
+    for (const m of marks) {
+      if (!(m.utilization >= 0) || !(m.utilization < 1)) continue;
+      const open = this.openCycle(m.name, m.window);
+      if (!open) continue;
+      const key = `${m.name}:${m.window}`;
+      const prev = this._utilMarks.get(key);
+      // Keep the OLDEST usable mark within this cycle: a wider span means a larger
+      // denominator and less rounding sensitivity. Reset when the cycle rolls.
+      if (!prev || prev.cycleStartedAt !== open.startedAt || m.utilization < prev.utilization) {
+        this._utilMarks.set(key, {
+          utilization: m.utilization, tokensSoFar: open.tokensSoFar,
+          cycleStartedAt: open.startedAt, at,
+        });
+      }
+    }
   }
 
   // ── Queries ─────────────────────────────────────────────────────────────────

package/src/tui.js

@@ -2064,8 +2064,14 @@ export class TUI {
         if (est) {
           anyData = true;
           const caveat = est.fresh ? '' : ' (utilization reading may be from the previous window)';
-          out.push('  ' + name + ' ' + prov + ' ' + cyan('~' + formatTokens(est.tokens).padStart(CW - 1))
-            + dim(` ≈ est from ${(est.utilization * 100).toFixed(0)}% full${caveat} — measured after this window completes`));
+          // ≥ = absolute method on a window we joined late: the true tank is at least
+          // this. No ≥ when the delta method fired — it is join-independent, or the
+          // window was observed from its start.
+          const op = est.lowerBound ? '≥' : '~';
+          const via = est.method === 'delta'
+            ? `Δ ${(est.utilization * 100).toFixed(0)}% full` : `${(est.utilization * 100).toFixed(0)}% full`;
+          out.push('  ' + name + ' ' + prov + ' ' + cyan(op + formatTokens(est.tokens).padStart(CW - 1))
+            + dim(` est from ${via}${caveat} — measured after this window completes`));
         } else {
           out.push('  ' + name + ' ' + prov + ' ' + dim('no completed cycle yet'));
         }
@@ -2087,7 +2093,7 @@ export class TUI {
           : ' A session figure appears after an account\'s 5h window resets once.'));
     }
     out.push(' ' + dim('A cycle counts only if maxpool ran for all of it and the account stayed enabled.'));
-    out.push(' ' + dim('~ = estimated now from utilization (tokens ÷ % full); a measured column replaces it later.'));
+    out.push(' ' + dim('~ = estimated from utilization; ≥ = at least this (window joined late); Δ = exact-by-difference; measured replaces both.'));
     return out;
   }