maxpool 1.8.6 → 1.8.8

package/package.json

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

@@ -3689,6 +3689,12 @@ export class AccountManager {
       // Running version + npm update state (set at startup by maybeCheckForUpdate).
       // null until the check resolves; `current` is known even offline.
       version: this.versionInfo || null,
+      // The version whose CODE is EXECUTING. `version.current` is a package.json DISK
+      // read, so after a self-install (or on an npm-link'd checkout) it reports the
+      // newest INSTALLED build, not the running one — a post-deploy check keyed on it
+      // verifies the wrong thing (measured 2026-08-23: reported 1.8.7 while executing
+      // 1.8.6). This field is the one to assert on.
+      runningVersion: this.runningVersion || null,
       currentAccount: this.accounts[this.currentIndex]?.name,
       switchThreshold: this.switchThreshold,
       routing: {

package/src/capacity-ledger.js

@@ -40,9 +40,9 @@ const MAX_DAY_BUCKETS = 10;
 // CLAMPS a future endedAt to startedAt so the stored row itself stops violating
 // invariants after migration, not just the averages.
 function demote(c) {
-  const fixed = { ...c, complete: false, partialReason: 'pre-v3-unverified' };
-  if (fixed.endedAt > Date.now() + 60_000) fixed.endedAt = fixed.startedAt;
-  return fixed;
+  // Timestamp repair is NOT done here — the load-time pass below handles a future
+  // endedAt at every schema version, so doing it twice would be two places to fix.
+  return { ...c, complete: false, partialReason: 'pre-v3-unverified' };
 }
 
 export class CapacityLedger {
@@ -88,7 +88,19 @@ export class CapacityLedger {
         const a = { ses: { open: null, closed: [] }, wk: { open: null, closed: [] }, days: {} };
         for (const w of ['ses', 'wk']) {
           if (rec[w]?.open) a[w].open = { ...rec[w].open };
-          if (Array.isArray(rec[w]?.closed)) a[w].closed = rec[w].closed.slice(-MAX_CYCLES_PER_WINDOW);
+          if (Array.isArray(rec[w]?.closed)) {
+            // LOAD-TIME REPAIR, applied at EVERY version — not inside the v2→v3 branch,
+            // which is where it was first (wrongly) placed: a future-dated row can be
+            // written by any build whose writer had the bug, and the payload it lands in
+            // is then already current, so a version-gated repair never runs. Measured
+            // 2026-08-23: a row ending 19:54 survived the v3 migration untouched because
+            // the state was already v3. A cycle cannot end after now; such a row is
+            // corrupt, so demote it and clamp it rather than let it re-alert until evicted.
+            a[w].closed = rec[w].closed.slice(-MAX_CYCLES_PER_WINDOW).map(c =>
+              (c.endedAt > Date.now() + 60_000)
+                ? { ...c, endedAt: c.startedAt, complete: false, partialReason: 'repaired-future-endedAt' }
+                : c);
+          }
         }
         if (rec.days && typeof rec.days === 'object') {
           for (const [d, v] of Object.entries(rec.days)) a.days[d] = { ...v };

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 } from './updater.js';
+import { maybeCheckForUpdate, getCurrentVersion, markApplied, clearQuarantine, getBootVersion } from './updater.js';
 import {
   runReloadBaton,
   RELOAD_SWAPPED, RELOAD_ROLLED_BACK,
@@ -1259,6 +1259,8 @@ 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/updater.js

@@ -85,6 +85,17 @@ let _lastAttemptedTarget = null;
 /** Test-only: reset the module's version-tracking state between cases. */
 export function __resetUpdaterState() { _bootVersion = undefined; _lastAttemptedTarget = null; }
 
+/** The version whose CODE this process is EXECUTING (captured at boot, before any
+ *  self-install can rewrite the disk). Everything user-facing that says "current"
+ *  should use THIS — a disk read reports the newest INSTALLED version, which after a
+ *  background self-install (or on an npm-link'd dev checkout whose package.json moves
+ *  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 function getBootVersion() {
+  return _bootVersion ?? null;   // null only before the first maybeCheckForUpdate
+}
+
 /** Mark a version as ATTEMPTED-to-apply. The caller calls this at the moment it triggers
  *  the reload — BEFORE the reload — so a rolled-back target is quarantined (advance-only).
  *  Kept as the caller's action (not a side effect of maybeCheckForUpdate) so a caller that