maxpool 1.15.0 → 1.17.0

package/package.json

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

package/src/prober.js

@@ -68,6 +68,11 @@ export class Prober {
     if (this._running) return this._inflight || Promise.resolve();
     this._running = true;
     this._stopping = false;
+    // Publish the sweep's liveness so the UI can answer "what happens next?"
+    // rather than printing a bare "stale". Reported 2026-08-27: a stale marker with
+    // no next step reads as a problem the user must fix, when the prober is already
+    // retrying on its own.
+    this.am.quotaProbeSweeping = true;
     this._inflight = (async () => {
       try {
         // CAPACITY LEDGER: close any open cycle whose window's reset stamp has
@@ -110,6 +115,10 @@ export class Prober {
       } finally {
         this._running = false;
         this._inflight = null;
+        this.am.quotaProbeSweeping = false;
+        // When the NEXT sweep starts. setInterval fires every intervalMs from the
+        // last tick, so "now + interval" is the honest estimate for the UI.
+        this.am.quotaProbeNextSweepAt = this.intervalMs > 0 ? Date.now() + this.intervalMs : null;
       }
     })();
     return this._inflight;

package/src/tui.js

@@ -139,6 +139,18 @@ function formatMs(ms) {
   return `${min}m${String(rem).padStart(2, '0')}s`;
 }
 
+/** Coarse human duration for AGE and NEXT-REFRESH text: "45s", "12m", "2h".
+ *  Deliberately not formatMs — "quota 12m03s old" spends precision on a number
+ *  nobody reads to the second, and the extra digits are what made the old cell
+ *  look like machine output. */
+function formatAge(ms) {
+  if (ms == null || isNaN(ms) || ms < 0) return '';
+  if (ms < 60_000) return `${Math.max(1, Math.round(ms / 1000))}s`;
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)}m`;
+  if (ms < 86_400_000) return `${Math.round(ms / 3_600_000)}h`;
+  return `${Math.round(ms / 86_400_000)}d`;
+}
+
 function statusColor(status) {
   if (status == null) return '-';
   if (status >= 200 && status < 300) return green(String(status));
@@ -162,22 +174,69 @@ function countdown(ts) {
   return `${Math.ceil(ms / 86_400_000)}d`;
 }
 
+/** ACTIVITY cell — "is this account working, and is it healthy?" in plain words.
+ *  Rewritten twice on owner feedback (2026-08-27): first to symbols ("▶2 · 17/h ·
+ *  8.5s"), which read as secret code; now to words. Average latency is GONE —
+ *  "how long each request takes" is not something the owner acts on. An idle
+ *  account renders NOTHING.
+ *
+ *    2 live · 17 req/hr · 1 failed
+ *    17 req/hr                 working, idle this second
+ *    (blank)                   resting — nothing to say
+ */
 function loadText(load) {
-  const cur = load?.current || {};
-  const m15 = load?.last15m || {};
-  const h1 = load?.last1h || {};
-  // "Now" = what this account is handling right THIS moment: N in-flight requests
-  // (and their combined weight ~ payload size, the scheduler's load input). Kept
-  // distinct from the "15m"/"1h" THROUGHPUT counts that follow, which the old
-  // "Load X/Y" label collided with.
-  const inflight = cur.inFlight || 0;
-  const weight = cur.activeWeight || 0;
-  const now = weight > 0 ? `Now ${inflight} (${weight}w)` : `Now ${inflight}`;
-  const recent = `${m15.requests || 0}r`;
-  const recentAvg = m15.avgMs != null ? ` ${formatMs(m15.avgMs)}` : '';
-  const hour = `${h1.requests || 0}r`;
-  const fails = (m15.failed || 0) > 0 ? ` ${red(`${m15.failed}f`)}` : '';
-  return `${now}  15m ${recent}${recentAvg}${fails}  1h ${hour}`;
+  const inflight = load?.current?.inFlight || 0;
+  const hourReq = load?.last1h?.requests || 0;
+  const failed = load?.last15m?.failed || 0;
+  if (!inflight && !hourReq && !failed) return '';
+  const parts = [];
+  if (inflight) parts.push(`${inflight} live`);
+  if (hourReq) parts.push(`${hourReq} req/hr`);
+  if (failed) parts.push(red(`${failed} failed`));
+  return parts.join(' · ');
+}
+
+/** The usage CAP is an account PROPERTY, not a state — so it renders whenever one
+ *  is set, on every account type, whatever the account is doing. It previously
+ *  lived inline in the provider branch only, so the OAuth account the feature was
+ *  built for (max@gomokka.com) showed no cap anywhere: reported 2026-08-27, "I need
+ *  to be able to see whether an account has a cap or not." Yellow while the cap is
+ *  actively holding traffic back, dim otherwise. */
+function capText(a, benched) {
+  if (a?.capUtilization == null) return '';
+  const t = `cap ${Math.round(a.capUtilization * 100)}%`;
+  return benched ? yellow(t) : dim(t);
+}
+
+/** PER-ACCOUNT SETTINGS the user set by hand — the last column's whole job
+ *  (owner, 2026-08-27: "the last column should contain any and all settings that
+ *  are custom per account"). Fleet-wide settings (routing mode, peak policy) stay
+ *  in the top header where they already live; only what is scoped to THIS account
+ *  belongs on THIS row.
+ *    preferred   this account is the manual routing pin (the 'p' key)
+ *    cap NN%     its reserved-capacity ceiling (the 'c' key)
+ *  Deliberately NOT here: automatic routing policies (peak, fast-refill) — those
+ *  are the system's behaviour, not the user's settings; they keep their own tags.
+ */
+function settingsTags(am, a) {
+  const tags = [];
+  if (am?.routingMode === 'preferred' && a?.name === am.preferredAccountName) {
+    tags.push(cyan('preferred'));
+  }
+  const capTag = capText(a, capBenched(am, a));
+  if (capTag) tags.push(capTag);
+  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. */
+function capBenched(am, a) {
+  if (a?.capUtilization == null) return false;
+  const q = a.quota || {};
+  const ses = a.type === 'provider' ? q.providerSes : q.unified5h;
+  const wk = a.type === 'provider' ? q.providerWk : q.unified7d;
+  return !!(am?._capped?.(a, ses) || am?._capped?.(a, wk));
 }
 
 export function weeklyPolicyText(am, account) {
@@ -190,6 +249,14 @@ export function weeklyPolicyText(am, account) {
     return yellow(`Cap ${Math.round((account.capUtilization || 0) * 100)}%`);
   }
   if (!state || state === 'unknown' || state === 'normal') return '';
+  // SAY IT ONCE (2026-08-27). An account Anthropic is rejecting outright already
+  // says so twice on this row: the Wk bar reads 100%, and the Status column reads
+  // "exhausted". A third "Wk exhausted 100%" tag was pure repetition, and it pushed
+  // the genuinely-informative tags (Cap, a per-model sub-limit) off to the right.
+  // Dropped ONLY when the Status column carries the same fact — a soft/reserve/
+  // critical row, or an exhausted-by-threshold row the status column shows as
+  // "active", still needs the tag.
+  if (am._isAccountWideRejected?.(account)) return '';
   const rawState = am._weeklyRawState?.(account) || state;
   const used = Number(account.quota?.unified7d);
   const pct = Number.isFinite(used)
@@ -1735,11 +1802,11 @@ export class TUI {
       if (hidden > 0) {
         lines.push(` ${dim(`… ${hidden} disabled account${hidden === 1 ? '' : 's'} hidden — press h to show`)}`);
       }
-      // Glossary FOOTER (expands the abbreviations the header + inline labels can't
-      // spell out). Below the rows so it never breaks the header↔column alignment.
-      if (W >= 88) {
-        lines.push(' ' + dim('Legend  Ses = 5h · Wk = 7d · Now = in-flight (weight) · 15m/1h = served (avg · f = fails)'));
-      }
+      // The glossary FOOTER is gone (owner, 2026-08-27). A legend is a symptom: it
+      // exists to decode a row that could not be read on its own. Every cell now
+      // says what it means in words ("2 live · 17 req/hr", "quota 12m old ·
+      // refreshing in 45s"), so there is nothing left to decode — and one fewer
+      // line of chrome between the operator and the data.
     }
 
     // ── Activity header
@@ -1859,13 +1926,16 @@ export class TUI {
     if (a.enabled !== false && upstreamBlocking && a.status === 'active') {
       effectiveStatus = a.inFlight > 0 ? 'probing' : 'waiting';
     }
-    // "blocked" = Anthropic is rejecting the WHOLE account (a 'rejected' unified
-    // status corroborated by an exhausted unified bucket). A per-model cap (Fable)
-    // is NOT account-wide — it shows as the separate "… maxed" tag, leaving the
-    // status column truthful. Keys on a.status (not effectiveStatus) so a genuine
-    // block wins even inside an upstream-throttle window.
+    // Anthropic is rejecting the WHOLE account (a 'rejected' unified status
+    // corroborated by an exhausted unified bucket). A per-model cap (Fable) is NOT
+    // account-wide — it shows as the separate "… maxed" tag, leaving the status
+    // column truthful. Keys on a.status (not effectiveStatus) so a genuine block
+    // wins even inside an upstream-throttle window.
+    // Named "exhausted", not "blocked" (2026-08-27): the row's own quota bar and
+    // every other surface call this state exhausted, and two words for one state
+    // read as two different problems.
     if (a.enabled !== false && a.status === 'active' && this.am._isAccountWideRejected?.(a)) {
-      effectiveStatus = 'blocked';
+      effectiveStatus = 'exhausted';
     }
     // A dead refresh token surfaces as "reauth" (re-login needed) rather than a
     // generic "error", so the user knows the fix. Display-only — account.status
@@ -1879,7 +1949,7 @@ export class TUI {
     switch (effectiveStatus) {
       case 'active':    status = isCur ? green('active') : 'active'; break;
       case 'reauth':    status = yellow('reauth'); break;
-      case 'blocked':   status = red('blocked'); break;
+      case 'blocked':   status = red('exhausted'); break;
       case 'probing':   status = green('probing'); break;
       case 'waiting':   status = yellow('waiting'); break;
       case 'paused':    status = yellow('paused'); break;
@@ -1936,6 +2006,15 @@ export class TUI {
     }
     const weekly = weeklyPolicyText(this.am, a);
     if (weekly) line += `  ${weekly}`;
+    // Per-account SETTINGS (preferred pin, usage cap), whatever the account is
+    // doing. weeklyPolicyText renders "Cap 50%" only while the cap is the ACTIVE
+    // weekly state; these are the standing properties, so a capped account that is
+    // exhausted, throttled or idle still says so. The cap is suppressed when the
+    // weekly tag already IS the Cap label (no double tag).
+    for (const tag of settingsTags(this.am, a)) {
+      if (weekly.includes('Cap ') && tag.includes('cap ')) continue;
+      line += `  ${tag}`;
+    }
     // Per-model weekly caps (e.g. Fable, while the unified weekly still has
     // headroom). Show the ACTUAL utilization — "Fable 90%" (yellow) while high but
     // still usable, "Fable maxed" (red) ONLY at genuine exhaustion. This is the
@@ -1958,7 +2037,8 @@ export class TUI {
     // cause (e.g. rate-limited) when a probe failure is on record — rather than imply
     // the last-known value is current.
     line += this._probeHealthNote(a);
-    line += `  ${dim(loadText(this._accountLoad(a)))}`;
+    const act = loadText(this._accountLoad(a));
+    if (act) line += `  ${dim(act)}`;
     return line;
   }
 
@@ -1990,10 +2070,35 @@ export class TUI {
       const headerFresh = q.lastHeaderQuotaAt && (Date.now() - q.lastHeaderQuotaAt) <= Math.max(3 * interval, 180_000);
       if (headerFresh) return '';
     }
-    const s = q.lastProbeErrorStatus;
-    if (s === 429) return `  ${yellow('stale·probe throttled')}`;
-    if (s) return `  ${yellow('stale·probe ' + s)}`;
-    return `  ${dim('stale')}`;
+    // SAY WHAT HAPPENS NEXT (owner, 2026-08-27): "stale" / "stale·probe throttled"
+    // named an internal mechanism and left the user with nothing to do. Nothing IS
+    // the correct action — the prober retries on its own schedule and backs off
+    // automatically when Anthropic rate-limits it — so the cell now states how old
+    // the numbers are AND when they refresh, in that order.
+    const age = q.lastProbeOkAt ? formatAge(Date.now() - q.lastProbeOkAt) : null;
+    const ageText = age ? `quota ${age} old` : 'quota not read yet';
+    const next = this._probeNextText();
+    const throttled = q.lastProbeErrorStatus === 429;
+    // Throttled is the ONE case worth colouring: it is why the refresh is late, and
+    // it self-clears. Everything else is a plain dim statement of fact.
+    const body = throttled
+      ? `${ageText} · rate-limited, retrying ${next}`
+      : `${ageText} · refreshing ${next}`;
+    return `  ${throttled ? yellow(body) : dim(body)}`;
+  }
+
+  /** "now" while a sweep is in flight, else "in 45s" from the prober's next-tick
+   *  stamp. Falls back to the configured interval when no sweep has completed yet
+   *  (fresh boot), and to a bare "shortly" when the probe is manual/off. */
+  _probeNextText() {
+    if (this.am.quotaProbeSweeping) return 'now';
+    const at = this.am.quotaProbeNextSweepAt;
+    if (at) {
+      const ms = at - Date.now();
+      return ms > 0 ? `in ${formatAge(ms)}` : 'now';
+    }
+    const interval = this.am.quotaProbeIntervalMs;
+    return interval > 0 ? `every ${formatAge(interval)}` : 'shortly';
   }
 
   _renderProviderAcct(sel, cur, name, type, status, a, bw = 11, showBoth = true) {
@@ -2031,7 +2136,6 @@ export class TUI {
         const m = this.am._fastRefillMultiplier(a);
         if (m < 1) note += `  ${cyan(`fast·refill ×${m.toFixed(2)}`)}`;
       }
-      if (a.capUtilization != null) note += `  ${yellow(`cap ${Math.round(a.capUtilization * 100)}%`)}`;
     } else if (q.providerQuotaSource === 'console-only') {
       sesCell = emptyBar('n/a', bw);
       wkCell = emptyBar('n/a', bw);
@@ -2040,15 +2144,26 @@ export class TUI {
       sesCell = emptyBar('probing', bw);
       wkCell = emptyBar('probing', bw);
     }
+    // Settings ride OUTSIDE the quota-readable branch: an account with an
+    // unreadable or not-yet-probed quota still HAS its reservation, and hiding the
+    // setting whenever the probe is quiet is how a shipped feature reads as absent.
+    for (const tag of settingsTags(this.am, a)) note += `  ${tag}`;
 
     let line = ` ${sel}${cur} ${name} ${type} ${status} Ses ${sesCell}`;
     if (showBoth) line += `  Wk  ${wkCell}`;
     line += note;
     // Same recent-load columns as OAuth (providers track inFlight + load events),
     // plus a compact Last <status> <ms> — the one signal that matters for a
-    // rarely-hit fallback (loadText reads 0r when idle).
-    line += `  ${dim(loadText(this._accountLoad(a)))}`;
-    if (a.lastStatus) line += `  ${dim('Last')} ${statusColor(a.lastStatus)} ${dim(formatMs(a.lastResponseMs))}`;
+    // rarely-hit fallback. loadText renders empty when fully idle.
+    const act = loadText(this._accountLoad(a));
+    if (act) line += `  ${dim(act)}`;
+    // "Last 200 6.4s" next to a live "17/h · 6.4s" said the same thing twice. Keep it
+    // for the two cases where it is the ONLY thing that speaks: a non-2xx last result
+    // (always worth seeing), or an idle row whose activity cell is blank.
+    const lastOk = a.lastStatus >= 200 && a.lastStatus < 300;
+    if (a.lastStatus && (!lastOk || !act)) {
+      line += `  ${dim('Last')} ${statusColor(a.lastStatus)} ${dim(formatMs(a.lastResponseMs))}`;
+    }
     // Header-derived generic rate-limit (distinct from the monitor-endpoint quota),
     // if the provider upstream returns x-ratelimit-* headers — only when present.
     if (q.genericLimit != null && q.genericRemaining != null) {