maxpool 1.24.23 → 1.24.25

package/package.json

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

@@ -3728,7 +3728,7 @@ export class AccountManager {
     spannedDays.add(new Date(now).toISOString().slice(0, 10));
     for (const name of this.capacity.accounts()) {
       if (this.capacity.openCycle(name, 'ses') || this.capacity.openCycle(name, 'wk')) {
-        this.capacity.markPartial(name);
+        this.capacity.markPartial(name, { reason: 'maxpool-downtime' });
       }
       for (const day of spannedDays) this.capacity.markDayPartial(name, day);
     }

package/src/capacity-ledger.js

@@ -43,6 +43,14 @@ const READ_FLOOR_MS = { ses: 4 * 3600_000, wk: 5 * 86400_000 };
 // in-window estimate must apply the same floor; one guarding without the other is how
 // the absurd number reached the screen in the first place.
 export const TANK_MIN_UTIL = 0.05;
+
+// Nominal window length. A closed cycle much LONGER than its window swallowed a
+// rollover it never saw (measured live 2026-10-13: "weekly" cycles of 11.9d-14d,
+// "5h" cycles of 7-8h) — two tanks' tokens over one tank's percentage. Not an
+// observation of one window; excluded from tank stats.
+const WINDOW_MS = { ses: 5 * 3600_000, wk: 7 * 86400_000 };
+const WINDOW_CEIL_FACTOR = 1.25;
+
 const MAX_CYCLES_PER_WINDOW = 50;
 const MAX_DAY_BUCKETS = 10;
 
@@ -190,7 +198,7 @@ export class CapacityLedger {
 
   /** Mark the open cycles as partial (maxpool was down / an account was disabled).
    *  Called by the boot path when a gap is detected (B2), and by the disable hook. */
-  markPartial(name, { disabled = false } = {}) {
+  markPartial(name, { disabled = false, reason = null } = {}) {
     const rec = this._accounts.get(name);
     if (!rec) return;
     for (const w of ['ses', 'wk']) {
@@ -200,8 +208,15 @@ export class CapacityLedger {
       // account out of rotation. Setting both for a disable made the disabled flag
       // query-redundant and therefore untested (red-team F6-1) — each now excludes on
       // its own, and each is pinned by its own test.
+      // `reason` ('maxpool-downtime', 'no-weekly-plan', …) rides along for display;
+      // a bare-false (reason null) keeps the historic shape. It is NEVER
+      // 'pre-v3-unverified' — that reason alone means "never trust this row"
+      // (see tankStats' reason gate).
       if (disabled) rec[w].open.disabledDuring = true;
-      else rec[w].open.complete = false;
+      else {
+        rec[w].open.complete = false;
+        if (reason != null && !rec[w].open.partialReason) rec[w].open.partialReason = reason;
+      }
     }
   }
 
@@ -219,6 +234,15 @@ export class CapacityLedger {
     const rec = this._accounts.get(name);
     if (!rec || !rec[window]?.open) return null;
     const open = rec[window].open;
+    // The closing window's fullness is the HIGHEST reading the cycle saw, never
+    // merely the latest: fullness only rises inside a window, so a caller's reading
+    // BELOW the peak is the next window's, arrived before this close ran (measured
+    // live 2026-10-13: kira closed a 3.1M-token week at "3% full" ⇒ a 105M tank —
+    // the reading was the freshly-reset NEXT week's).
+    if (Number.isFinite(open.peakUtilization)
+        && !(Number.isFinite(finalUtilization) && finalUtilization >= open.peakUtilization)) {
+      finalUtilization = open.peakUtilization;
+    }
     // ONE CYCLE PER BOUNDARY CLOSURE — the structural backstop for the two-closer race
     // (round-2 F1). If both closers observe the SAME reset stamp within the same
     // rollover moment, the second close's tokens are a straddling tail of that same
@@ -332,9 +356,15 @@ export class CapacityLedger {
     if (!marks) return;
     this._utilMarks = this._utilMarks || new Map();
     for (const m of marks) {
-      if (!(m.utilization >= 0) || !(m.utilization < 1)) continue;
+      if (!Number.isFinite(m.utilization) || m.utilization < 0) continue;
       const open = this.openCycle(m.name, m.window);
       if (!open) continue;
+      // PEAK: fullness only rises inside one window, so the highest reading a cycle
+      // saw is its closing fullness (closeCycle prefers it over a later, lower one).
+      if (!Number.isFinite(open.peakUtilization) || m.utilization > open.peakUtilization) {
+        open.peakUtilization = Math.min(1, m.utilization);
+      }
+      if (!(m.utilization < 1)) 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
@@ -409,8 +439,24 @@ export class CapacityLedger {
   tankStats(name, window) {
     const rec = this._accounts.get(name);
     const floor = (this._readFloorOverride ?? READ_FLOOR_MS)[window] ?? 0;
+    // TANK READING SET (2026-10-13): partial cycles COUNT here. The strict
+    // `complete` gate was written for demand stats and quietly deleted every
+    // weekly observation — a 7d window outlives every maxpool restart/sleep, so
+    // restoreCapacityState's >60s downtime check marked nearly all of them
+    // partial and the Weekly (7d) page read "--" everywhere (owner report
+    // 2026-10-13). For TANK math a gap is already handled: tokens ÷ vendor % is
+    // a lower bound whenever spend was unseen, and exact/bounded/lowerBound
+    // exist to say so. Still excluded, hard: disabledDuring (operator benched
+    // the account — not a capacity observation) and `pre-v3-unverified` (the
+    // ONE reason that means "never trust this row").
     const closed = (rec?.[window]?.closed || []).filter(c =>
-      c.complete && !c.disabledDuring && (c.endedAt - c.startedAt) >= floor - 1_000);
+      !c.disabledDuring
+      && c.partialReason !== 'pre-v3-unverified'
+      && (c.endedAt - c.startedAt) >= floor - 1_000
+      // CEILING: a cycle far longer than its window swallowed a rollover it never
+      // saw — two tanks' tokens over one tank's percentage (see WINDOW_CEIL_FACTOR).
+      && (this._readFloorOverride != null
+          || (c.endedAt - c.startedAt) <= WINDOW_MS[window] * WINDOW_CEIL_FACTOR));
     // PHYSICAL FLOOR: a tank can never be smaller than the most tokens ever
     // delivered in one complete window — every token we count is a vendor token
     // (C ≤ V ≤ tank), so maxDelivered ≤ tank is an invariant, not a heuristic.
@@ -425,23 +471,34 @@ export class CapacityLedger {
     // floor rather than being thrown away — discarding left an account whose
     // every reading was contaminated with NOTHING to show. After a plan
     // downgrade the floor over-states until old cycles age out — conservative.
-    const maxDelivered = closed.reduce((m, c) => Math.max(m, c.tokens), 0);
+    // The floor's own base uses the complete windows only — a partial cycle's
+    // tokens may end mid-window, understating a single delivery.
+    const maxDelivered = closed.filter(c => c.complete)
+      .reduce((m, c) => Math.max(m, c.tokens), 0);
     const usable = closed.filter(c =>
       Number.isFinite(c.finalUtilization) && c.finalUtilization >= TANK_MIN_UTIL);
     if (!usable.length) return null;
     let sum = 0, exact = 0, bounded = 0;
     for (const c of usable) {
       const observedFromStart = c.startedAt != null && c.windowStartedAt != null
-        && c.startedAt <= c.windowStartedAt + 60_000;
+        && c.startedAt <= c.windowStartedAt + 60_000 && c.complete;
       sum += Math.max(c.tokens / c.finalUtilization, maxDelivered);
       if (observedFromStart) exact++; else bounded++;
     }
     const last = usable[usable.length - 1];
+    const prevCycle = usable[usable.length - 2];
     return {
       avg: Math.round(sum / usable.length),
       exact, bounded,
       n: usable.length,
-      last: Math.round(last.tokens / last.finalUtilization),
+      last: Math.round(Math.max(last.tokens / last.finalUtilization, maxDelivered)),
+      // PREV in TANK units (tokens ÷ that cycle's own reading) — the page's
+      // Prev column used to come from windowStats (delivered tokens), mixing
+      // units across one row (2026-10-13 owner report). Same physical floor as
+      // the average: a reading implying less than a past delivery is impossible.
+      prev: prevCycle != null
+        ? Math.round(Math.max(prevCycle.tokens / prevCycle.finalUtilization, maxDelivered))
+        : null,
       lowerBound: bounded > 0 && exact === 0,
     };
   }

package/src/tui.js

@@ -271,23 +271,31 @@ function settingsTags(am, a) {
   return tags;
 }
 
-/** True when the reservation is what is currently keeping traffic off this account
- *  — either window at or past the cap. Reads the manager's own predicate so the
- *  label can never disagree with routing. */
-/** The 5h window is used up past the bench — same predicate the router's
- *  _isSessionQuotaUnavailable applies, without its expiry-clearing side effect (a
- *  window whose reset has passed is NOT full: the router clears it on next use). */
+/** The session (5h) window is what keeps traffic off this account: a pure mirror of
+ *  the router's _isSessionQuotaUnavailable, without its expiry-clearing write.
+ *  Which readings expire on their reset is the ROUTER's rule, copied here: it clears
+ *  the Claude 5h reading and the API-key limits when their reset passes, but NEVER
+ *  a provider's (GLM/Kimi) providerSes — that stays until the next usage probe, so a
+ *  provider past its reset stamp is still refused and must not read "active". */
 function sessionFull(am, a) {
   const q = a?.quota || {};
   const now = Date.now();
   const bench = am?._sessionBenchThreshold?.(a, now);
   if (!Number.isFinite(bench)) return false;
-  const live = (util, reset) => util != null && !(reset && now >= reset) && util >= bench;
-  return a.type === 'provider'
-    ? live(q.providerSes, q.providerSesReset)
-    : live(q.unified5h, q.unified5hReset);
+  const expired = reset => reset != null && now >= reset;
+  if (q.unified5h != null && !expired(q.unified5hReset) && q.unified5h >= bench) return true;
+  const apiLive = !(q.resetsAt && now >= new Date(q.resetsAt).getTime());
+  if (apiLive && q.tokensLimit != null && q.tokensRemaining != null
+      && 1 - q.tokensRemaining / q.tokensLimit >= bench) return true;
+  if (apiLive && q.requestsLimit != null && q.requestsRemaining != null
+      && 1 - q.requestsRemaining / q.requestsLimit >= bench) return true;
+  if (q.providerSes != null && q.providerSes >= bench) return true;
+  return false;
 }
 
+/** True when the reservation is what is currently keeping traffic off this account
+ *  — either window at or past the cap. Reads the manager's own predicate so the
+ *  label can never disagree with routing. */
 function capBenched(am, a) {
   if (a?.capUtilization == null) return false;
   const q = a.quota || {};
@@ -296,7 +304,13 @@ function capBenched(am, a) {
   // Each reading is judged against ITS OWN window's cap — under the dynamic cap the
   // two differ (a 5h window nearly over is lifted while the weekly is still at its
   // floor), so passing the default window for both would mislabel one of them.
-  return !!(am?._capped?.(a, ses, 'ses') || am?._capped?.(a, wk, 'wk'));
+  if (am?._capped?.(a, ses, 'ses') || am?._capped?.(a, wk, 'wk')) return true;
+  // Providers: the router's weekly gate judges max(5h, weekly) against the WEEKLY
+  // cap (_weeklyRawState), so a 5h reading over the weekly cap benches it too.
+  if (a.type === 'provider' && (ses != null || wk != null)) {
+    return !!am?._capped?.(a, Math.max(ses ?? 0, wk ?? 0), 'wk');
+  }
+  return false;
 }
 
 export function weeklyPolicyText(am, account) {
@@ -1014,7 +1028,9 @@ export class TUI {
 
 
   _keyRouting(k) {
-    if (k === 'a') {
+    if (k === 'a' && this.am.routingMode !== 'preferred') {
+      this._addLog('No account is pinned — routing is already automatic');
+    } else if (k === 'a') {
       this._confirm(
         'Unpin and use automatic routing?',
         'Removes the pinned account. New requests are spread across all healthy accounts again.',
@@ -1236,7 +1252,13 @@ export class TUI {
           ? `${Math.round(existing * 100)}%${existingMode === 'dynamic' ? ' dynamic' : ' fixed'}`
           : 'off';
         this.mode = 'input';
-        this.inputPrompt = `Usage cap for "${current}" — NN = dynamic floor (rises near reset), fNN = fixed, 0 = off, now ${nowLabel}`;
+        // Plain-English prompt (owner 2026-10-13: "I'm not sure how does this work.
+        // I want to keep the dynamic floor, but I also want to raise the basic cap").
+        // Type just a number = the dynamic cap's STARTING level (it holds the account
+        // to NN% early in each window, then rises toward ~95% as the window nears
+        // its reset, so unused capacity isn't stranded). fNN = fixed wall (no rise).
+        // 0 = no cap.
+        this.inputPrompt = `Usage cap for "${current}" — type a % like 75: the account stays free until it hits that, then unlocks gradually as the window refills (dynamic). f75 = never unlock early (fixed). 0 = remove. Now ${nowLabel}`;
         this.inputBuf = '';
         this.inputSensitive = false;
         this.inputCb = value => this._doSetCap(targetIdx, String(value || '').trim());
@@ -2020,6 +2042,15 @@ export class TUI {
       lines.push(`   ${gray(this.log[i].t)}  ${this.log[i].msg}`);
     }
 
+    // The footer is the screen's controls — it must never be pushed off. On a short
+    // terminal cut the BODY from the bottom, and say so.
+    if (lines.length > H - footerH) {
+      const keep = Math.max(0, H - footerH - 1);
+      const hidden = lines.length - keep;
+      lines.length = keep;
+      lines.push(` ${dim(`… ${hidden} more row${hidden === 1 ? '' : 's'} — make the window taller to see them`)}`);
+    }
+
     // Pad to fill
     while (lines.length < H - footerH) lines.push('');
 
@@ -2116,10 +2147,10 @@ export class TUI {
     // relabels an otherwise-active row; exhausted / throttled / auth states keep their
     // own (more specific) word. "capped" = the owner's usage cap is holding it;
     // "5h full" = its session window is used up until the reset shown on the row.
-    // READ-ONLY by design: _weeklyRawState/_isSessionQuotaUnavailable call
-    // _clearExpiredQuotas, which MUTATES the quota (nulls an expired window). A render
-    // must never change the state it is drawing — the row's own bars, read later in
-    // this function, then showed blanks. capBenched + _sessionBenchThreshold are pure.
+    // Pure predicates on purpose: _weeklyRawState/_isSessionQuotaUnavailable call
+    // _clearExpiredQuotas, which MUTATES the quota (nulls an expired window), so calling
+    // them here blanked this row's own bars mid-render. (_render already runs the
+    // manager's expiry refresh once per frame, before any row is drawn.)
     if (a.enabled !== false && effectiveStatus === 'active') {
       if (capBenched(this.am, a)) effectiveStatus = 'capped';
       else if (sessionFull(this.am, a)) effectiveStatus = '5h full';
@@ -2483,7 +2514,7 @@ export class TUI {
       if (win === 'wk' && a.type === 'provider' && a.quota?.weeklyAbsent) {
         const sesTank = this.am.capacityTank?.(i, 'ses');
         const approx = sesTank && sesTank.n > 0
-          ? formatTokens(Math.round(sesTank.avg * (7 * 24) / 5)) : '--';
+          ? `≈ ${formatTokens(Math.round(sesTank.avg * (7 * 24) / 5))}` : '--';
         const cellsByName = { Current: cyan(approx), Prev: '--', Avg: '--', N: sesTank?.n ? String(sesTank.n) : '--' };
         out.push('  ' + name + ' ' + prov + ' '
           + COLS.map(c => cellsByName[c].padStart(CW)).join('')
@@ -2507,12 +2538,14 @@ export class TUI {
         cur = formatTokens(Math.round(nowOpen.tokensSoFar / util));
       }
       const curPct = util != null && cur !== '--' ? dim(`@${Math.round(util * 100)}%`) : '';
-      const st = ledger.windowStats(a.name, win);
+      // Every history column is a TANK number (tokens ÷ closing %). Prev/N used to
+      // come from windowStats — delivered tokens and a different cycle set — so one
+      // row mixed units (2026-10-13 owner report; see tankStats' reading-set note).
       const cellsByName = {
         Current: cur.padStart(CW - (curPct ? curPct.length + 1 : 0)),
-        Prev: (st?.prev != null ? formatTokens(st.prev) : '--'),
+        Prev: (tank?.source === 'cycles' && tank.prev != null ? formatTokens(tank.prev) : '--'),
         Avg: (tank?.source === 'cycles' ? formatTokens(tank.avg) : '--'),
-        N: (st ? String(st.cycles) : '--'),
+        N: (tank?.source === 'cycles' ? String(tank.n) : '--'),
       };
       const row = '  ' + name + ' ' + prov + ' '
         + COLS.map(c => cellsByName[c].padStart(CW)).join('');
@@ -2551,7 +2584,7 @@ export class TUI {
     out.push(` ${dim('Usage cap for ONE account:')} ${bold('Esc')} ${dim('then')} ${bold('a')} ${dim('→')} ${bold('u')} ${dim('(Claude or GLM)')}`);
     const capped = this.am.accounts.filter(a => a.capUtilization != null && a.enabled !== false);
     if (capped.length) {
-      out.push(` ${dim('Capped now:')} ${capped.map(a => `${a.name} ${Math.round(a.capUtilization * 100)}%`).join(', ')}`);
+      out.push(` ${dim('Caps set:')} ${capped.map(a => `${a.name} ${Math.round(a.capUtilization * 100)}%`).join(', ')}`);
     }
     return out;
   }