maxpool 1.8.8 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.8.8",
+  "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/index.js

@@ -33,7 +33,7 @@ import { loginOAuth, fetchProfile, refreshAccessToken, isTokenExpiringSoon, toke
 import { TUI } from './tui.js';
 import { RestartController } from './restart-controller.js';
 import { resolveAccounts } from './account-config.js';
-import { maybeCheckForUpdate, getCurrentVersion, markApplied, clearQuarantine, getBootVersion } from './updater.js';
+import { maybeCheckForUpdate, getCurrentVersion, markApplied, clearQuarantine, captureBootVersion } from './updater.js';
 import {
   runReloadBaton,
   RELOAD_SWAPPED, RELOAD_ROLLED_BACK,
@@ -577,6 +577,10 @@ async function serverWorkerCommand() {
 
   const threshold = config.switchThreshold || 0.90;
   const accountManager = new AccountManager(accounts, threshold, config.scheduler || {});
+  // The EXECUTING build: a disk read taken NOW, before any self-install can rewrite
+  // package.json. Fire-and-forget — the status endpoint reports null until it lands
+  // (milliseconds), never a wrong number.
+  captureBootVersion().then(v => { accountManager.runningVersion = v; }).catch(() => {});
   // (macOS) Keep the system awake ONLY while there is work in flight or queued, so a
   // long overnight streaming request survives Maintenance Sleep; the Mac sleeps
   // normally when idle. Disable via `preventSleep: false` in config.
@@ -1259,8 +1263,6 @@ async function serverWorkerCommand() {
       // pass the real config so they still respect the user's autoUpdate choice.
       const cfg = forceInstall ? { ...config, autoUpdate: true } : config;
       const r = await maybeCheckForUpdate(cfg, notifyUpdate, info => { accountManager.versionInfo = info; }, { announce });
-      // Capture the EXECUTING version for /maxpool/status (see AccountManager.getStatus).
-      accountManager.runningVersion = getBootVersion();
       apply(r);
       return r;
     } catch { return undefined; /* update path is best-effort; never break the proxy */ }

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;
   }
 

package/src/updater.js

@@ -92,8 +92,18 @@ export function __resetUpdaterState() { _bootVersion = undefined; _lastAttempted
  *  with every commit) is not what is running. Measured 2026-08-23: the status endpoint
  *  answered 1.8.7 for a process executing 1.8.6, and a post-deploy check keyed on that
  *  number verified the wrong build. */
+export async function captureBootVersion() {
+  // Read the disk ONCE, at process start, BEFORE any self-install can rewrite it — that
+  // read IS the executing version. (_bootVersion is the same value; it is populated
+  // lazily by the first maybeCheckForUpdate, which is up to 30 minutes after boot, so
+  // reading it at construction returns null — the bug in the first version of this fix.)
+  if (_bootVersion === undefined) _bootVersion = await getCurrentVersion();
+  return _bootVersion ?? null;
+}
+
+/** The already-captured executing version; null before captureBootVersion(). */
 export function getBootVersion() {
-  return _bootVersion ?? null;   // null only before the first maybeCheckForUpdate
+  return _bootVersion ?? null;
 }
 
 /** Mark a version as ATTEMPTED-to-apply. The caller calls this at the moment it triggers