maxpool 1.8.9 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.8.9",
+  "version": "1.9.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

@@ -2699,12 +2699,11 @@ export class AccountManager {
       if (usage.sevenDay.utilization != null) q.unified7d = clamp01(usage.sevenDay.utilization);
       if (usage.sevenDay.resetAt != null) q.unified7dReset = usage.sevenDay.resetAt;
     }
-    // Stamp-advance close (same guard as the provider path): a FRESHER stamp means
-    // the old window rolled over — close its cycle at the old boundary.
-    // noteCapacityWindowAdvance already no-ops on a missing/unchanged/older stamp, so
-    // there is nothing to gate here — pass the raw (possibly undefined) value through.
     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();
     // 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
@@ -3018,6 +3017,19 @@ export class AccountManager {
 
   /** Accrue ONE request's tokens into the capacity ledger (per-request values; the
    *  server seam has already applied max-semantics for streamed output). */
+  /** The capacity ESTIMATE for an account+window, from live utilization. Falls back
+   *  to null when the vendor reports no utilization for that window (the no-weekly GLM
+   *  plans), the account has not accrued, or it is already throttled. */
+  capacityEstimate(accountIndex, window) {
+    const a = this.accounts[accountIndex];
+    if (!a) return null;
+    const q = a.quota || {};
+    const util = window === 'wk'
+      ? (a.type === 'provider' ? q.providerWk : q.unified7d)
+      : (a.type === 'provider' ? q.providerSes : q.unified5h);
+    return this.capacity.estimateFromUtilization(a.name, window, util) || null;
+  }
+
   accrueCapacity(accountIndex, { input = 0, output = 0 } = {}) {
     const account = this.accounts[accountIndex];
     if (!account) return;

package/src/capacity-ledger.js

@@ -53,6 +53,7 @@ export class CapacityLedger {
     // True only for a ledger restored with no usable history — see fromSerialized.
     // Cleared per account+window once that window's first boundary is behind us.
     this._joinedMidWindow = false;
+    this._utilObservedAt = 0;   // last utilization-reading arrival (see estimateFromUtilization)
   }
 
   /** Restore from a serialized payload (state.json). Tolerant: unknown schemaVersion →
@@ -231,6 +232,38 @@ export class CapacityLedger {
     return rec[window].closed[rec[window].closed.length - 1];
   }
 
+  /**
+   * ESTIMATED window capacity from live utilization: tokens observed in the OPEN
+   * cycle ÷ the vendor's own fullness fraction (0..1). A window at 96% holding 812k
+   * tokens implies a ~846k tank — no completed cycle needed. This is the same math the
+   * user does in their head ("if 10% took A tokens, 100% is A×10") and it makes the
+   * page useful from minute one, while completed cycles remain the precise column.
+   *
+   * Returns { tokens, utilization, fresh } or null when no estimate exists.
+   *   null cases — utilization 0/unknown (0÷0), no accrual yet, or util ≥ 1 (the
+   *   account is throttled; the fraction says nothing about the tank size).
+   * `fresh` = the utilization reading and the accrual are from the same window
+   * (utilization refreshes on probe/header; the open cycle closes at the boundary —
+   * a stale util from the PREVIOUS window silently understates the estimate).
+   */
+  estimateFromUtilization(name, window, utilization) {
+    if (!(utilization > 0) || !(utilization < 1)) return null;
+    const open = this.openCycle(name, window);
+    if (!open || !(open.tokensSoFar > 0)) return null;
+    // 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 };
+  }
+
+  /** Record when a utilization reading arrived, so estimateFromUtilization can tell
+   *  same-window freshness from a stale previous-window reading. */
+  noteUtilizationObserved(at = this._now()) {
+    this._utilObservedAt = at;
+  }
+
   // ── Queries ─────────────────────────────────────────────────────────────────
 
   /** The columns the TUI renders: last, prev, prev1, avg3, avg10, allTime — over

package/src/tui.js

@@ -2056,7 +2056,19 @@ export class TUI {
       }
       const st = ledger.windowStats(a.name, win);
       if (!st) {
-        out.push('  ' + name + ' ' + prov + ' ' + dim('no completed cycle yet'));
+        // No completed cycle yet — but the vendor's own fullness reading still yields
+        // an ESTIMATE (tokens seen ÷ utilization): useful from minute one, honest about
+        // being an estimate. `~` marks it; a measured column replaces it after the first
+        // full window. A stale-util caveat only when we cannot prove same-window.
+        const est = this.am.capacityEstimate?.(i, win);
+        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`));
+        } else {
+          out.push('  ' + name + ' ' + prov + ' ' + dim('no completed cycle yet'));
+        }
         continue;
       }
       anyData = true;
@@ -2075,6 +2087,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.'));
     return out;
   }