tokenmaxxing 1.23.0 → 1.24.0

package/DESIGN.md

@@ -37,7 +37,7 @@ It is a process manager only - spawn with inherited stdio plus saved `stty -g` t
   - `bin/claude` - the supervisor.
 - Per-account **credentials** follow the platform's Claude Code store: macOS = login-keychain items `tokenmaxxing-cred-<accountUuid[:8]>` (never plaintext on disk); Linux = 0600 files `creds/tokenmaxxing-cred-<accountUuid[:8]>.json` (the same plaintext model claude itself uses - its Linux build has no keyring path at all, binary-verified 2.1.205). One `credstore` facade dispatches on a `{kind: keychain|file}` target; call sites never branch on platform.
 
-- A periodic check job (`com.tokenmaxxing.check` launchd agent on macOS, `tokenmaxxing-check.timer` systemd user timer on Linux) running `tokenmaxxing check --if-due` once per tick (`policy.checkIntervalMs`, 60s by default), self-paced up to five ticks from the live account's headroom: hooks alone miss long agentic turns, so the timer is the backstop that keeps switching engaged mid-turn.
+- A periodic check job (`com.tokenmaxxing.check` launchd agent on macOS, `tokenmaxxing-check.timer` systemd user timer on Linux) running `tokenmaxxing check` once per tick (`policy.checkIntervalMs`, 60s by default): hooks alone miss long agentic turns, so the timer is the backstop that keeps switching engaged mid-turn.
 
 The switching path runs no long-lived daemon. The statusline pushes usage. Hooks and the supervisor react. The periodic check job above is the only recurring process. The `claude` binary and `~/.claude` layout are untouched.
 

package/README.md

