maxpool 1.24.98 → 1.24.100

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "maxpool",
3
- "version": "1.24.98",
3
+ "version": "1.24.100",
4
4
  "description": "Multi-account Claude Code proxy with adaptive, rate-aware load balancing across Claude accounts",
5
5
  "type": "module",
6
6
  "main": "src/index.js",
@@ -230,6 +230,13 @@ const DEFAULT_SCHEDULER = {
230
230
  // its whole prompt cache). Edited live from the TUI routing screen (`b`); env
231
231
  // MAXPOOL_STICKY_BUSY_BUDGET_MS overrides it when set. 0 = never wait.
232
232
  stickyBusyBudgetMs: 60_000,
233
+ // REPEAT COLD-HOP HOLD (owner 2026-11-17): a long conversation that already paid one
234
+ // cold Claude re-write after a GLM turn, and is back on GLM, waits up to this long for
235
+ // a GLM row instead of paying a second cold re-write on Claude (audit 2026-11-16: 55-58
236
+ // conversations paid a >50k write more than once, 36M tokens in ~5h). Streaming only
237
+ // (the SSE heartbeat keeps the client alive); off when no GLM row can serve soon.
238
+ // 0 = never hold.
239
+ coldClaudeRepeatHoldMs: 120_000,
233
240
  concurrencyWeight: 2, // multiplies in-flight load (activeWeight+reqWeight) — dominant
234
241
  perAccountConcurrencyTarget: 3, // D: soft per-account in-flight target; past it, capPenalty bites
235
242
  capPenaltyWeight: 10, // steep penalty per unit of in-flight depth past D (throttle safety floor)
@@ -415,15 +422,19 @@ const EDGE_EFFICIENCY_FIELDS = ['bounced', 'refused', 'waited', 'waitMs', 'waitT
415
422
  const efficiencyWindowMs = (windowKey) => (windowKey === 'last1h' ? 60 * 60_000 : 15 * 60_000);
416
423
 
417
424
  function emptyEfficiency() {
418
- return { served: 0, in: 0, out: 0, cr: 0, cc: 0, moved: 0,
425
+ return { served: 0, in: 0, out: 0, cr: 0, cc: 0, moved: 0, movedSame: 0, movedCross: 0,
419
426
  movedByCause: { busy: 0, wall: 0, balance: 0, link: 0, other: 0 },
420
427
  newConversation: 0, bounced: 0, refused: 0, waited: 0, waitMs: 0, waitThenMoved: 0, e2e: [] };
421
428
  }
422
- /** Add one exported/summarized efficiency block into an accumulator (missing fields = 0). */
429
+ /** Add one exported/summarized efficiency block into an accumulator (missing fields = 0).
430
+ * Old blocks without movedSame/movedCross keep their moved total (shown as same-family
431
+ * — the cheap side, so a mixed fleet under-reports cross moves rather than inventing them). */
423
432
  function addEfficiency(acc, e) {
424
- for (const k of ['served', 'in', 'out', 'cr', 'cc', 'moved', 'newConversation', 'bounced', 'refused', 'waited', 'waitMs', 'waitThenMoved']) {
433
+ const hasSplit = Number.isFinite(Number(e.movedSame)) || Number.isFinite(Number(e.movedCross));
434
+ for (const k of ['served', 'in', 'out', 'cr', 'cc', 'moved', 'movedSame', 'movedCross', 'newConversation', 'bounced', 'refused', 'waited', 'waitMs', 'waitThenMoved']) {
425
435
  acc[k] += Number(e[k]) || 0;
426
436
  }
437
+ if (!hasSplit) acc.movedSame += Number(e.moved) || 0;
427
438
  for (const c of Object.keys(acc.movedByCause)) acc.movedByCause[c] += Number(e.movedByCause?.[c]) || 0;
428
439
  // Latency samples exist for this pool's own rows only (percentiles do not add).
429
440
  if (Array.isArray(e.e2e)) acc.e2e.push(...e.e2e);
@@ -433,14 +444,21 @@ const pct = (arr, p) => {
433
444
  const s = [...arr].sort((x, y) => x - y);
434
445
  return s[Math.min(s.length - 1, Math.floor(p * s.length))];
435
446
  };
436
- /** Derived figures: hit = cr/(cr+cc+in) (GLM has no cc → r/(r+in)); missTokens = in+cc. */
447
+ /** Derived figures: hit = cr/(cr+cc+in) (GLM has no cc → r/(r+in)); missTokens = in+cc;
448
+ * writeShare = 1.25·cc / (0.1·cr + 1.25·cc + in) — the price-weighted share of
449
+ * cost-equivalent spend the cache WRITES carry (reads 0.1x, writes 1.25x, uncached
450
+ * input 1x). hit% alone read green while writes carried 55% of Claude spend
451
+ * (2026-11-17 audit, finding 2). Cost-equivalent = quota-burn proxy (OAuth
452
+ * subscriptions), not dollars. */
437
453
  function finishEfficiency(acc, provider) {
438
454
  const prompt = acc.cr + acc.cc + acc.in;
455
+ const cost = 0.1 * acc.cr + 1.25 * acc.cc + acc.in;
439
456
  const { e2e, ...sums } = acc;
440
457
  return {
441
458
  ...sums,
442
459
  provider,
443
460
  hit: prompt > 0 ? acc.cr / prompt : null,
461
+ writeShare: cost > 0 ? (1.25 * acc.cc) / cost : null,
444
462
  missTokens: acc.in + acc.cc,
445
463
  promptTokens: prompt,
446
464
  lowVolume: acc.served < 20 || prompt < 100_000,
@@ -467,6 +485,27 @@ function lruSet(map, key, value) {
467
485
  /** An Anthropic account with its own prompt cache (allow-list: a provider or legacy
468
486
  * pool row can forward to GLM, so "not a provider" is not proof of a Claude cache). */
469
487
  const isClaudeAccount = (a) => a?.type === 'oauth' || a?.type === 'apikey';
488
+ // Providers whose prompt cache is shared by every account of that provider, so a
489
+ // conversation warm on one row is warm on all of them. Measured 2026-11-16 (Mac pool,
490
+ // 4.9h): z.ai GLM->GLM hops re-wrote ~150-2.6k tokens vs ~190k per GLM->Claude hop.
491
+ // Kimi is unmeasured, so it stays per account.
492
+ const SHARED_CACHE_PROVIDERS = new Set(['zai']);
493
+ const sharesProviderCache = (a, b) => Boolean(a && b && a.type === 'provider' && b.type === 'provider'
494
+ && a.provider === b.provider && SHARED_CACHE_PROVIDERS.has(a.provider));
495
+ // A Claude copy of a conversation that went to GLM is treated as dead after this long:
496
+ // audit 2026-11-16 — returns <5 min after the last Claude turn stayed cheap (32 hops,
497
+ // 0.5M), later ones re-wrote nearly in full (median dead-copy age 519 s; a detour pushes
498
+ // the prefix past the cache lookback, so the 1-hour copy does not survive it).
499
+ const COLD_CLAUDE_AFTER_MS = 300_000;
500
+ // How long a paid cold GLM->Claude hop marks the conversation as a repeat offender.
501
+ const COLD_HOP_MEMORY_MS = 6 * 3_600_000;
502
+ // Only conversations big enough that a re-write matters (~40k+ tokens).
503
+ const COLD_HOLD_MIN_BYTES = 150_000;
504
+ /** ROUTING FAMILY for the moved split (2026-11-17 audit, finding 4): every Claude
505
+ * account shares one cache-per-account world; each provider (zai, kimi) is its own
506
+ * family — z.ai's cache is shared across that provider's accounts, so a zai→zai hop
507
+ * re-writes ~nothing while a Claude↔provider hop re-writes the whole prompt. */
508
+ const accountFamily = (a) => (isClaudeAccount(a) ? 'claude' : String(a?.provider || 'provider'));
470
509
  const IDENTITY_WINDOW_MS = 15 * 60_000;
471
510
  const IDENTITY_MAX_SAMPLES = 4000;
472
511
  const IDENTITY_MIN_PER_SESSION = 8;
@@ -742,6 +781,7 @@ export class AccountManager {
742
781
  usage: {
743
782
  totalInputTokens: 0,
744
783
  totalOutputTokens: 0,
784
+ totalPaidTokens: 0,
745
785
  totalRequests: 0,
746
786
  lastUsed: null,
747
787
  },
@@ -783,6 +823,9 @@ export class AccountManager {
783
823
  // account only (a GLM/Kimi turn never overwrites the name; it sets `detoured`), so a
784
824
  // conversation returning from a provider detour can go home.
785
825
  this.conversationLastClaudeAccount = new Map();
826
+ // _homeKey → time of the last SERVED GLM->Claude hop that landed on a cold Claude copy
827
+ // (repeat cold-hop hold, see _coldClaudeHold).
828
+ this.conversationColdClaudeHops = new Map();
786
829
  // Conversation-identity HEALTH (owner 2026-11-08: "make sure this cannot degrade
787
830
  // silently"). Twice in one day a Claude Code request-shape detail (a moving
788
831
  // cache_control marker, then a per-request billing checksum) made every turn hash
@@ -1115,23 +1158,45 @@ export class AccountManager {
1115
1158
  this._bumpCaller(callerName, 1, 0);
1116
1159
  }
1117
1160
 
1118
- /** Attribute response TOKENS to the caller (SC22: tokens + requests). */
1161
+ /** Attribute response TOKENS to the caller (SC22: tokens + requests).
1162
+ * Counting callers are callers with no full-prompt booking (tests, legacy paths);
1163
+ * full-prompt accounting books the SAME buckets once per request via
1164
+ * noteCallerPrompt (the running-max capacity figures), so the two never mix on a
1165
+ * request — releaseAccount books `caller` only when _callerPromptBooked is unset. */
1119
1166
  countCallerTokens(callerName, tokens) {
1120
1167
  if (!callerName || !tokens) return;
1121
- this._bumpCaller(callerName, 0, tokens);
1122
- }
1123
-
1124
- _bumpCaller(callerName, req, tok) {
1168
+ this._bumpCaller(callerName, 0, tokens, 0);
1169
+ }
1170
+
1171
+ /** Book one request's FULL token figures for the caller (audit 2026-11-17, finding 3):
1172
+ * prompt = input + cache_read + cache_creation (provider-native), plus output; paid =
1173
+ * cache write + uncached input — the part that actually consumes quota/money.
1174
+ * Called ONCE per request, at the terminal release, off the request's running-max
1175
+ * capacity book (per-request max ⇒ a rerouted request books once, not per hop).
1176
+ * Legacy SSE/non-stream per-event countCallerTokens calls are dropped for requests
1177
+ * that route through this — this supersedes them (they booked message_start input
1178
+ * + output only: a 908k-token cache-write MISS booked 2 tokens). */
1179
+ noteCallerPrompt(callerName, { input = 0, cacheRead = 0, cacheCreation = 0, output = 0 }) {
1180
+ if (!callerName) return 0;
1181
+ const prompt = (input || 0) + (cacheRead || 0) + (cacheCreation || 0);
1182
+ const paid = (input || 0) + (cacheCreation || 0);
1183
+ if (!(prompt + (output || 0) > 0)) return 0;
1184
+ this._bumpCaller(callerName, 0, prompt + (output || 0), paid);
1185
+ return prompt;
1186
+ }
1187
+
1188
+ _bumpCaller(callerName, req, tok, paid = 0) {
1125
1189
  const now = new Date();
1126
1190
  const hourKey = now.toISOString().slice(0, 13); // 'YYYY-MM-DDTHH' UTC
1127
1191
  const dayKey = now.toISOString().slice(0, 10); // 'YYYY-MM-DD' UTC
1128
1192
  let st = this.callerStats.get(callerName);
1129
- if (!st) { st = { hours: {}, days: {}, total: { req: 0, tok: 0 } }; this.callerStats.set(callerName, st); }
1193
+ if (!st) { st = { hours: {}, days: {}, total: { req: 0, tok: 0, paid: 0 } }; this.callerStats.set(callerName, st); }
1130
1194
  for (const [bucket, key] of [[st.hours, hourKey], [st.days, dayKey]]) {
1131
- bucket[key] = bucket[key] || { req: 0, tok: 0 };
1132
- bucket[key].req += req; bucket[key].tok += tok;
1195
+ bucket[key] = bucket[key] || { req: 0, tok: 0, paid: 0 };
1196
+ bucket[key].req += req; bucket[key].tok += tok; bucket[key].paid += paid;
1133
1197
  }
1134
1198
  st.total.req += req; st.total.tok += tok;
1199
+ st.total.paid = (st.total.paid || 0) + paid;
1135
1200
  this._pruneCallerBuckets(st);
1136
1201
  }
1137
1202
 
@@ -1174,22 +1239,22 @@ export class AccountManager {
1174
1239
  const now = Date.now();
1175
1240
  const out = new Map();
1176
1241
  const win = (st, ms, hourly) => {
1177
- let req = 0, tok = 0;
1242
+ let req = 0, tok = 0, paid = 0;
1178
1243
  const src = hourly ? st.hours : st.days;
1179
1244
  for (const [k, v] of Object.entries(src)) {
1180
1245
  const t = Date.parse(hourly ? k + ':00:00Z' : k + 'T00:00:00Z');
1181
- if (t <= now && now - t < ms) { req += v.req; tok += v.tok; }
1246
+ if (t <= now && now - t < ms) { req += v.req; tok += v.tok; paid += v.paid || 0; }
1182
1247
  }
1183
- return { req, tok };
1248
+ return { req, tok, paid };
1184
1249
  };
1185
1250
  const winPrior = (st, fromMs, toMs) => {
1186
- let req = 0, tok = 0;
1251
+ let req = 0, tok = 0, paid = 0;
1187
1252
  for (const [k, v] of Object.entries(st.days)) {
1188
1253
  const t = Date.parse(k + 'T00:00:00Z');
1189
1254
  const age = now - t;
1190
- if (t <= now && age >= fromMs && age < toMs) { req += v.req; tok += v.tok; }
1255
+ if (t <= now && age >= fromMs && age < toMs) { req += v.req; tok += v.tok; paid += v.paid || 0; }
1191
1256
  }
1192
- return { req, tok };
1257
+ return { req, tok, paid };
1193
1258
  };
1194
1259
  for (const [name, st] of this.callerStats) {
1195
1260
  out.set(name, {
@@ -1232,6 +1297,13 @@ export class AccountManager {
1232
1297
  console.log(`[Maxpool] return-home lease throttled (${outcome.status} ${outcome.error || '-'}${scope}, ${lease.returnedHomeSwitched ? 'switched' : 'natural'}): ${account.name} depth=${depthBefore}`);
1233
1298
  }
1234
1299
 
1300
+ // Per-account + per-caller token totals, booked ONCE per request at its terminal
1301
+ // release off the running-max capacity book (finding 3, 2026-11-17): a stream that
1302
+ // died mid-flight still delivered its tokens, so this runs for every non-neutral
1303
+ // outcome, success or not. A request with no capacity figures (a refusal, a bounce)
1304
+ // books nothing.
1305
+ if (!outcome.neutral) this._bookRequestTokens(lease, account, outcome);
1306
+
1235
1307
  if (lease.upstreamThrottleProbe) {
1236
1308
  if (outcome.success) {
1237
1309
  this.clearUpstreamThrottle('successful recovery probe');
@@ -1253,7 +1325,19 @@ export class AccountManager {
1253
1325
  // A pinned refusal (busy / unavailable / throttled cloud row) never reached the
1254
1326
  // client: one BOUNCED load event, no failure counters, no streak, no error text.
1255
1327
  if (outcome.bounced) {
1256
- this._recordLoadEvent(account, lease, { ...outcome, success: false, bounced: true });
1328
+ // ONE bounced request per row, however many queue releases it refuses on: a
1329
+ // request held in the queue re-asks the same full row every release, and counting
1330
+ // each refusal read "bounced 69%" when far fewer requests were ever refused
1331
+ // (2026-11-16). The event is still recorded (lease accounting); repeats are flagged
1332
+ // and left out of every bounced/refused count.
1333
+ const ri = lease.requestInfo;
1334
+ let repeat = false;
1335
+ if (ri) {
1336
+ ri._bouncedOn ||= new Set();
1337
+ repeat = ri._bouncedOn.has(account.name);
1338
+ ri._bouncedOn.add(account.name);
1339
+ }
1340
+ this._recordLoadEvent(account, lease, { ...outcome, success: false, bounced: true, repeatBounce: repeat });
1257
1341
  return;
1258
1342
  }
1259
1343
 
@@ -1282,7 +1366,7 @@ export class AccountManager {
1282
1366
  }
1283
1367
  // Backstop for callers that never saw a first byte (unit callers): a 2xx served
1284
1368
  // the conversation. Idempotent — the first-byte note already ran on the real paths.
1285
- if (lease.requestInfo && !(outcome.status >= 300)) this.noteConversationServed(lease.requestInfo, account);
1369
+ if (lease.requestInfo && !(outcome.status >= 300)) { this.stampMovedFrom(lease.requestInfo); this.noteConversationServed(lease.requestInfo, account); }
1286
1370
  // Efficiency fields derived from the served request; a field the caller passed
1287
1371
  // explicitly on the outcome wins.
1288
1372
  const tel = this._servedTelemetry(lease.requestInfo, account);
@@ -1320,8 +1404,20 @@ export class AccountManager {
1320
1404
  status: outcome.status || null,
1321
1405
  // Efficiency telemetry (2026-11-15) — optional, read by _efficiencySummary only.
1322
1406
  bounced: Boolean(outcome.bounced),
1407
+ repeatBounce: Boolean(outcome.repeatBounce),
1323
1408
  usage: outcome.usage || null,
1324
1409
  moved: Boolean(outcome.moved),
1410
+ // Moved split by routing family (finding 4): same = within one family (a zai→zai
1411
+ // hop, near-free — z.ai's cache is shared across its accounts); cross = the
1412
+ // prompt re-wrote wholesale on the new family (e.g. Claude↔provider). A caller
1413
+ // passing `moved` without a family gets it classified HERE (off the lease's
1414
+ // request when it exists, else off the serving account alone).
1415
+ movedSame: Boolean(outcome.movedSame)
1416
+ || (Boolean(outcome.moved) && outcome.movedCross !== true
1417
+ && !this._outcomeMoveCross(outcome, lease, account)),
1418
+ movedCross: Boolean(outcome.movedCross)
1419
+ || (Boolean(outcome.moved) && outcome.movedSame !== true
1420
+ && this._outcomeMoveCross(outcome, lease, account)),
1325
1421
  newConversation: Boolean(outcome.newConversation),
1326
1422
  moveCause: outcome.moveCause || null,
1327
1423
  busyWaitMs: outcome.busyWaitMs || 0,
@@ -1333,6 +1429,58 @@ export class AccountManager {
1333
1429
  this._pruneLoadEvents(account, now);
1334
1430
  }
1335
1431
 
1432
+ /** Book one request's FULL token figures (input + cache read + cache write, provider-
1433
+ * native, plus output) on the account's usage and the named caller — once per
1434
+ * request (`_tokensBooked`), at the terminal release (finding 3, 2026-11-17: the
1435
+ * old per-event booking counted message_start input + output only, so a 908k-token
1436
+ * cache-write miss booked 2 tokens, and GLM input — which rides message_delta —
1437
+ * never landed). Unit callers that pass `outcome.usage` instead of filling the
1438
+ * request's capacity book are honoured when the request carries no figures. */
1439
+ _bookRequestTokens(lease, account, outcome) {
1440
+ const ri = lease.requestInfo;
1441
+ if (ri?.isCountTokens || ri?._tokensBooked) return;
1442
+ // A cloud MIRROR row is served by the linked pool, which books its own tokens (the
1443
+ // People page counts each request once, at the pool that served it); the edge only
1444
+ // taps the usage for efficiency figures.
1445
+ if (account.remote) return;
1446
+ const has = ri && (ri._capacityInput != null || ri._capacityCacheRead != null
1447
+ || ri._capacityCacheCreation != null || ri._capacityOutput != null);
1448
+ const u = has
1449
+ ? { input: ri._capacityInput || 0, cacheRead: ri._capacityCacheRead || 0, cacheCreation: ri._capacityCacheCreation || 0, output: ri._capacityOutput || 0 }
1450
+ : (outcome.success && outcome.usage
1451
+ ? { input: outcome.usage.in || 0, cacheRead: outcome.usage.cr || 0, cacheCreation: outcome.usage.cc || 0, output: outcome.usage.out || 0 }
1452
+ : null);
1453
+ if (!u || !(u.input + u.cacheRead + u.cacheCreation + u.output > 0)) return;
1454
+ if (ri) ri._tokensBooked = true;
1455
+ const idx = Number.isInteger(account.index) ? account.index : this.accounts.indexOf(account);
1456
+ this.updateUsage(idx, { input: u.input, cacheRead: u.cacheRead, cacheCreation: u.cacheCreation }, u.output);
1457
+ this.noteCallerPrompt(ri?.caller ?? outcome.caller, u);
1458
+ }
1459
+
1460
+ /** Classify an outcome-passed move (no family on the outcome): cross unless the
1461
+ * request's remembered previous holder is a same-family account. No previous holder
1462
+ * known (no request identity, unit callers) → a Claude serve is cross (unknown prev
1463
+ * could have re-written the whole prompt — over-report the costly side), a provider
1464
+ * serve same (its family's shared cache makes the rewrite assumption weak). */
1465
+ _outcomeMoveCross(outcome, lease, account) {
1466
+ const ri = lease?.requestInfo;
1467
+ const fromName = ri ? (ri._servedMovedFrom ?? ri._prevServedName ?? null) : null;
1468
+ const fromAccount = fromName != null ? this.accounts.find(a => a.name === fromName) : null;
1469
+ if (fromAccount == null) return isClaudeAccount(account);
1470
+ return accountFamily(fromAccount) !== accountFamily(account);
1471
+ }
1472
+
1473
+ /** Remember which account served this conversation's PREVIOUS turn, on the request,
1474
+ * BEFORE noteConversationServed overwrites the memory (finding 4: the move's family
1475
+ * split needs the previous holder). Idempotent per request; a request that already
1476
+ * carries `_servedMovedFrom` (set by noteConversationServed itself) is left alone.
1477
+ * Never touches the conversation maps — display/telemetry only. */
1478
+ stampMovedFrom(requestInfo) {
1479
+ if (!requestInfo || requestInfo._notedServed || requestInfo.isCountTokens || '_prevServedName' in requestInfo) return;
1480
+ const key = this._affinityKey(requestInfo);
1481
+ requestInfo._prevServedName = key ? (this.conversationLastAccount.get(key) ?? null) : null;
1482
+ }
1483
+
1336
1484
  /** Efficiency fields of a SERVED event, read off the request that was served. */
1337
1485
  _servedTelemetry(ri, account) {
1338
1486
  if (!ri) return {};
@@ -1342,6 +1490,19 @@ export class AccountManager {
1342
1490
  // add a latency sample that starts AFTER the edge's wait. Served + tokens stay here.
1343
1491
  const pinned = ri.pinAccount != null;
1344
1492
  const moved = !pinned && Boolean(ri._servedMoved) && ri._notedServed === account.name;
1493
+ // Family split of the move (finding 4): prev family read off the request — the
1494
+ // other engineer's noteConversationServed will soon stamp `ri._servedMovedFrom`;
1495
+ // until then the name is derived here (same key, same map, no edit there).
1496
+ let movedSame = null, movedCross = null;
1497
+ if (moved) {
1498
+ const fromName = ri._servedMovedFrom ?? ri._prevServedName ?? null;
1499
+ const fromAccount = fromName != null ? this.accounts.find(a => a.name === fromName) : null;
1500
+ // No prev row found (renamed/offline) → CROSS: unknown prev family could have
1501
+ // re-written the whole prompt, and over-reporting the costly side is the honest
1502
+ // failure direction for an alarm.
1503
+ const cross = fromAccount == null || accountFamily(fromAccount) !== accountFamily(account);
1504
+ if (cross) movedCross = true; else movedSame = true;
1505
+ }
1345
1506
  return {
1346
1507
  countTokens: Boolean(ri.isCountTokens),
1347
1508
  usage: ri.isCountTokens ? null : {
@@ -1349,6 +1510,7 @@ export class AccountManager {
1349
1510
  cr: ri._capacityCacheRead || 0, cc: ri._capacityCacheCreation || 0,
1350
1511
  },
1351
1512
  moved,
1513
+ movedSame, movedCross,
1352
1514
  moveCause: moved ? (ri._moveCause || (ri._hop > 0 ? 'other' : 'balance')) : null,
1353
1515
  newConversation: !pinned && Boolean(ri._newConversation) && ri._notedServed === account.name,
1354
1516
 
@@ -1370,6 +1532,7 @@ export class AccountManager {
1370
1532
  for (const e of account.loadEvents || []) {
1371
1533
  if (e.at < since || e.countTokens) continue;
1372
1534
  if (e.bounced) {
1535
+ if (e.repeatBounce) continue;
1373
1536
  out.bounced++;
1374
1537
  if (e.refusal && e.refusal !== 'busy') out.refused++;
1375
1538
  continue;
@@ -1379,6 +1542,8 @@ export class AccountManager {
1379
1542
  if (e.usage) { out.in += e.usage.in; out.out += e.usage.out; out.cr += e.usage.cr; out.cc += e.usage.cc; }
1380
1543
  if (e.moved) {
1381
1544
  out.moved++;
1545
+ if (e.movedCross) out.movedCross++;
1546
+ else out.movedSame++; // legacy events (no split) default to the cheap side
1382
1547
  const c = Object.hasOwn(out.movedByCause, e.moveCause) ? e.moveCause : 'other';
1383
1548
  out.movedByCause[c]++;
1384
1549
  if (e.busyWaitMs > 0) out.waitThenMoved++;
@@ -1406,6 +1571,11 @@ export class AccountManager {
1406
1571
  if (!exp) return edge;
1407
1572
  const acc = emptyEfficiency();
1408
1573
  for (const k of ['served', 'in', 'out', 'cr', 'cc']) acc[k] = Number(exp[k]) || 0;
1574
+ // Family split (finding 4): an export that carries it adds both halves; an older
1575
+ // export keeps its moved total on the cheap side (same) — never invents cross moves.
1576
+ const expSplit = Number.isFinite(Number(exp.movedSame)) || Number.isFinite(Number(exp.movedCross));
1577
+ acc.movedSame = (expSplit ? Number(exp.movedSame) || 0 : Number(exp.moved) || 0) + edge.movedSame;
1578
+ acc.movedCross = (expSplit ? Number(exp.movedCross) || 0 : 0) + edge.movedCross;
1409
1579
  for (const k of EDGE_EFFICIENCY_FIELDS) acc[k] = (Number(exp[k]) || 0) + edge[k];
1410
1580
  for (const c of Object.keys(acc.movedByCause)) {
1411
1581
  acc.movedByCause[c] = (Number(exp.movedByCause?.[c]) || 0) + edge.movedByCause[c];
@@ -1475,7 +1645,7 @@ export class AccountManager {
1475
1645
  const all = (account.loadEvents || []).filter(e => e.at >= since);
1476
1646
  // A BOUNCE (pinned refusal, 2026-11-15) never served anything: out of every
1477
1647
  // denominator — requests, weight (spread share), avgMs — and out of `failed`.
1478
- const bounced = all.filter(e => e.bounced).length;
1648
+ const bounced = all.filter(e => e.bounced && !e.repeatBounce).length;
1479
1649
  const events = all.filter(e => !e.bounced);
1480
1650
  const requests = events.length;
1481
1651
  // "failed" is what the operator reads as the ACCOUNT misbehaving; a link fault is
@@ -1855,7 +2025,12 @@ export class AccountManager {
1855
2025
  // Fairness stays: the skip only fires after a real wait, and the head's own
1856
2026
  // window (queueAndRetry's ceiling) still bounds IT.
1857
2027
  const HEAD_SKIP_MS = 60_000;
1858
- if (this.queueState.waiting[0]?.id === ticket.id) {
2028
+ // A cold-held ticket (waiting for a GLM row only) is no head for anyone else to
2029
+ // queue behind (red-team 2026-11-17 f1); it keeps its own FIFO place for GLM rows.
2030
+ const head = this._coldHeldTicket(ticket)
2031
+ ? this.queueState.waiting[0]
2032
+ : this.queueState.waiting.find(t => !this._coldHeldTicket(t));
2033
+ if (!head || head.id === ticket.id) {
1859
2034
  // fast path: unchanged FIFO
1860
2035
  } else {
1861
2036
  const waited = Date.now() - (ticket.queuedAt ?? Date.now());
@@ -3010,7 +3185,11 @@ export class AccountManager {
3010
3185
  // conversation leaves its last account (bounded by moves, not by requests).
3011
3186
  const ckey = this._affinityKey(requestInfo);
3012
3187
  const lastName = ckey ? this.conversationLastAccount.get(ckey) : null;
3013
- if (lastName && lastName !== best.name) {
3188
+ const moveKey = lastName ? `${lastName}>${best.name}` : null;
3189
+ if (lastName && lastName !== best.name && requestInfo?._movedLogged !== moveKey) {
3190
+ // One line per request per move: a queued request re-routes on every release and
3191
+ // used to log the same move each time (29× in 27 min for one request, 2026-11-16).
3192
+ requestInfo._movedLogged = moveKey;
3014
3193
  // why= explains why the conversation LEFT its last account — measured against
3015
3194
  // the loop's own pick, before any return-home switch.
3016
3195
  let why = 'unknown';
@@ -3306,16 +3485,95 @@ export class AccountManager {
3306
3485
  // Cloud mirrors egress from the cloud's own IP — this machine's upstream throttle
3307
3486
  // and local queue fairness don't describe them.
3308
3487
  const providerLike = account.type === 'provider' || Boolean(account.remote);
3488
+ // A request parked by the repeat cold-hop hold (red-team 2026-11-17 f1) still
3489
+ // registers a queue ticket like any queued request, but its ticket must not count
3490
+ // as a WAITER for anyone else: a queued waiter makes local Claude rows refuse every
3491
+ // NEW request without a ticket, and a ticket-holder queues behind it — so one held
3492
+ // conversation stalled unrelated traffic on an idle Claude row for up to
3493
+ // HEAD_SKIP_MS (60 s). Held tickets are therefore skipped by the fairness gate
3494
+ // below and by the head pick in canAdmitQueuedRequest (_coldHeldTicket).
3495
+ const coldHeld = isClaudeAccount(account) && this._coldClaudeHold(requestInfo);
3309
3496
  if (
3310
3497
  !providerLike
3311
- && this.queueState.waiting.length
3498
+ && this.queueState.waiting.some(t => !this._coldHeldTicket(t))
3312
3499
  && !requestInfo.queueTicket
3313
3500
  && !requestInfo.queueAdmitted
3314
3501
  ) return false;
3315
3502
  if (!providerLike && this._isUpstreamThrottleBlocking()) return false;
3503
+ if (coldHeld) return false;
3316
3504
  return true;
3317
3505
  }
3318
3506
 
3507
+ /**
3508
+ * REPEAT COLD-HOP HOLD (owner 2026-11-17, "yes"): true while Claude rows must NOT take
3509
+ * this request, so it waits (queue + SSE heartbeat) for a GLM row instead of paying a
3510
+ * second cold Claude re-write. All of: the knob is on; a big streaming /v1/messages
3511
+ * turn; the conversation is warm on z.ai (served there last); it already paid a cold
3512
+ * GLM->Claude hop in the last COLD_HOP_MEMORY_MS; its Claude copy is dead; some z.ai
3513
+ * row can serve before the cap ends; and the cap (from the first time the hold
3514
+ * engaged for this request) has not run out.
3515
+ */
3516
+ _coldClaudeHold(requestInfo = {}, now = Date.now()) {
3517
+ const capMs = Number(this.scheduler.coldClaudeRepeatHoldMs);
3518
+ if (!(capMs > 0) || requestInfo.isCountTokens || !requestInfo.stream) return false;
3519
+ if ((requestInfo.bodyBytes || 0) < COLD_HOLD_MIN_BYTES) return false;
3520
+ const homeKey = this._homeKey(requestInfo);
3521
+ const key = this._affinityKey(requestInfo);
3522
+ if (!homeKey || !key) return false;
3523
+ const last = this.accounts.find(a => a.name === this.conversationLastAccount.get(key));
3524
+ // A non-z.ai holder (Claude, Kimi) ends at _sharedCacheRowSoon: no row shares its cache.
3525
+ if (!last) return false;
3526
+ const hopAt = this.conversationColdClaudeHops.get(homeKey);
3527
+ if (hopAt == null || now - hopAt > COLD_HOP_MEMORY_MS) return false;
3528
+ const home = this.conversationLastClaudeAccount.get(homeKey);
3529
+ if (home && now - home.at <= COLD_CLAUDE_AFTER_MS) return false;
3530
+ const started = requestInfo._coldHoldStartedAt ?? now;
3531
+ const until = started + capMs;
3532
+ if (now >= until) return false;
3533
+ if (!this._sharedCacheRowSoon(last, requestInfo, until, now)) return false;
3534
+ if (requestInfo._coldHoldStartedAt == null) {
3535
+ requestInfo._coldHoldStartedAt = now;
3536
+ console.log(`[Maxpool] holding a ${requestInfo.bodyBytes}B conversation for GLM up to ${Math.round(capMs / 1000)}s: it already paid one cold Claude re-write and its Claude copy is ${home ? `${Math.round((now - home.at) / 1000)}s old` : 'absent'}`);
3537
+ }
3538
+ return true;
3539
+ }
3540
+
3541
+ /** Is this queue ticket's request inside a LIVE repeat cold-hop hold? The stamp
3542
+ * alone is not enough (red-team r2): when the hold releases early — every GLM row
3543
+ * went dead mid-wait — the ticket becomes an ordinary fair waiter again at once,
3544
+ * instead of staying invisible to the head pick until the cap expires. */
3545
+ _coldHeldTicket(t, now = Date.now()) {
3546
+ const started = t?.requestInfo?._coldHoldStartedAt;
3547
+ if (started == null) return false;
3548
+ const capMs = Number(this.scheduler.coldClaudeRepeatHoldMs);
3549
+ return capMs > 0 && now < started + capMs && this._coldClaudeHold(t.requestInfo, now);
3550
+ }
3551
+
3552
+ /** Could a z.ai row sharing `holder`'s cache serve this request before `until`?
3553
+ * (Enabled, eligible, not weekly-out, not benched or 5h-walled past `until`.) */
3554
+ _sharedCacheRowSoon(holder, requestInfo, until, now) {
3555
+ const profile = requestInfo.profile || 'claude';
3556
+ return this.accounts.some(a => {
3557
+ if (a.enabled === false || !sharesProviderCache(holder, a)) return false;
3558
+ // Permanent outs (red-team 2026-11-17 f2): auth-dead, subscription gone,
3559
+ // terminal statuses, a dead cloud mirror — no wait can end in a serve, so the
3560
+ // hold must release at once instead of idling to the cap.
3561
+ if (a.status === 'error' || a.status === 'exhausted' || a.subscriptionGone) return false;
3562
+ if (a.remote && (a.refreshDead || a.status === 'error')) return false;
3563
+ if (!this._matchesRequest(a, profile, requestInfo)) return false;
3564
+ if ((a.rateLimitedUntil || 0) > until && a.status === 'throttled') return false;
3565
+ if ((a.cooldownUntil || 0) > until) return false;
3566
+ if ((a.provisionalUpstreamUntil || 0) > until) return false;
3567
+ // Peak-hour hard bar (red-team r2 f3): peakCap 0 = never during the window, so
3568
+ // waiting cannot end in a serve. Judged at the END of the cap: a window that
3569
+ // closes before then still counts as soon.
3570
+ if (this._peakHardBarred(a, until)) return false;
3571
+ if (this._isSessionQuotaUnavailable(a, now)) return false;
3572
+ const w = this._weeklyRawState(a, now);
3573
+ return w !== 'exhausted' && w !== 'capped';
3574
+ });
3575
+ }
3576
+
3319
3577
  _crossProviderFallbackPolicy() {
3320
3578
  const p = this.scheduler.crossProviderFallbackPolicy;
3321
3579
  return (p === 'never' || p === 'always') ? p : 'when-exhausted';
@@ -4096,23 +4354,32 @@ export class AccountManager {
4096
4354
  * there but costs nothing either, and one rule is simpler to reason about.
4097
4355
  * Applies in every scored mode (balance, prefer-*); never in sticky (see below).
4098
4356
  */
4099
- _noteConversationAccount(requestInfo, account) {
4100
- // conversationLastAccount is written at the first real upstream byte
4101
- // (noteConversationServed), never here: a refused/failed hop must not re-point the
4102
- // conversation (2026-11-15).
4103
- // Home memory: ONE key per conversation, independent of identity health, so the
4104
- // degraded <-> ok flip of _affinityKey can neither hide a home nor lend it to the
4105
- // sibling conversations that share the terminal key. The entry carries its own
4106
- // detour state: a Claude turn clears it, a provider turn sets it (same name and
4107
- // `at`, only the LRU position moves so other traffic cannot evict a long detour).
4357
+ _noteConversationAccount(_requestInfo, _account) {
4358
+ // Both conversation memories are written at the first real upstream byte
4359
+ // (noteConversationServed), never here: a refused/failed attempt must not re-point
4360
+ // the conversation (last account: 2026-11-15; Claude home + detour flag: 2026-11-17).
4361
+ }
4362
+
4363
+ /** Home memory: ONE key per conversation, independent of identity health, so the
4364
+ * degraded <-> ok flip of _affinityKey can neither hide a home nor lend it to the
4365
+ * sibling conversations that share the terminal key. The entry carries its own detour
4366
+ * state: a served Claude turn clears it, a served provider turn sets it (same name and
4367
+ * `at`, only the LRU position moves so other traffic cannot evict a long detour).
4368
+ * Also remembers a served GLM->Claude hop that landed on a dead Claude copy. */
4369
+ _noteHomeServed(requestInfo, account, prevName) {
4108
4370
  const homeKey = this._homeKey(requestInfo);
4109
4371
  if (!homeKey) return;
4372
+ const now = requestInfo.now ?? Date.now();
4373
+ const home = this.conversationLastClaudeAccount.get(homeKey);
4110
4374
  if (isClaudeAccount(account)) {
4111
- lruSet(this.conversationLastClaudeAccount, homeKey,
4112
- { name: account.name, at: requestInfo.now ?? Date.now(), detoured: false });
4113
- } else {
4114
- const home = this.conversationLastClaudeAccount.get(homeKey);
4115
- if (home) lruSet(this.conversationLastClaudeAccount, homeKey, { ...home, detoured: true });
4375
+ const prev = prevName != null ? this.accounts.find(a => a.name === prevName) : null;
4376
+ const copyDead = !home || home.name !== account.name || now - home.at > COLD_CLAUDE_AFTER_MS;
4377
+ if (prev && SHARED_CACHE_PROVIDERS.has(prev.provider) && prev.type === 'provider' && copyDead) {
4378
+ lruSet(this.conversationColdClaudeHops, homeKey, now);
4379
+ }
4380
+ lruSet(this.conversationLastClaudeAccount, homeKey, { name: account.name, at: now, detoured: false });
4381
+ } else if (home) {
4382
+ lruSet(this.conversationLastClaudeAccount, homeKey, { ...home, detoured: true });
4116
4383
  }
4117
4384
  }
4118
4385
 
@@ -4126,10 +4393,12 @@ export class AccountManager {
4126
4393
  requestInfo._notedServed = account.name;
4127
4394
  requestInfo._servedAt = Date.now();
4128
4395
  const key = this._affinityKey(requestInfo);
4396
+ const prev = key ? this.conversationLastAccount.get(key) : undefined;
4397
+ this._noteHomeServed(requestInfo, account, prev);
4129
4398
  if (!key) return;
4130
- const prev = this.conversationLastAccount.get(key);
4131
4399
  requestInfo._newConversation = prev == null;
4132
4400
  requestInfo._servedMoved = prev != null && prev !== account.name;
4401
+ requestInfo._servedMovedFrom = requestInfo._servedMoved ? prev : null;
4133
4402
  lruSet(this.conversationLastAccount, key, account.name);
4134
4403
  lruSet(this.conversationLastServedAt, key, Date.now());
4135
4404
  }
@@ -4266,7 +4535,12 @@ export class AccountManager {
4266
4535
  if (base <= 0 || (this.scheduler.routingMode === 'sticky' && !retrySame)) return 0;
4267
4536
  if (!retrySame) {
4268
4537
  const key = this._affinityKey(requestInfo);
4269
- if (!key || (holderName ?? this.conversationLastAccount.get(key)) !== account.name) return 0;
4538
+ const holder = key ? (holderName ?? this.conversationLastAccount.get(key)) : null;
4539
+ // FAMILY AFFINITY (owner 2026-11-17): a z.ai holder makes every z.ai row warm (the
4540
+ // cache is shared), so when the holder is excluded/busy a GLM sibling — not a cold
4541
+ // Claude row — inherits the hold. Same bonus, release gates and anti-dogpile cap.
4542
+ if (!holder || (holder !== account.name
4543
+ && !sharesProviderCache(this.accounts.find(a => a.name === holder), account))) return 0;
4270
4544
  }
4271
4545
  // Scale with the CONVERSATION'S SIZE too: losing the cache costs the prefix a
4272
4546
  // hop re-writes, and requestInfo.bodyBytes ≈ prefix + this turn. Checkpoint
@@ -5576,12 +5850,24 @@ export class AccountManager {
5576
5850
 
5577
5851
  /**
5578
5852
  * Update cumulative token usage from response body data.
5853
+ * `inputTokens` may be a number (legacy: uncached input only) or a usage object
5854
+ * {input, cacheRead, cacheCreation} — the object books FULL prompt tokens
5855
+ * (input + cache read + cache write, provider-native; finding 3, 2026-11-17), and
5856
+ * paid (write + uncached) into totalPaidTokens beside it.
5579
5857
  */
5580
5858
  updateUsage(accountIndex, inputTokens, outputTokens) {
5581
5859
  const account = this.accounts[accountIndex];
5582
5860
  if (!account) return;
5583
- if (inputTokens) account.usage.totalInputTokens += inputTokens;
5861
+ let input = inputTokens, paid = null;
5862
+ if (inputTokens && typeof inputTokens === 'object') {
5863
+ input = (inputTokens.input || 0) + (inputTokens.cacheRead || 0) + (inputTokens.cacheCreation || 0);
5864
+ paid = (inputTokens.input || 0) + (inputTokens.cacheCreation || 0);
5865
+ }
5866
+ if (input) account.usage.totalInputTokens += input;
5584
5867
  if (outputTokens) account.usage.totalOutputTokens += outputTokens;
5868
+ // Legacy two-arg calls carry uncached input → it counts as paid too.
5869
+ const paidAdd = paid != null ? paid : (typeof inputTokens === 'number' ? inputTokens : 0);
5870
+ if (paidAdd) account.usage.totalPaidTokens = (account.usage.totalPaidTokens || 0) + paidAdd;
5585
5871
  }
5586
5872
 
5587
5873
  /**
@@ -5968,7 +6254,7 @@ export class AccountManager {
5968
6254
  // Unknown quota until the first response — probe it like startup accounts.
5969
6255
  probing: true,
5970
6256
  quota: emptyQuota(),
5971
- usage: { totalInputTokens: 0, totalOutputTokens: 0, totalRequests: 0, lastUsed: null },
6257
+ usage: { totalInputTokens: 0, totalOutputTokens: 0, totalPaidTokens: 0, totalRequests: 0, lastUsed: null },
5972
6258
  inFlight: 0,
5973
6259
  activeWeight: 0,
5974
6260
  completedRequests: 0,
@@ -385,7 +385,10 @@ export class CapacityLedger {
385
385
  accrue(name, { input, output, cacheRead = 0, cacheCreation = 0, model = null }, at = this._now(), windows = ['ses', 'wk']) {
386
386
  // TOKEN DEFINITION (v5, owner 2026-11-06): every token the provider processed =
387
387
  // input + cache_read + cache_creation + output, identical for Anthropic and z.ai so
388
- // both sit on one axis. (The cache counters are also kept separately per cycle.)
388
+ // both sit on one axis. NOTE (audit 2026-11-17): "one axis" means
389
+ // one DEFINITION — counts stay provider-native (GLM's tokenizer reads ~0.6x Anthropic's
390
+ // for the same prompt) and a 0.1x cache read weighs the same as a 1.25x write; the
391
+ // Capacity page labels the axis "processed tokens (provider-native)". (The cache counters are also kept separately per cycle.)
389
392
  const cr = cacheRead > 0 ? cacheRead : 0, cc = cacheCreation > 0 ? cacheCreation : 0;
390
393
  const total = (input > 0 ? input : 0) + (output > 0 ? output : 0) + cr + cc;
391
394
  if (!(total > 0)) return;
package/src/index.js CHANGED
@@ -2275,7 +2275,11 @@ async function statusCommand() {
2275
2275
  console.log(` Tokens: ${tok} used Requests: ${req} used`);
2276
2276
  }
2277
2277
 
2278
- console.log(` Total: ${acct.usage.totalInputTokens + acct.usage.totalOutputTokens} tokens, ${acct.usage.totalRequests} requests`);
2278
+ // Full prompt (input + cache read + cache write) + output, provider-native; paid =
2279
+ // cache write + uncached input (audit 2026-11-17, finding 3). Older servers book
2280
+ // uncached input only and carry no paid figure — then Total reads as before.
2281
+ const paidTok = acct.usage.totalPaidTokens;
2282
+ console.log(` Total: ${acct.usage.totalInputTokens + acct.usage.totalOutputTokens} tokens${paidTok != null ? ` (paid ${paidTok})` : ''}, ${acct.usage.totalRequests} requests`);
2279
2283
  if (acct.rateLimitedUntil) console.log(` Throttled until: ${acct.rateLimitedUntil}`);
2280
2284
  console.log('');
2281
2285
  }
@@ -2806,10 +2810,10 @@ function efficiencyLines(data, key = 'last15m') {
2806
2810
  const s = (ms) => (ms == null ? '—' : `${(ms / 1000).toFixed(1)}s`);
2807
2811
  return [
2808
2812
  `Efficiency (${key === 'last1h' ? '1h' : '15m'}):`,
2809
- ` Cache: Claude ${pctOrDash(claude.hit)} (miss ${(claude.missTokens / 1e6).toFixed(1)}M tok) · GLM ${pctOrDash(glm.hit)} (miss ${(glm.missTokens / 1e6).toFixed(1)}M tok)`,
2810
- ` Moves: ${served ? `${Math.round(sum('moved') * 100 / served)}/100 served` : '—'} (busy ${n(cause('busy'))} · balance ${n(cause('balance'))} · wall ${n(cause('wall'))} · link ${n(cause('link'))} · other ${n(cause('other'))})`,
2813
+ ` Cache: Claude ${pctOrDash(claude.hit)} (miss ${(claude.missTokens / 1e6).toFixed(1)}M tok${claude.writeShare != null ? ` · writes ${pctOrDash(claude.writeShare)} of cost` : ''}) · GLM ${pctOrDash(glm.hit)} (miss ${(glm.missTokens / 1e6).toFixed(1)}M tok)`,
2814
+ ` Moves: ${served ? `${Math.round(sum('moved') * 100 / served)}/100 served` : '—'} (cross-family ${n(sum('movedCross'))} · same-family ${n(sum('movedSame'))} · busy ${n(cause('busy'))} · balance ${n(cause('balance'))} · wall ${n(cause('wall'))} · link ${n(cause('link'))} · other ${n(cause('other'))})`,
2811
2815
  ` Bounced: ${n(sum('bounced'))} (refused ${n(sum('refused'))}) · failed ${failed} · link drops ${linkDrops}`,
2812
- ` Waited: ${n(sum('waited'))}${sum('waited') ? ` (avg ${s(sum('waitMs') / sum('waited'))})` : ''} · waited then moved ${n(sum('waitThenMoved'))}`,
2816
+ ` Busy waits: ${n(sum('waited'))}${sum('waited') ? ` (avg ${s(sum('waitMs') / sum('waited'))})` : ''} · waited then moved ${n(sum('waitThenMoved'))} (busy-bounce waits only; queue holds show in first-byte p95)`,
2813
2817
  ` Client errors: ${co ? `${co.poolErrors + co.requestErrors} of ${co.total} (pool ${co.poolErrors} · request ${co.requestErrors})` : '—'}`,
2814
2818
  ` First byte: p50 ${s(overall.e2eP50)} · p95 ${s(overall.e2eP95)} (this pool's clients, waits included)`,
2815
2819
  '',
package/src/server.js CHANGED
@@ -1421,6 +1421,7 @@ async function forwardRequest(
1421
1421
  if (upRes.status < 300) {
1422
1422
  // The conversation now lives on this row (first REAL byte), and its usage
1423
1423
  // is read off the relayed bytes — figures only, never a booking.
1424
+ accountManager.stampMovedFrom?.(requestInfo);
1424
1425
  accountManager.noteConversationServed?.(requestInfo, account);
1425
1426
  tapLinkUsage(value, requestInfo);
1426
1427
  }
@@ -1635,7 +1636,7 @@ async function forwardRequest(
1635
1636
  requestInfo._upstreamForwardStartAt = upstreamForwardStartAt;
1636
1637
  requestInfo._firstUpstreamByteAt = Date.now();
1637
1638
  // A 2xx answer: the conversation now lives on this account (never on a refusal).
1638
- if (upstreamRes.status < 300) accountManager.noteConversationServed?.(requestInfo, account);
1639
+ if (upstreamRes.status < 300) { accountManager.stampMovedFrom?.(requestInfo); accountManager.noteConversationServed?.(requestInfo, account); }
1639
1640
  // Response arrived — the pre-response leak window is over. Stop guarding for
1640
1641
  // client-disconnect via abort (streamResponse handles mid-stream disconnects).
1641
1642
  res.off('close', onClientClose);
@@ -5305,13 +5306,12 @@ function parseSSEEvent(event, accountIndex, accountManager, requestInfo = {}) {
5305
5306
  // M3: Anthropic interim message_delta usage is CUMULATIVE — add-semantics inflates
5306
5307
  // output on long generations. Track a per-stream RUNNING MAX, accrue once at end.
5307
5308
  // M4: count_tokens responses are prompt-size echoes, not delivered work — skip.
5309
+ // Per-account / per-caller totals are booked ONCE per request at the terminal
5310
+ // release, off the running-max capacity book (finding 3, 2026-11-17) — booking
5311
+ // here would double-count hops and re-add cumulative deltas.
5308
5312
  const usage = requestInfo.isCountTokens ? null : usageFromSseData(data);
5309
5313
  if (usage) {
5310
- const isDelta = data.type === 'message_delta';
5311
- const n = isDelta ? usage.output_tokens : usage.input_tokens;
5312
- accountManager.updateUsage(accountIndex, isDelta ? 0 : n, isDelta ? n : 0);
5313
- accountManager.countCallerTokens?.(requestInfo.caller, n);
5314
- noteCapacityUsage(requestInfo, usage, isDelta);
5314
+ noteCapacityUsage(requestInfo, usage, data.type === 'message_delta');
5315
5315
  }
5316
5316
  if (sseEventContainsThinking(data)) {
5317
5317
  accountManager.markSessionThinkingProtected?.(requestInfo.sessionKey, requestInfo.model);
@@ -5362,8 +5362,8 @@ function extractUsageFromBody(buffer, accountIndex, accountManager, requestInfo
5362
5362
  try {
5363
5363
  const json = JSON.parse(buffer.toString());
5364
5364
  if (json.usage) {
5365
- accountManager.updateUsage(accountIndex, json.usage.input_tokens, json.usage.output_tokens);
5366
- accountManager.countCallerTokens?.(requestInfo.caller, (json.usage.input_tokens || 0) + (json.usage.output_tokens || 0));
5365
+ // Per-account / per-caller totals book once per request at the terminal release
5366
+ // (finding 3, 2026-11-17) — off the running-max capacity figures booked here.
5367
5367
  // CAPACITY LEDGER — M4: a /count_tokens response is a prompt-size echo with ZERO
5368
5368
  // work delivered. Claude Code calls it constantly; counting it would inflate every
5369
5369
  // cycle by whole prompt sizes.
package/src/tui.js CHANGED
@@ -1180,7 +1180,16 @@ export class TUI {
1180
1180
  /** EFFICIENCY line (2026-11-15), directly under Routing: is the prompt cache holding,
1181
1181
  * and what are moves costing — Claude and GLM never blended. null with no traffic.
1182
1182
  * Colours are WARN-only proposals until a one-day baseline exists; a red names the
1183
- * cause and the account. */
1183
+ * cause and the account.
1184
+ * Honest-efficiency rework (2026-11-17, audit findings 2-6):
1185
+ * - hit% never travels alone: writeShare (1.25·cc / 0.1·cr+1.25·cc+in) rides beside
1186
+ * it — a 91% hit line can carry writes worth half the spend, and that is the number
1187
+ * that hid the cold-hop waste. Yellow >40%, red >60% (Claude).
1188
+ * - moves split cross-family (the prompt re-wrote wholesale; drives the red alarm)
1189
+ * vs same-family (near-free: z.ai's cache is shared across its accounts).
1190
+ * - miss is per provider — GLM and Claude tokenizers differ ~1.6x, a blended sum is
1191
+ * unit-inconsistent.
1192
+ * - waits say what they count: busy-bounce waits only (queue holds book 0 here). */
1184
1193
  _efficiencyLine(W = 80, now = Date.now()) {
1185
1194
  const eff = this.am.efficiencyOverall?.('last15m', now);
1186
1195
  if (!eff) return null;
@@ -1193,31 +1202,40 @@ export class TUI {
1193
1202
  if (c.lowVolume && g.lowVolume) return truncLine(` Cache ${dim('— (little traffic)')}${since}`, W);
1194
1203
  const pctTxt = x => `${Math.round(x * 100)}%`;
1195
1204
  const parts = [];
1196
- if (c.hit != null) parts.push(`Claude ${c.lowVolume ? dim(pctTxt(c.hit)) : pctTxt(c.hit)}`);
1205
+ if (c.hit != null) parts.push(`Claude ${c.lowVolume ? dim(pctTxt(c.hit)) : pctTxt(c.hit)}${c.writeShare != null ? ` (w/ ${pctTxt(c.writeShare)} of cost)` : ''}`);
1197
1206
  if (g.hit != null) parts.push(`GLM ${g.lowVolume ? dim(pctTxt(g.hit)) : pctTxt(g.hit)}`);
1198
- const miss = c.missTokens + g.missTokens;
1199
- parts.push(`miss ${miss >= 1e6 ? `${(miss / 1e6).toFixed(1)}M` : `${Math.round(miss / 1000)}k`} tok`);
1207
+ const missTxt = t => t >= 1e6 ? `${(t / 1e6).toFixed(1)}M` : `${Math.round(t / 1000)}k`;
1208
+ if (c.hit != null || c.missTokens) parts.push(`Claude miss ${missTxt(c.missTokens)} tok`);
1209
+ if (g.hit != null || g.missTokens) parts.push(`GLM miss ${missTxt(g.missTokens)} tok`);
1200
1210
  const cause = k => c.movedByCause[k] + g.movedByCause[k];
1201
1211
  const per100 = n => (served ? Math.round(n * 100 / served) : 0);
1202
- parts.push(`moves ${per100(c.moved + g.moved)}/100 (busy ${cause('busy')} · balance ${cause('balance')} · wall ${cause('wall')}${cause('link') ? ` · link ${cause('link')}` : ''}${cause('other') ? ` · other ${cause('other')}` : ''})`);
1212
+ const cross = (c.movedCross || 0) + (g.movedCross || 0);
1213
+ // Causes list only what happened — a row of zeros is width the line cannot spare.
1214
+ const causeTxt = ['busy', 'balance', 'wall', 'link', 'other'].filter(k => cause(k) > 0).map(k => ` · ${k} ${cause(k)}`).join('');
1215
+ parts.push(`cross-moves ${per100(cross)}/100 (same ${(c.movedSame || 0) + (g.movedSame || 0)}${causeTxt})`);
1203
1216
  const bounceShare = bounced / (served + bounced);
1204
1217
  if (bounced) parts.push(`bounced ${pctTxt(bounceShare)}`);
1218
+ const glmBusy = g.movedByCause.busy || 0;
1219
+ if (glmBusy) parts.push(`glm busy-bounced ${glmBusy}`);
1205
1220
  const waited = c.waited + g.waited;
1206
- if (waited) parts.push(`waited ${waited} (avg ${((c.waitMs + g.waitMs) / waited / 1000).toFixed(1)}s)`);
1221
+ if (waited) parts.push(`busy-bounce waits ${waited} (avg ${((c.waitMs + g.waitMs) / waited / 1000).toFixed(1)}s)`);
1207
1222
 
1208
1223
  // RED — the first cause that applies, named with the account behind it.
1209
- const forced = cause('busy') + cause('wall') + cause('link');
1210
1224
  const wtm = c.waitThenMoved + g.waitThenMoved;
1211
1225
  let red_ = null;
1212
1226
  if (!c.lowVolume && c.hit != null && c.hit < 0.5) red_ = `Claude ${pctTxt(c.hit)} on ${this._worstCacheAccount() || '?'}`;
1213
- else if (per100(forced) > 2) red_ = `${per100(forced)} forced moves/100 — most refusals on ${this._mostBouncedAccount(now) || '?'}`;
1227
+ else if (!c.lowVolume && c.writeShare != null && c.writeShare > 0.6) red_ = `write share ${pctTxt(c.writeShare)} of cost on ${this._worstCacheAccount() || '?'}`;
1228
+ else if (per100(cross) > 2) red_ = `cross moves ${per100(cross)}/100 — most refusals on ${this._mostBouncedAccount(now) || '?'}`;
1214
1229
  else if (bounceShare > 0.1) red_ = `${pctTxt(bounceShare)} bounced — most on ${this._mostBouncedAccount(now) || '?'}`;
1215
1230
  else if (wtm * 100 / Math.max(1, served) > 0.5) red_ = `${wtm} waits still moved — on ${this._mostBouncedAccount(now) || '?'}`;
1216
1231
  if (red_) return truncLine(` ${red('Cache')} ${red(`⚠ ${red_}`)} ${dim('·')} ${parts.join(' · ')} ${dim('[15m]')}${since}`, W);
1217
- // YELLOW — Claude below 70%, drifting 15+ points under its hour, or waits are common.
1232
+ // YELLOW — Claude below 70%, write share over 40% of cost, drifting 15+ points
1233
+ // under its hour, or waits are common.
1218
1234
  const hour = this.am.efficiencyOverall('last1h', now).claude;
1219
1235
  const drift = !c.lowVolume && !hour.lowVolume && c.hit != null && hour.hit != null && hour.hit - c.hit >= 0.15;
1220
- const warn = (!c.lowVolume && c.hit != null && c.hit < 0.7) || drift || waited > 0.25 * served;
1236
+ const warn = (!c.lowVolume && c.hit != null && c.hit < 0.7)
1237
+ || (!c.lowVolume && c.writeShare != null && c.writeShare > 0.4)
1238
+ || drift || waited > 0.25 * served;
1221
1239
  return truncLine(` ${warn ? yellow('Cache') : green('Cache')} ${parts.join(' · ')} ${dim('[15m]')}${since}`, W);
1222
1240
  }
1223
1241
 
@@ -3396,9 +3414,10 @@ export class TUI {
3396
3414
 
3397
3415
  const merged = new Map();
3398
3416
  const addWin = (name, w) => {
3399
- const cur = merged.get(name) || { h24: 0, h24p: 0, d7: 0, d7p: 0, d30: 0, d30p: 0, total: 0, tok7: 0 };
3417
+ const cur = merged.get(name) || { h24: 0, h24p: 0, d7: 0, d7p: 0, d30: 0, d30p: 0, total: 0, tok7: 0, paid7: 0 };
3400
3418
  for (const k of ['h24', 'h24p', 'd7', 'd7p', 'd30', 'd30p', 'total']) cur[k] += (w[k]?.req ?? 0);
3401
3419
  cur.tok7 += (w.d7?.tok ?? 0);
3420
+ cur.paid7 += (w.d7?.paid ?? 0);
3402
3421
  merged.set(name, cur);
3403
3422
  };
3404
3423
  for (const [n, w] of this.am.callerWindowStats?.() || []) addWin(n, w);
@@ -3422,22 +3441,23 @@ export class TUI {
3422
3441
  };
3423
3442
  const CW = 9;
3424
3443
  const header = ' ' + 'person'.padEnd(10)
3425
- + ['24h', 'Δ24h', '7d', 'Δ7d', '30d', 'Δ30d', 'total', '~7d tok'].map(c => c.padStart(CW)).join('');
3444
+ + ['24h', 'Δ24h', '7d', 'Δ7d', '30d', 'Δ30d', 'total', '~7d tok', '~7d paid'].map(c => c.padStart(CW)).join('');
3426
3445
  out.push(dimUnderline(fitLine(header, W)));
3427
3446
 
3428
3447
  const rows = [...merged.entries()].sort((a, b) => b[1].d7 - a[1].d7);
3429
- const tot = { h24: 0, h24p: 0, d7: 0, d7p: 0, d30: 0, d30p: 0, total: 0, tok7: 0 };
3448
+ const tot = { h24: 0, h24p: 0, d7: 0, d7p: 0, d30: 0, d30p: 0, total: 0, tok7: 0, paid7: 0 };
3430
3449
  for (const [name, w] of rows) {
3431
3450
  for (const k of Object.keys(tot)) tot[k] += w[k];
3432
3451
  out.push(' ' + name.slice(0, 10).padEnd(10)
3433
- + [fmt(w.h24), delta(w.h24, w.h24p), fmt(w.d7), delta(w.d7, w.d7p), fmt(w.d30), delta(w.d30, w.d30p), fmt(w.total), fmtTok(w.tok7)]
3452
+ + [fmt(w.h24), delta(w.h24, w.h24p), fmt(w.d7), delta(w.d7, w.d7p), fmt(w.d30), delta(w.d30, w.d30p), fmt(w.total), fmtTok(w.tok7), fmtTok(w.paid7)]
3434
3453
  .map(c => lpadVis(String(c), CW)).join(''));
3435
3454
  }
3436
3455
  out.push(dim(' ' + 'total'.padEnd(10)
3437
- + [fmt(tot.h24), delta(tot.h24, tot.h24p), fmt(tot.d7), delta(tot.d7, tot.d7p), fmt(tot.d30), delta(tot.d30, tot.d30p), fmt(tot.total), fmtTok(tot.tok7)]
3456
+ + [fmt(tot.h24), delta(tot.h24, tot.h24p), fmt(tot.d7), delta(tot.d7, tot.d7p), fmt(tot.d30), delta(tot.d30, tot.d30p), fmt(tot.total), fmtTok(tot.tok7), fmtTok(tot.paid7)]
3438
3457
  .map(c => lpadVis(String(c), CW)).join('')));
3439
3458
 
3440
3459
  const link = (this.am.poolLinks || []).find(l => l.lastOkAt);
3460
+ out.push(dim(' tok = full prompt (input + cache read + cache write) + output, provider-native · paid = cache write + uncached input'));
3441
3461
  out.push(dim(` rolling windows · restarts included${link ? ` · team pool synced ${new Date(link.lastOkAt).toLocaleTimeString()}` : ''}`));
3442
3462
  return out;
3443
3463
  }
@@ -3590,10 +3610,14 @@ export class TUI {
3590
3610
  out.push('');
3591
3611
  out.push(' ' + dim('Capacity = median of tokens ÷ % full across readings in each cycle. Med-3 = median of last 3 cycles, Med-all = every cycle.'));
3592
3612
  out.push(' ' + dim('One row per account. Where = which side holds its history: cloud, laptop or both. ? = identity unknown.'));
3593
- out.push(' ' + dim('Tokens = everything the provider processed (input + cached + output), same for Claude and GLM.'));
3613
+ // Axis honesty (audit 2026-11-17, finding 5): the figure counts processed tokens in
3614
+ // EACH provider's own tokenizer (GLM ≈ 0.6x Anthropic for the same prompt), and a
3615
+ // cache read (0.1x) weighs the same as a cache write (1.25x). So $/1M across a
3616
+ // Claude and a GLM row is not a like-for-like price per Claude-equivalent token.
3617
+ out.push(' ' + dim('Tokens = processed tokens (provider-native): input + cached + output, counted in each provider\'s own tokenizer.'));
3594
3618
  out.push(' ' + dim('N = cycles in Med-all (Med-3 uses the newest 3). N* = includes a cycle both pools saw (merged) — estimated from close-time tokens, less precise.'));
3595
3619
  out.push(' ' + dim('Current @% = live window, % full now · no-weekly weekly = avg 5h × 33.6.'));
3596
- out.push(' ' + dim('$/1M = plan price ÷ measured weekly tank (monthly-normalized). -- = no price or tank yet.'));
3620
+ out.push(' ' + dim('$/1M = plan price ÷ measured weekly tank (monthly-normalized), per processed tokens (provider-native). -- = no price or tank yet.'));
3597
3621
  return out;
3598
3622
  }
3599
3623