maxpool 1.8.1 → 1.8.3

package/package.json

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

@@ -3055,19 +3055,20 @@ export class AccountManager {
    *  covers the case where the old stamp was never learned. */
   noteCapacityWindowAdvance(accountName, window, prevResetAt, nextResetAt) {
     if (!prevResetAt || !nextResetAt) return;
-    // EPSILON, not `>`. An OAuth reset stamp is derived per-response as
-    // `Date.now() + delay_seconds * 1000` (parseResetHeader), so the SAME window
-    // boundary reads a little later on every response — sub-second to ~2s of jitter.
-    // A bare `nextResetAt > prevResetAt` fired the advance-close on each of those,
-    // shredding one real 5h window into 9-10 fake cycles and closing a "weekly"
-    // cycle whose endedAt was a week in the FUTURE. Measured on live state.json
-    // 2026-08-23, 12h after v1.8.0 shipped: mk@dubner.io had 9 ses cycles between
-    // 01:00 and 06:00, the shortest 0.2 minutes. A REAL advance is a whole window
-    // (>=5h); 60s separates the two by three orders of magnitude.
-    // Provider stamps (z.ai/Kimi probe) are absolute and did NOT jitter — which is
-    // how the defect localized to the OAuth path.
-    if (nextResetAt - prevResetAt < WINDOW_ADVANCE_EPSILON_MS) return;
-    this.capacity.closeCycle(accountName, window, prevResetAt, { resetAt: prevResetAt });
+    // TWO guards, both learned from live data (2026-08-23):
+    // 1. PAST stamp = a probe that answered late (its window rolled mid-request) or
+    //    vendor clock skew — honoring it closed a minutes-long "cycle" sliver. Close
+    //    at NOW instead: the window genuinely rolled, just later than the stale stamp.
+    // 2. JITTER: OAuth stamps derive per-response as Date.now()+delay*1000
+    //    (parseResetHeader), so one boundary reads ~2s later on every response; a
+    //    bare `>` comparison shredded one real 5h window into 9-10 fake cycles and
+    //    dated a "weekly" cycle a week into the future. A real advance moves a whole
+    //    window (>=5h) — the 60s epsilon separates it by three orders of magnitude.
+    //    Provider stamps (z.ai/Kimi probe) are absolute and never jitter.
+    const nowMs = Date.now();
+    const boundary = nextResetAt <= nowMs ? nowMs : nextResetAt;
+    if (boundary - prevResetAt < WINDOW_ADVANCE_EPSILON_MS) return;
+    this.capacity.closeCycle(accountName, window, boundary, { resetAt: prevResetAt });
   }
 
   /**

package/src/capacity-ledger.js

@@ -32,13 +32,24 @@ export class CapacityLedger {
     this._now = now;
     // accountName → { ses: {open?, closed: []}, wk: {open?, closed: []}, days: {utcDay: {tokens, partial}} }
     this._accounts = new Map();
+    // 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;
   }
 
   /** Restore from a serialized payload (state.json). Tolerant: unknown schemaVersion →
    *  start empty and KEEP the file (the caller preserves it); a corrupt shape → empty. */
   static fromSerialized(payload, { now = () => Date.now() } = {}) {
     const l = new CapacityLedger({ now });
-    if (!payload || payload.schemaVersion !== SCHEMA_VERSION) return l;
+    if (!payload || payload.schemaVersion !== SCHEMA_VERSION) {
+      // No history to continue: whatever window each account is in RIGHT NOW is
+      // already in progress, so the next cycle we close saw only its tail. Flag it so
+      // it is shown but never averaged (live 2026-08-23: the first GLM cycle after the
+      // v1.8.1 migration read 21,192 tokens for a 5h window it had watched 14.6 min —
+      // and with one cycle recorded, that sliver WAS every column).
+      l._joinedMidWindow = true;
+      return l;
+    }
     try {
       for (const [name, rec] of Object.entries(payload.accounts || {})) {
         const a = { ses: { open: null, closed: [] }, wk: { open: null, closed: [] }, days: {} };
@@ -91,7 +102,12 @@ export class CapacityLedger {
       // reset stamp was never learned). startedAt is the accrual time then — the cycle
       // will be flagged partial by the caller if the boot gap warrants it (B1/B2).
       if (!rec[w].open) {
-        rec[w].open = { startedAt: at, tokensSoFar: 0, lastAccrualAt: at, complete: true, disabledDuring: false };
+        const joined = this._joinedMidWindow && rec[w].closed.length === 0;
+        rec[w].open = {
+          startedAt: at, tokensSoFar: 0, lastAccrualAt: at,
+          complete: !joined, disabledDuring: false,
+          ...(joined ? { partialReason: 'joined-mid-window' } : {}),
+        };
       }
       rec[w].open.tokensSoFar += input + output;
       rec[w].open.lastAccrualAt = at;
@@ -162,6 +178,7 @@ export class CapacityLedger {
       tokens: open.tokensSoFar,
       complete: open.complete,
       disabledDuring: open.disabledDuring,
+      ...(open.partialReason ? { partialReason: open.partialReason } : {}),
       resetAt,
     });
     if (rec[window].closed.length > MAX_CYCLES_PER_WINDOW) rec[window].closed.shift();