@@ -113,7 +113,7 @@ See [How switching decides](docs/content/docs/switching.mdx) for the policy and
 }
 ```
 
-`thresholds.session` is a ladder: the bar is the lowest rung some pooled account still clears, so the default `[90]` is one bar, while with `[50, 80, 95]` a seat past 50 hands off while a sibling is under 50, and the bar climbs to 80 and then 95 as the whole pool fills; `projectionMargin` is a fixed safety margin subtracted from each threshold bar (effective bar = threshold - margin), so a large turn is less likely to blow past a bar between checks; `greedySessionFloor` is the session-used % at which the greedy convergence engages; `switchModels` names the models whose per-model cap triggers a switch; `usagePollTtlMs` is how long a `/usage` per-model poll stays fresh; `maxWaitMs` bounds the depleted-pool countdown - a soonest reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer and which every headroom band is a multiple of, one tick near a bar up to five with plenty of headroom (a depleted wait and the post-swap cooldown sleep to their own deadlines instead) - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick.
+`thresholds.session` is a ladder: the bar is the lowest rung some pooled account still clears, so the default `[90]` is one bar, while with `[50, 80, 95]` a seat past 50 hands off while a sibling is under 50, and the bar climbs to 80 and then 95 as the whole pool fills; `projectionMargin` is a fixed safety margin subtracted from each threshold bar (effective bar = threshold - margin), so a large turn is less likely to blow past a bar between checks; `greedySessionFloor` is the session-used % at which the greedy convergence engages; `switchModels` names the models whose per-model cap triggers a switch; `usagePollTtlMs` is how long a `/usage` per-model poll stays fresh; `maxWaitMs` bounds the depleted-pool countdown - a soonest reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick.
 
 State lives entirely in `~/.config/tokenmaxxing/`. Per-account credentials follow the platform's Claude Code store: the login keychain on macOS (`tokenmaxxing-cred-<uuid8>` items, never plaintext on disk), 0600 files under `~/.config/tokenmaxxing/creds/` on Linux (the same plaintext model claude itself uses for `~/.claude/.credentials.json`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/check.ts

@@ -1,49 +1,33 @@
-import { checkDelayMs, evaluateAndMaybeSwap } from "../lib/decide.ts";
-import { readOAuthAccount } from "../lib/claudejson.ts";
+import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { log } from "../lib/log.ts";
-import { loadConfig, loadNextCheckDueAt, saveNextCheckDueAt } from "../lib/state.ts";
 import { c, emitError, emitJson, fmtReset } from "./render.ts";
 
-export async function cmdCheck(args: string[] = [], json = false): Promise<number> {
-  const now = Date.now();
-  let cfg;
+export async function cmdCheck(json = false): Promise<number> {
   let d;
   try {
-    cfg = loadConfig();
-    const dueAt = args.includes("--if-due") ? loadNextCheckDueAt({ now, cfg }) : null;
-    if (dueAt != null && now + cfg.policy.checkIntervalMs / 2 < dueAt) {
-      if (json) emitJson({ ok: true, due: false, nextCheckAt: dueAt });
-      else console.log(c.dim(`not due (${Math.ceil((dueAt - now) / 1000)}s)`));
-      return 0;
-    }
-    d = await evaluateAndMaybeSwap(now);
+    d = await evaluateAndMaybeSwap(Date.now());
   } catch (e) {
     const detail = e instanceof Error ? e.message : String(e);
     log("check.error", { err: detail });
     emitError({ json, message: `check failed: ${detail}` });
     return 1;
   }
-  const delayMs = checkDelayMs({ cfg, account: readOAuthAccount()?.accountUuid ?? null, now, decision: d });
-  saveNextCheckDueAt({ dueAt: now + delayMs, ts: now });
   if (json) {
     emitJson({
       ok: true,
-      due: true,
       swapped: d.swapped,
       account: d.account?.label ?? null,
       reason: d.reason,
       waitUntil: d.waitUntil ?? null,
-      nextCheckAt: now + delayMs,
     });
     return 0;
   }
-  const next = c.dim(`next in ${Math.round(delayMs / 1000)}s`);
   if (d.swapped && d.account) {
-    console.log(`${c.green("↻")} switched to ${c.bold(d.account.label)} ${next}`);
+    console.log(`${c.green("↻")} switched to ${c.bold(d.account.label)}`);
   } else if (d.waitUntil !== undefined && d.account) {
-    console.log(c.yellow(`all accounts at limit - staying on ${c.bold(d.account.label)} (${fmtReset(d.waitUntil)})`) + ` ${next}`);
+    console.log(c.yellow(`all accounts at limit - staying on ${c.bold(d.account.label)} (${fmtReset(d.waitUntil)})`));
   } else {
-    console.log(c.dim(`no switch (${d.reason}) `) + next);
+    console.log(c.dim(`no switch (${d.reason})`));
   }
   return 0;
 }

package/src/lib/decide.ts

@@ -2,11 +2,11 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { MAX_CHECK_DELAY_TICKS, POST_SWAP_COOLDOWN_MS, maxCheckDelayMs, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { chooseAndSwap, isSkippableSwapError, performSwap, type VerifyVerdict } from "./swap.ts";
 import { probeParkedUsage } from "./sample.ts";
-import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt, type PickCtx } from "./picker.ts";
+import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, usableAt, type PickCtx } from "./picker.ts";
 import { familyTokens, gatedFamilies, probeUsage, type EnforcedClass } from "./usage.ts";
 import { log } from "./log.ts";
 import { AccountSchema, ModelUsageStateSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type ModelUsageState, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
@@ -413,38 +413,3 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; account
     return { outcome: "stamped", resetsAt: limit.resetsAt };
   });
 }
-
-const STAGE_CEILING_TICKS = [MAX_CHECK_DELAY_TICKS, 3, 2];
-
-export function checkDelayMs(input: { cfg: Config; account: string | null; now: number; decision: SwapDecision }): number {
-  const { cfg, account, now, decision } = input;
-  const tick = cfg.policy.checkIntervalMs;
-  const max = maxCheckDelayMs(cfg);
-  if (decision.waitUntil !== undefined) return Math.min(max, Math.max(tick, decision.waitUntil - now));
-  const swapAt = loadLastSwapAt();
-  if (swapAt != null && now - swapAt < POST_SWAP_COOLDOWN_MS) return swapAt + POST_SWAP_COOLDOWN_MS - now;
-  const snap = loadUsageSnapshot();
-  if (!account || !snap || !usageFresh(snap.state, snap.at, account, cfg.policy.usagePollTtlMs, now)) return 3 * tick;
-  const accounts = loadAccounts().accounts;
-  const u = freshest(snap.state, snap.at, accounts.find((a) => a.accountUuid === account)) ?? { ...snap.state, ts: snap.at };
-  const mu = loadModelUsage();
-  const muSame = mu && mu.account === account ? mu : null;
-  const families = gatedFamilies(u.model, cfg.policy.switchModels);
-  const bars = effectiveBars(cfg, { accounts: overlayLive(accounts, u, muSame, account), now, switchFamilies: families });
-  const heads = [
-    bars.session - liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }),
-    bars.weekly - liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }),
-  ];
-  let capMissing = false;
-  const capFresh = muSame != null && now - (muSame.sampledAt ?? muSame.ts) <= cfg.policy.usagePollTtlMs;
-  for (const family of families) {
-    const cap = muSame && capFresh ? capForFamily(muSame, family, now) : undefined;
-    if (cap && muSame) heads.push(bars.weekly - liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: muSame.sampledAt ?? muSame.ts, now }));
-    else capMissing = true;
-  }
-  const headroom = Math.min(...heads);
-  const banded = headroom >= 40 ? max : headroom >= 20 ? 3 * tick : headroom >= 8 ? 2 * tick : tick;
-  const stage = sessionLadder(cfg).indexOf(bars.session);
-  const staged = Math.min(banded, (STAGE_CEILING_TICKS[stage] ?? 1) * tick);
-  return capMissing ? Math.min(staged, 2 * tick) : staged;
-}

package/src/lib/install.ts

@@ -214,7 +214,7 @@ function installCheckTimer(intervalS: number): boolean {
 <plist version="1.0">
 <dict>
   <key>Label</key><string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key><array><string>${escape(installedBin())}</string><string>check</string><string>--if-due</string></array>
+  <key>ProgramArguments</key><array><string>${escape(installedBin())}</string><string>check</string></array>
   <key>StartInterval</key><integer>${intervalS}</integer>
   <key>StandardOutPath</key><string>/dev/null</string>
   <key>StandardErrorPath</key><string>${escape(join(paths.home, "check.stderr.log"))}</string>
@@ -229,7 +229,7 @@ function installCheckTimer(intervalS: number): boolean {
     return run(["launchctl", "bootstrap", domain, plist]) || checkTimerHealthy();
   }
 
-  const exec = `"${installedBin().replaceAll("%", "%%")}" check --if-due`;
+  const exec = `"${installedBin().replaceAll("%", "%%")}" check`;
   writeFileAtomic(
     join(paths.systemdUserDir, "tokenmaxxing-check.service"),
     `[Unit]

