tokenmaxxing 1.85.0 → 1.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.85.0",
+  "version": "1.87.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/cli/serve.ts

@@ -14,7 +14,7 @@ import type { Provider } from "../lib/provider.ts";
 import { foldTee } from "../lib/sample.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { OAUTH_USAGE_URL } from "../lib/usage.ts";
-import type { Account, Config } from "../lib/types.ts";
+import type { Account, Config, Thresholds } from "../lib/types.ts";
 import { c, emitError } from "./render.ts";
 import { usageReport, type UsageReport, type WindowReport } from "./status.ts";
 
@@ -24,7 +24,7 @@ const STALE_AFTER_MS = 2 * 60 * 60_000;
 type HubPool = {
   provider: Provider;
   usageUrl: string;
-  fold: (account: Account) => void;
+  fold: (account: Account, thresholds: Thresholds) => void;
   read: (account: Account, cfg: Config, now: number) => Promise<Account>;
   body: (usage: UsageReport, account: Account) => unknown;
 };
@@ -96,7 +96,7 @@ function authFiles(cfg: Config, now: number): unknown {
   const files = POOLS.flatMap((pool) => {
     const ctx = { now, thresholds: thresholdBars(cfg), currentId: null, families: pool.provider.gatedFamilies(cfg), seats: null };
     return loadAccounts(pool.provider.pool).accounts.map((a) => {
-      pool.fold(a);
+      pool.fold(a, ctx.thresholds);
       return {
         id: a.id,
         auth_index: authIndex(pool, a),
@@ -140,8 +140,9 @@ async function apiCall(req: Request): Promise<Response> {
   const account = loadAccounts(pool.provider.pool).accounts.find((a) => authIndex(pool, a) === index);
   if (!account) return json({ error: "auth credential not found for auth_index" }, 400);
   const now = Date.now();
-  const current = await pool.read(account, loadConfig(), now);
-  pool.fold(current);
+  const cfg = loadConfig();
+  const current = await pool.read(account, cfg, now);
+  pool.fold(current, thresholdBars(cfg));
   const usage = usageReport({ ...current, windows: current.windows.filter((w) => now - w.sampledAt <= STALE_AFTER_MS) }, now);
   if (!usage || (!usage.fiveHour && !usage.week)) return json({ error: `no usage figure newer than ${STALE_AFTER_MS / 3_600_000}h for this account` }, 502);
   return json({ status_code: 200, header: { "Content-Type": ["application/json"] }, body: JSON.stringify(pool.body(usage, current)) });

package/src/cli/status.ts

@@ -6,7 +6,7 @@ import { opencodeGo } from "../lib/opencodego.ts";
 import { loadAccounts, loadConfig, saveAccounts } from "../lib/state.ts";
 import { withLock } from "../lib/lock.ts";
 import { codexPool, grokPool, opencodeGoPool } from "../lib/paths.ts";
-import { earliestReset, gatedWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
+import { earliestReset, gatedWindows, landWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import type { Provider, SampleReport } from "../lib/provider.ts";
 import { bar, c, count, emitJson, fmtAgo } from "./render.ts";
 import type { Account, Config, Thresholds, Window } from "../lib/types.ts";
@@ -84,25 +84,46 @@ function gatedNote(accounts: Account[], families: string[] | null, weeklyBar: nu
 }
 
 async function collect(p: Provider, cfg: Config, now: number, cached: boolean): Promise<PoolReport> {
+  const bars = thresholdBars(cfg);
   let idx = loadAccounts(p.pool);
   let reports = new Map<string, SampleReport>();
   let liveId: string | null = null;
   if (!cached && idx.accounts.length > 0) {
-    await withLock(p.pool.lockFile, async () => {
-      idx = loadAccounts(p.pool);
-      const notice = process.stderr.isTTY;
-      if (notice) process.stderr.write(c.dim(`sampling ${p.name} usage...`));
-      try {
-        liveId = p.liveId();
-        reports = await p.samplePool(idx.accounts, liveId, now);
-      } finally {
-        if (notice) process.stderr.write("\r\x1b[2K");
-      }
-      saveAccounts(p.pool, idx);
-    });
+    const notice = process.stderr.isTTY;
+    if (notice) process.stderr.write(c.dim(`sampling ${p.name} usage...`));
+    try {
+      liveId = p.liveId();
+      const retries = new Map(idx.accounts.map((a) => [a.id, a.usageRetryAt ?? null]));
+      reports = await p.samplePool(idx.accounts, liveId, now);
+      await withLock(p.pool.lockFile, () => {
+        const fresh = loadAccounts(p.pool);
+        let dirty = false;
+        for (const a of idx.accounts) {
+          const stored = fresh.accounts.find((x) => x.id === a.id);
+          if (!stored) continue;
+          if (a.needsReauth === true && stored.needsReauth !== true) {
+            stored.needsReauth = true;
+            dirty = true;
+          }
+          if ((a.usageRetryAt ?? null) !== retries.get(a.id)) {
+            stored.usageRetryAt = a.usageRetryAt;
+            dirty = true;
+          }
+          if (a.lastUsageAt != null && (stored.lastUsageAt == null || a.lastUsageAt > stored.lastUsageAt)) {
+            landWindows(stored, p.mergeWindows(a.windows, stored.windows), a.lastUsageAt, bars);
+            if (a.email != null) stored.email = a.email;
+            if (a.tier != null) stored.tier = a.tier;
+            dirty = true;
+          }
+        }
+        if (dirty) saveAccounts(p.pool, fresh);
+        idx = fresh;
+      });
+    } finally {
+      if (notice) process.stderr.write("\r\x1b[2K");
+    }
   }
 
-  const bars = thresholdBars(cfg);
   const present = p.presence();
   const ctx = { now, thresholds: bars, currentId: null, families: p.gatedFamilies(cfg), seats: null };
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
@@ -235,7 +256,7 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
       console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
       console.log();
     } else {
-      const header = `thresholds 5h ${claudeReport.thresholds.session}% weekly ${claudeReport.thresholds.weekly}%  (${count({ n: claudeReport.accounts.length, noun: "claude account" })})`;
+      const header = `thresholds 5h ${claudeReport.thresholds.session}% weekly ${claudeReport.thresholds.weekly}%  bars 5h ${claudeReport.bars.session}% weekly ${claudeReport.bars.weekly}%  (${count({ n: claudeReport.accounts.length, noun: "claude account" })})`;
       renderPool(claude, claudeReport, header, Date.now(), cfg.policy.usagePollTtlMs);
     }
   }

package/src/entries/stopfailurehook.ts

@@ -80,8 +80,8 @@ export async function runStopFailureHook(): Promise<number> {
       );
     }
 
-    const decision = await evaluateAndMaybeSwap(claude, now, canRespawn && enforced != null, enforced, { waiterId: canRespawn ? session?.sid : undefined });
-    if (enforced && session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+    const decision = await evaluateAndMaybeSwap(claude, now, canRespawn, enforced, { waiterId: canRespawn ? session?.sid : undefined });
+    if (session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       writeRespawnMarker({ session, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: false, origin: "stopfailure" });
       log("stopfailure.marker", { session: session.sid.slice(0, 8), live: session.live.slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil ?? now });
     } else {

package/src/entries/supervisor.ts

@@ -498,7 +498,12 @@ export async function runSupervisor(argv: string[]): Promise<number> {
         delete compactEnv.TOKENMAXXING_SESSION_ID;
         delete compactEnv.TOKENMAXXING_LAUNCHED_AT;
         delete compactEnv.TOKENMAXXING_MODEL;
-        const outcome = await compactClaudeSession({ real, sid: m.sessionId, transcript, env: compactEnv });
+        const outcome = await compactClaudeSession({ real, sid: m.sessionId, transcript, env: compactEnv, onSpawn: (p) => { child = p; } });
+        child = null;
+        if (terminating) {
+          await releaseClaim();
+          return 143;
+        }
         log("supervisor.compact", { sid: m.sessionId.slice(0, 8), seat: seat.id.slice(0, 8), ok: outcome.ok, reason: outcome.ok ? undefined : outcome.reason });
         if (!outcome.ok) say(`\x1b[33m   compaction did not land (${outcome.reason}) - resuming with the full context\x1b[0m\n`, `tokenmaxxing: compaction did not land; resuming with the full context. (${outcome.reason})`);
         compacted = outcome.ok;

package/src/lib/claude.ts

@@ -8,7 +8,7 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
 import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
-import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
+import { landWindows, pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { deletePiStore } from "./piauth.ts";
 import { seatCounts } from "./presence.ts";
 import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
@@ -48,8 +48,7 @@ async function observeLive(account: Account, cfg: Config, now: number, opts: { p
       if (outcome.ok) {
         a.probeFails = 0;
         if (a.lastUsageAt == null || startedAt > a.lastUsageAt) {
-          a.windows = mergeWindows(windowsOf(outcome.usage, startedAt), a.windows);
-          a.lastUsageAt = startedAt;
+          landWindows(a, mergeWindows(windowsOf(outcome.usage, startedAt), a.windows), startedAt, thresholdBars(cfg));
         }
       } else {
         a.probeFails = (a.probeFails ?? 0) + 1;
@@ -64,12 +63,13 @@ async function observeLive(account: Account, cfg: Config, now: number, opts: { p
 
 async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
   const reports = new Map<string, SampleReport>();
+  const bars = thresholdBars(loadConfig());
   await Promise.all(
     accounts.map(async (a) => {
       const tee = loadUsageSnapshot(a.id);
       const teeAt = tee == null ? null : (tee.state.sampledAt ?? tee.state.ts);
       if (teeAt != null && (a.lastUsageAt == null || teeAt >= a.lastUsageAt)) {
-        foldTee(a);
+        foldTee(a, bars);
         reports.set(a.id, { ok: true, source: "statusline" });
         return;
       }
@@ -80,8 +80,7 @@ async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport
         return;
       }
       const at = Date.now();
-      a.lastUsageAt = at;
-      a.windows = mergeWindows(windowsOf(outcome.usage, at), a.windows);
+      landWindows(a, mergeWindows(windowsOf(outcome.usage, at), a.windows), at, bars);
       reports.set(a.id, { ok: true, source: "probe" });
     }),
   );
@@ -120,11 +119,12 @@ async function storeUsable(a: Account): Promise<boolean> {
 
 export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Account | null {
   const cfg = loadConfig();
+  const bars = thresholdBars(cfg);
   const idx = loadAccounts(claudePool);
   let dirty = false;
-  for (const a of idx.accounts) dirty = foldTee(a) || dirty;
+  for (const a of idx.accounts) dirty = foldTee(a, bars) || dirty;
   if (dirty) saveAccounts(claudePool, idx);
-  const ctx: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats: presence() };
+  const ctx: PickCtx = { now, thresholds: bars, currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats: presence() };
   const candidates = idx.accounts.filter(eligible);
   return pickBest(candidates, ctx) ?? pickEarliestReset(candidates, ctx)?.account ?? null;
 }

package/src/lib/codex.ts

@@ -33,9 +33,10 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
   if (usage.planType != null) account.tier = usage.planType;
 }
 
-type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | { ok: false; reason: string; deadGrant: boolean };
+type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; expiring?: boolean };
+type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | CodexReadFailure;
 
-async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
+async function freshCodexAuth(account: Account, now: number, refresh: boolean, holder?: string): Promise<{ ok: true; auth: CodexAuthJson } | CodexReadFailure> {
   let auth: CodexAuthJson | null;
   try {
     auth = readCodexStoreAuth(account.id);
@@ -43,22 +44,30 @@ async function readCodexUsage(account: Account, now: number, refresh: boolean, h
     return { ok: false, reason: `store credential unreadable (${errorMessage(e).slice(0, 80)})`, deadGrant: false };
   }
   if (!auth) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth --codex`", deadGrant: false };
+  if (!isCodexAccessExpiring({ auth, now })) return { ok: true, auth };
+  if (!refresh) return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false, expiring: true };
+  if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
+    return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
+  }
   try {
-    if (isCodexAccessExpiring({ auth, now })) {
-      if (!refresh) {
-        return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false };
-      }
-      if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
-        return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
-      }
-      auth = await refreshCodexAuth({ auth, now });
-      writeCodexStoreAuth(account.id, auth);
-    }
-    const at = Date.now();
-    return { ok: true, usage: await fetchCodexUsage({ auth, at }), at };
+    auth = await refreshCodexAuth({ auth, now });
   } catch (e) {
     if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true };
-    if (e instanceof CodexRefreshFailedError || e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false };
+    if (e instanceof CodexRefreshFailedError) return { ok: false, reason: e.message, deadGrant: false };
+    throw e;
+  }
+  writeCodexStoreAuth(account.id, auth);
+  return { ok: true, auth };
+}
+
+async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
+  const fresh = await freshCodexAuth(account, now, refresh, holder);
+  if (!fresh.ok) return fresh;
+  try {
+    const at = Date.now();
+    return { ok: true, usage: await fetchCodexUsage({ auth: fresh.auth, at }), at };
+  } catch (e) {
+    if (e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false };
     throw e;
   }
 }
@@ -86,18 +95,27 @@ export async function observeCodex(account: Account, cfg: Config, now: number, o
 
 async function samplePool(accounts: Account[], _liveId: string | null, now: number): Promise<Map<string, SampleReport>> {
   const reports = new Map<string, SampleReport>();
+  const record = (account: Account, outcome: CodexReadOutcome): void => {
+    if (outcome.ok) {
+      applyUsage(account, outcome.usage, outcome.at);
+      reports.set(account.id, { ok: true, source: "probe" });
+    } else {
+      if (outcome.deadGrant) account.needsReauth = true;
+      reports.set(account.id, { ok: false, reason: outcome.reason });
+    }
+  };
+  const expiring: Account[] = [];
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now, true);
-      if (outcome.ok) {
-        applyUsage(account, outcome.usage, outcome.at);
-        reports.set(account.id, { ok: true, source: "probe" });
-      } else {
-        if (outcome.deadGrant) account.needsReauth = true;
-        reports.set(account.id, { ok: false, reason: outcome.reason });
-      }
+      const outcome = await readCodexUsage(account, now, false);
+      if (!outcome.ok && outcome.expiring === true) expiring.push(account);
+      else record(account, outcome);
     }),
   );
+  if (expiring.length > 0) {
+    const rotated = await withLock(codexPool.lockFile, () => Promise.all(expiring.map(async (account) => ({ account, fresh: await freshCodexAuth(account, now, true) }))));
+    await Promise.all(rotated.map(async ({ account, fresh }) => record(account, fresh.ok ? await readCodexUsage(account, now, false) : fresh)));
+  }
   return reports;
 }
 

package/src/lib/compact.ts

@@ -1,4 +1,5 @@
 import { statSync } from "node:fs";
+import type { Subprocess } from "bun";
 import { delay } from "es-toolkit";
 import { z } from "zod";
 import pkg from "../../package.json" with { type: "json" };
@@ -13,7 +14,7 @@ const PIPE_GRACE_MS = 2_000;
 
 const CompactBoundarySchema = z.looseObject({ type: z.literal("system"), subtype: z.literal("compact_boundary") });
 
-export async function compactClaudeSession(input: { real: string; sid: string; transcript: string; env: Record<string, string | undefined> }): Promise<CompactOutcome> {
+export async function compactClaudeSession(input: { real: string; sid: string; transcript: string; env: Record<string, string | undefined>; onSpawn: (child: Subprocess) => void }): Promise<CompactOutcome> {
   const offset = statSync(input.transcript).size;
   const p = Bun.spawn([input.real, "-p", "--resume", input.sid, "/compact"], {
     env: input.env,
@@ -23,6 +24,7 @@ export async function compactClaudeSession(input: { real: string; sid: string; t
     timeout: CLAUDE_COMPACT_KILL_MS,
     killSignal: "SIGKILL",
   });
+  input.onSpawn(p);
   const reads = Promise.all([p.stdout.text(), p.stderr.text()]);
   const settled = await Promise.race([reads, p.exited.then(() => delay(PIPE_GRACE_MS)).then(() => null)]);
   await p.exited;

package/src/lib/decide.ts

@@ -1,7 +1,7 @@
 import { countBy } from "es-toolkit";
 import { withLock } from "./lock.ts";
 import { loadAccounts, loadConfig, liveWaitClaims, releaseWaitClaim, replaceWaitClaim, saveAccounts } from "./state.ts";
-import { isExhausted, limitWindows, liveUsed, nextWeeklyReset, pickBest, pickWaitTarget, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
+import { isExhausted, landWindows, limitWindows, liveUsed, nextWeeklyReset, pickBest, pickWaitTarget, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
 import { familyTokens } from "./usage.ts";
 import { errorMessage, log } from "./log.ts";
 import type { Observation, Provider } from "./provider.ts";
@@ -100,10 +100,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
     for (const a of idx.accounts) {
       const obs = await p.observeLive(a, cfg, now, { probe: false, perModel: false });
       if (a === active) obs2 = obs;
-      if (obs && (a.lastUsageAt == null || obs.at > a.lastUsageAt)) {
-        a.windows = p.mergeWindows(obs.windows, a.windows);
-        a.lastUsageAt = obs.at;
-      }
+      if (obs && (a.lastUsageAt == null || obs.at > a.lastUsageAt)) landWindows(a, p.mergeWindows(obs.windows, a.windows), obs.at, bars);
     }
     saveAccounts(p.pool, idx);
 

package/src/lib/picker.ts

@@ -53,16 +53,16 @@ function barFor(w: Window, thresholds: Thresholds): number {
   return isSessionWindow(w) ? thresholds.session : thresholds.weekly;
 }
 
-function blockedUntil(w: Window, bar: number): number {
-  if (w.usedPercentage < bar) return 0;
+function blockedUntil(w: Window, bar: number, now: number): number {
+  if (liveUsed(w, now) < bar) return 0;
   if (w.resetsAt != null) return w.resetsAt;
-  return w.windowSeconds != null ? w.sampledAt + w.windowSeconds * 1000 : Number.POSITIVE_INFINITY;
+  return w.sampledAt + (w.windowSeconds ?? 0) * 1000;
 }
 
 function blockingUntil(a: Account, ctx: PickCtx): number[] {
   return [
-    ...a.windows.filter((w) => w.name == null).map((w) => blockedUntil(w, barFor(w, ctx.thresholds))),
-    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(w, barFor(w, ctx.thresholds))),
+    ...a.windows.filter((w) => w.name == null).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
+    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
     ...(a.enforcedUntil != null ? [a.enforcedUntil] : []),
   ];
 }
@@ -71,6 +71,14 @@ export function isExhausted(a: Account, ctx: PickCtx): boolean {
   return blockingUntil(a, ctx).some((t) => t > ctx.now);
 }
 
+export function landWindows(a: Account, windows: Window[], at: number, thresholds: Thresholds): void {
+  const ctx: PickCtx = { now: at, thresholds, currentId: null, families: [], seats: null };
+  const blocked = a.enforcedUntil != null && isExhausted({ ...a, enforcedUntil: undefined }, ctx);
+  a.windows = windows;
+  a.lastUsageAt = at;
+  if (blocked && !isExhausted({ ...a, enforcedUntil: undefined }, ctx)) a.enforcedUntil = undefined;
+}
+
 export function nextWeeklyReset(resetsAt: number | null, now: number): number | null {
   if (resetsAt == null || resetsAt > now) return resetsAt;
   return resetsAt + (Math.floor((now - resetsAt) / WEEK_MS) + 1) * WEEK_MS;

package/src/lib/sample.ts

@@ -3,11 +3,12 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, isDeadCredential } from "./oauth.ts";
 import { claudePool, paths } from "./paths.ts";
+import { landWindows, thresholdBars } from "./picker.ts";
 import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
 import { fetchUsageDirect, mergeWindows, windowsOf } from "./usage.ts";
-import type { Account, Config, UsageWindows } from "./types.ts";
+import type { Account, Config, Thresholds, UsageWindows } from "./types.ts";
 
 export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" } | { ok: false; reason: string; retryAt?: number };
 
@@ -23,11 +24,10 @@ export function teeObservation(account: Account): Observation | null {
   return { windows: mergeWindows(aggregate, account.windows), at };
 }
 
-export function foldTee(account: Account): boolean {
+export function foldTee(account: Account, thresholds: Thresholds): boolean {
   const observed = teeObservation(account);
   if (!observed || (account.lastUsageAt != null && observed.at <= account.lastUsageAt)) return false;
-  account.windows = observed.windows;
-  account.lastUsageAt = observed.at;
+  landWindows(account, observed.windows, observed.at, thresholds);
   return true;
 }
 
@@ -79,7 +79,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
     const now = Date.now();
     const idx = loadAccounts(claudePool);
     let dirty = false;
-    for (const a of idx.accounts) dirty = foldTee(a) || dirty;
+    for (const a of idx.accounts) dirty = foldTee(a, thresholdBars(cfg)) || dirty;
     const sampledAt = (a: Account) => Math.max(a.lastUsageAt ?? 0, a.lastProbeAt ?? 0);
     const seats = seatCounts(paths.presenceDir);
     const stale = idx.accounts
@@ -123,8 +123,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
           dirty = true;
         }
         if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
-          stored.windows = mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows);
-          stored.lastUsageAt = startedAt;
+          landWindows(stored, mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows), startedAt, thresholdBars(cfg));
           dirty = true;
         }
         if (dirty) saveAccounts(claudePool, idx);