package/src/lib/paths.ts

@@ -20,7 +20,6 @@ export const paths = {
   modelUsageJson: join(TM_HOME, "model-usage.json"),
   lastSwapJson: join(TM_HOME, "lastswap.json"),
   depletedJson: join(TM_HOME, "depleted.json"),
-  nextCheckJson: join(TM_HOME, "nextcheck.json"),
   respawnDir: join(TM_HOME, "respawn"),
   binDir: join(TM_HOME, "bin"),
   supervisorLink: join(TM_HOME, "bin", "claude"),

package/src/lib/state.ts

@@ -8,7 +8,6 @@ import {
   ConfigSchema,
   LastSwapSchema,
   ModelUsageStateSchema,
-  NextCheckSchema,
   SessionLadderSchema,
   UsageStateSchema,
   type AccountsIndex,
@@ -209,33 +208,8 @@ export function clearDepletedWait(): void {
   rmSync(paths.depletedJson, { force: true });
 }
 
-export const MAX_CHECK_DELAY_TICKS = 5;
 export const POST_SWAP_COOLDOWN_MS = 45_000;
 
-export function maxCheckDelayMs(cfg: Config): number {
-  return MAX_CHECK_DELAY_TICKS * cfg.policy.checkIntervalMs;
-}
-
-export function loadNextCheckDueAt(input: { now: number; cfg: Config }): number | null {
-  if (!existsSync(paths.nextCheckJson)) return null;
-  let parsed;
-  try {
-    parsed = NextCheckSchema.safeParse(JSON.parse(readFileSync(paths.nextCheckJson, "utf8")));
-  } catch {
-    return null;
-  }
-  if (!parsed.success) return null;
-  return parsed.data.dueAt - input.now > Math.max(maxCheckDelayMs(input.cfg), POST_SWAP_COOLDOWN_MS) ? null : parsed.data.dueAt;
-}
-
-export function saveNextCheckDueAt(input: { dueAt: number; ts: number }): void {
-  writeFileAtomic(paths.nextCheckJson, JSON.stringify(NextCheckSchema.parse(input)));
-}
-
-export function clearNextCheck(): void {
-  rmSync(paths.nextCheckJson, { force: true });
-}
-
 const USAGE_TS_REFRESH_MS = 10 * 60_000;
 const SAMPLED_AT_REFRESH_MS = 30_000;
 

package/src/lib/swap.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { clearDepletedWait, clearNextCheck, clearUsageSnapshots, loadAccounts, saveAccounts, saveLastSwapAt } from "./state.ts";
+import { clearDepletedWait, clearUsageSnapshots, loadAccounts, saveAccounts, saveLastSwapAt } from "./state.ts";
 import { readItem, writeItem, liveTarget, parkedTarget, claudeAiOauthOnly, mergeIntoLive } from "./credstore.ts";
 import { refreshCredential, isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity, IdentityUnavailableError, InvalidGrantError, RefreshRejectedError } from "./oauth.ts";
 import { swapOAuthAccount } from "./claudejson.ts";
@@ -155,7 +155,6 @@ export async function performSwap(target: Account): Promise<void> {
     saveAccounts(idx);
     clearUsageSnapshots();
     clearDepletedWait();
-    clearNextCheck();
     saveLastSwapAt(Date.now());
   });
   log("swap.done", { account: target.accountUuid.slice(0, 8), email: target.email });

package/src/lib/types.ts

@@ -85,8 +85,6 @@ export const AccountsIndexSchema = z.object({
 export const LastSwapSchema = z.object({ ts: z.number() });
 export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
-export const NextCheckSchema = z.object({ dueAt: z.number(), ts: z.number() });
-
 export const EnforcedLimitSchema = z.object({
   account: z.string(),
   family: z.string().nullable(),

package/src/main.ts

@@ -140,7 +140,13 @@ async function main(): Promise<number> {
       const rest = args.slice(1).filter((a) => a !== "--codex");
       return args.includes("--codex") ? cmdCodexSwitch(rest[0], json) : cmdSwitch(rest[0], json);
     }
-    case "check": return cmdCheck(args.slice(1), json);
+    case "check": {
+      if (args.length > 1) {
+        emitError({ json, message: `unknown check option: ${args[1]} (check takes no options; the timer runs a plain check every tick)` });
+        return 2;
+      }
+      return cmdCheck(json);
+    }
     case "config": return cmdConfig(args.slice(1), json);
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();