tokenmaxxing 1.20.0 → 1.23.0

package/DESIGN.md

@@ -72,7 +72,7 @@ Each terminal ran the supervisor, so each has its own child `claude` and its own
 
 - **`tokenmaxxing init` imports the account you're already on - automatically, no prompts, no re-login.** It reads the live `Claude Code-credentials` keychain blob plus the `oauthAccount` object in `~/.claude.json` (email, `organizationUuid`, `accountUuid`, plan tier) and writes them as **account #1** into tokenmaxxing's store (`tokenmaxxing-cred-<accountUuid[:8]>` + an `accounts.json` index entry). Nothing about your current session changes - that account stays active; it's now just also a registered pool member. After this one command you already have a working (single-account) pool. `init` also installs the supervisor + the four settings entries.
   - If the current auth is API-key mode (`ANTHROPIC_API_KEY`/`apiKeyHelper`) rather than a subscription `/login`, there's no quota-poolable subscription credential to import - `init` says so and points you to `/login` first (per-token API billing isn't what tokenmaxxing pools).
-- **`tokenmaxxing add`** - registers *additional* accounts: logs one in via a throwaway `CLAUDE_CONFIG_DIR=~/.config/tokenmaxxing/onboard` (your primary login untouched), harvests it into the store, deletes the temp dir + its namespaced item. `CLAUDE_CONFIG_DIR` is SET by tokenmaxxing only for throwaway isolated stores like this one: the same harvest serves `auth`, and parked-account `/usage` sampling probes under `sample/<item>` the same way; an AMBIENT `CLAUDE_CONFIG_DIR` is refused by every CLI command and by the SDK's pooledSpawnEnv.
+- **`tokenmaxxing add`** - registers *additional* accounts: logs one in via a throwaway `CLAUDE_CONFIG_DIR=~/.config/tokenmaxxing/onboard` (your primary login untouched), harvests it into the store, deletes the temp dir + its namespaced item. `CLAUDE_CONFIG_DIR` is SET by tokenmaxxing only for throwaway isolated stores like this one: the same harvest serves `auth`, and parked-account `/usage` sampling probes under `sample/<item>` the same way; an AMBIENT `CLAUDE_CONFIG_DIR` is refused by every CLI command.
 - **`tokenmaxxing auth [sel | --all]`** - reauthenticates an *existing* pool member whose refresh token died (a needs-reauth account can never heal through a swap: the dead token is exactly what a swap would need). Same isolated-login harvest as `add`, but it states which email to sign in with and **requires the login to land on the target account** (harvested `accountUuid` must match, else nothing changes) - the credential write and the needs-reauth clear happen in one flock critical section so a concurrent swap's harvest cannot clobber the fresh backup. Bare `auth` lists the pool with emails and asks which; `--all` walks every flagged account one by one.
 - Both commands exercise `security` reads/writes interactively (where a macOS keychain ACL prompt is acceptable), so the first access never happens cold inside a headless hook.
 
@@ -98,8 +98,6 @@ The [wall policy](docs/content/docs/switching.mdx#the-wall) defines Layer 2 reco
 
 **Model-aware trigger.** Claude subscriptions also enforce **per-model weekly caps** - currently only for Sonnet and Fable (there is no Opus-only quota), and Fable's tighter limit binds *before* the aggregate (e.g. 80% week-Fable at only 50% week-all-models). This cap isn't in statusLine stdin, so when the active model is in `policy.switchModels` we read it from `claude -p '/usage'` (free, 0 tokens, TTL-cached) and add `week(<activeModel>) >= threshold` to the trigger. A Fable session switches on the Fable cap; a Sonnet session rides the aggregate. Both layers apply the per-model gate: a burnt Fable cap screens an account out of a Layer 1 switch, and a Fable cap at the wall screens it out of the Layer 2 squeeze too.
 
-**Banked resets (opt-in).** Both CLIs can reset a hit limit on the same account: Claude Code's `/limit-reset` (the `juniper_tide` server program, claimed by `POST /api/organizations/<org>/reset_rate_limits`, once a week, and the reset window still counts toward the weekly limit; the slash command is interactive-only, so tokenmaxxing makes the claim call itself with the live credential) and Codex's banked reset (`POST .../wham/rate-limit-reset-credits/consume` with an idempotency key; it refreshes the 5h and weekly windows together). `policy.preferToUseBankedReset` (a provider list, default `[]`) makes the hard path spend one before swapping, because a swap cold-starts the per-org prompt cache while a reset keeps the seat. Claude holds between the session rung and the wall only while the account still has weekly room for one more session window at its measured rate (`sessionWindowWeeklyCost`, learned from the tee within one window; unmeasured swaps), claims at the wall, and on `reset` respawns the failed turn in place. Codex rides to the wall while the usage endpoint reports a credit, consumes one, re-samples, and never restarts. Detail: `docs/switching.mdx` §Banked resets, `src/lib/bankedreset.ts`, `src/lib/codexreset.ts`.
-
 ---
 
 ## 6. Honest papercuts
@@ -120,7 +118,7 @@ The [wall policy](docs/content/docs/switching.mdx#the-wall) defines Layer 2 reco
 
 **v2:** projected-threshold pre-emption; a `UserPromptSubmit` guard that respawns *before* a turn starts when already over; Windows.
 
-**Shipped since (0.11.0):** a programmatic SDK surface (`src/sdk.ts`, the package's `exports["."]`) for pairing with the Claude Agent SDK - personal use across the owner's own pooled accounts. The Agent SDK reads credentials per subprocess spawn and has no statusLine, so the surface is boundary-driven: run the shared switch decision before a spawn (`ensureBestAccount`) and at Stop-hook turn boundaries (`stopHookCheck`), and hand the SDK a pinned real-claude path plus a full replacement env scrubbed of credential overrides (`pooledOptions`).
+**Removed (1.23.0):** the programmatic SDK surface, the stdio MCP server, and the Agent Plugin that shipped from 0.11.0 through 1.22.0. The CLI, the hooks, and the supervisor are the only surfaces.
 
 **Later:** tool-agnostic picker.
 

package/README.md

@@ -108,42 +108,15 @@ See [How switching decides](docs/content/docs/switching.mdx) for the policy and
     "greedySessionFloor": 80,
     "switchModels": ["fable"],
     "usagePollTtlMs": 90000,
-    "checkIntervalMs": 60000,
-    "preferToUseBankedReset": []
+    "checkIntervalMs": 60000
   }
 }
 ```
 
-`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; `preferToUseBankedReset` lists the providers (`claude`, `codex`) that spend a banked limit reset (Claude Code's weekly `/limit-reset`, Codex's banked reset) on the same account before swapping, which keeps the prompt cache a swap would cold-start - on Claude the seat holds past the session rung only while the account has weekly room for one more session window at its measured rate, and claims the reset at the wall.
+`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.
 
 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`).
 
-## Pairing with the Claude Agent SDK
-
-For agents you build on the [Claude Agent SDK](https://docs.claude.com/en/api/agent-sdk/overview) against **your own** pooled accounts, `tokenmaxxing` is importable as a library (your agent app must run under Bun: tokenmaxxing ships TypeScript source and uses `bun:ffi`):
-
-```ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { ensureBestAccount, pooledOptions, stopHookCheck } from "tokenmaxxing";
-
-await ensureBestAccount();
-
-for await (const message of query({
-  prompt: "...",
-  options: {
-    ...pooledOptions(),
-    hooks: { Stop: [{ hooks: [stopHookCheck] }] },
-  },
-})) {
-}
-```
-
-The loop body receives the message stream; keep the session id from the init message if you want `resume` across swaps.
-
-The SDK reads credentials when it spawns the claude subprocess and has no statusLine, so none of the CLI-side supervisor machinery applies; the integration is boundary-driven instead. `ensureBestAccount()` runs the exact greedy decision the CLI hooks and timer run (screening bars, pace-pressure target, post-swap cooldown - all shared code); like them, it deliberately does nothing until the decision engages (the active session past `policy.greedySessionFloor`, or a bar crossed), so a fresh account rides instead of churning. `pooledOptions()` pins `pathToClaudeCodeExecutable` to the real claude binary and supplies a full replacement `env` with every ambient credential override (`ANTHROPIC_API_KEY`, `CLAUDE_CODE_OAUTH_TOKEN`, ...) scrubbed, so the subprocess resolves the pool's live credential and nothing else. The pooled surface requires the default Claude Code credential store: it fails fast if `CLAUDE_CONFIG_DIR` or `CLAUDE_SECURESTORAGE_CONFIG_DIR` is set in your app's environment, because a swap would write the live credential where those point while the spawned subprocess reads the default store. `stopHookCheck` re-runs the decision at turn boundaries; a swap it lands takes effect on the next subprocess spawn (it never yanks a mid-query token). If your app loads user settings (see the SDK's `settingSources`), the Stop hook `tokenmaxxing init` installed may already fire in SDK sessions too - `stopHookCheck` makes the check explicit and works when settings are restricted.
-
-This is for pooling **your own** subscription accounts in agents you run yourself - the same personal-use posture as the CLI. Anthropic does not allow third-party products to offer claude.ai login or rate limits, including agents built on the Agent SDK; don't ship this surface to third parties.
-
 ## Codex support
 
 The same pooling works for OpenAI's Codex CLI (your own ChatGPT-subscription accounts):
@@ -156,7 +129,7 @@ codex                       # use codex as always
 
 Codex mechanics differ from Claude Code in one hard way: a running codex process refuses a credential swapped to a different account, so **a restart is the switch**. The installed Stop hook runs the same greedy pace-pressure decision at each turn boundary (usage read free from codex's own rate-limit endpoint: percentages plus absolute reset times, weekly aggregate and per-model caps alike); when it swaps, the supervisor relaunches `codex resume <session-id>` on the fresh account with the transcript intact. `tokenmaxxing switch --codex [sel]` does it manually, `status`/`watch`/`ls` show both pools.
 
-Two codex-specific facts worth knowing: codex does not run hooks it has not been told to trust, so after `init --codex` you must open codex once and trust the tokenmaxxing Stop hook via `/hooks` (auto-switching is inert until then); and codex has no cross-process lock on `auth.json`, so tokenmaxxing serializes all of its own credential writes behind its own lock and swaps only at idle turn boundaries. With `codex` in `policy.preferToUseBankedReset`, a seat at its limit consumes a banked reset credit (which refreshes both windows) and keeps running instead of restarting onto another account.
+Two codex-specific facts worth knowing: codex does not run hooks it has not been told to trust, so after `init --codex` you must open codex once and trust the tokenmaxxing Stop hook via `/hooks` (auto-switching is inert until then); and codex has no cross-process lock on `auth.json`, so tokenmaxxing serializes all of its own credential writes behind its own lock and swaps only at idle turn boundaries.
 
 ## Honest limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.20.0",
+  "version": "1.23.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",
@@ -13,13 +13,8 @@
   "bin": {
     "tokenmaxxing": "./src/main.ts"
   },
-  "exports": {
-    ".": "./src/sdk.ts",
-    "./package.json": "./package.json"
-  },
   "files": [
     "src",
-    "agent-plugin",
     "README.md",
     "DESIGN.md"
   ],
@@ -41,7 +36,6 @@
     "typescript": "^5.6.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.29.0",
     "es-toolkit": "^1.49.0",
     "ky": "^2.0.2",
     "zod": "^4.4.3"

package/src/cli/check.ts

@@ -30,7 +30,6 @@ export async function cmdCheck(args: string[] = [], json = false): Promise<numbe
       ok: true,
       due: true,
       swapped: d.swapped,
-      reset: d.reset === true,
       account: d.account?.label ?? null,
       reason: d.reason,
       waitUntil: d.waitUntil ?? null,
@@ -41,8 +40,6 @@ export async function cmdCheck(args: string[] = [], json = false): Promise<numbe
   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}`);
-  } else if (d.reset && d.account) {
-    console.log(`${c.green("↻")} reset the session limit on ${c.bold(d.account.label)} ${next}`);
   } 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}`);
   } else {

package/src/cli/config.ts

@@ -21,7 +21,6 @@ export const KNOWN_KEYS = [
   "policy.usagePollTtlMs",
   "policy.maxWaitMs",
   "policy.checkIntervalMs",
-  "policy.preferToUseBankedReset",
 ] as const;
 
 const TIMER_REWRITE_NOTE = "note: run `tokenmaxxing init` to rewrite the periodic timer at the new tick";

package/src/cli/status.ts

@@ -12,7 +12,7 @@ import { isCodexExhausted } from "../lib/codexpick.ts";
 import { codexLimitLabel, isSessionWindow } from "../lib/codexusage.ts";
 import { bar, c, claudeTierLabel, count, emitJson, fmtAgo } from "./render.ts";
 import { gatedFamilies, type FullUsage } from "../lib/usage.ts";
-import { BankedResetRecordSchema, ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
+import { ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
 
 const SampleReportSchema = z.discriminatedUnion("ok", [
   z.object({ ok: z.literal(true), source: z.enum(["statusline", "probe"]) }),
@@ -35,9 +35,6 @@ const ClaudeStatusAccountSchema = z.object({
   pingError: z.string().nullable(),
   pingRejected: z.boolean(),
   pinged: z.boolean(),
-  bankedReset: BankedResetRecordSchema.nullable(),
-  sessionWindowWeeklyCost: z.number().nullable(),
-  sessionWindowFamilyCosts: z.record(z.string(), z.number()).nullable(),
 });
 type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
 
@@ -59,7 +56,6 @@ const CodexStatusAccountSchema = z.object({
     .nullable(),
   usageAt: z.number().nullable(),
   sample: SampleReportSchema,
-  resetCredits: z.number().int().nullable(),
 });
 type CodexStatusAccount = z.infer<typeof CodexStatusAccountSchema>;
 
@@ -158,7 +154,6 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
         a.lastUsageAt = viaTee && teeAt != null ? (live?.sampledAt ?? teeAt) : Date.now();
-        if (viaTee && live?.sessionWindowWeeklyCost != null) a.sessionWindowWeeklyCost = live.sessionWindowWeeklyCost;
         if (Object.keys(outcome.usage.perModel).length > 0) {
           a.lastPerModel = outcome.usage.perModel;
           a.lastPerModelAt = viaTee && modelUsage ? (modelUsage.sampledAt ?? modelUsage.ts) : a.lastUsageAt;
@@ -178,7 +173,6 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
   const families = gatedFamilies(loadUsage()?.model ?? null, cfg.policy.switchModels);
   const bars = effectiveBars(cfg, { accounts: idx.accounts, now, switchFamilies: families });
   const liveAccount = readOAuthAccount()?.accountUuid ?? null;
-  const liveModelUsage = loadModelUsage();
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
   const accounts = ordered.map((a): ClaudeStatusAccount => {
     const sampled = samples.get(a.accountUuid) ?? { outcome: { ok: false, reason: "not sampled" }, viaTee: false };
@@ -201,9 +195,6 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
       pingError: sampled.outcome.pingError ?? null,
       pingRejected: sampled.outcome.pingRejected === true,
       pinged: pings.has(a.accountUuid) && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
-      bankedReset: a.bankedReset ?? null,
-      sessionWindowWeeklyCost: a.sessionWindowWeeklyCost ?? null,
-      sessionWindowFamilyCosts: liveModelUsage && liveModelUsage.account === a.accountUuid ? (liveModelUsage.familyCosts ?? null) : null,
     };
   });
   return {
@@ -231,7 +222,7 @@ async function collectCodex(input: { cfg: Config; now: number }): Promise<Status
         const outcome = await sampleCodexAccount({ account, liveAccountId: liveId, now });
         outcomes.set(account.accountId, outcome);
         if (outcome.ok) {
-          account.lastUsage = { aggregate: outcome.usage.aggregate, perLimit: outcome.usage.perLimit, resetCredits: outcome.usage.resetCredits, reachedType: outcome.usage.reachedType };
+          account.lastUsage = { aggregate: outcome.usage.aggregate, perLimit: outcome.usage.perLimit };
           account.lastUsageAt = Date.now();
           if (outcome.usage.email != null) account.email = outcome.usage.email;
           if (outcome.usage.planType != null) account.planType = outcome.usage.planType;
@@ -272,7 +263,6 @@ async function collectCodex(input: { cfg: Config; now: number }): Promise<Status
         : null,
       usageAt: account.lastUsageAt ?? null,
       sample: outcome.ok ? { ok: true, source: "probe" } : { ok: false, reason: outcome.reason },
-      resetCredits: usage?.resetCredits ?? null,
     };
   });
   return { bars, accounts };

package/src/entries/codexstophook.ts

@@ -99,7 +99,6 @@ export async function handleCodexStop(input: { rawStdin: string }): Promise<void
     }
     if (await promoteReconcile({ supervisorId, sessionId })) return;
     const decision = await evaluateAndMaybeSwapCodex({});
-    if (decision.reset && decision.account) log("codexstop.reset", { account: decision.account.accountId.slice(0, 8) });
     if (decision.swapped && decision.account) {
       mkdirSync(codexPaths.respawnDir, { recursive: true });
       const payload = CodexRespawnMarkerSchema.parse({

package/src/entries/stopfailurehook.ts

@@ -4,13 +4,12 @@ import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { enforcedWindowMs, evaluateAndMaybeSwap, postSwapProof, recordEnforcedLimit } from "../lib/decide.ts";
-import { loadConfig, loadLastSeatChangeAt, loadLastSwapAt } from "../lib/state.ts";
+import { loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 export const RETRIGGER_PROMPT = "Continue where the previous turn left off; it was interrupted by a usage limit and tokenmaxxing switched accounts.";
-export const RETRIGGER_RESET_PROMPT = "Continue where the previous turn left off; it was interrupted by the session limit and tokenmaxxing reset that limit on the same account.";
 
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
@@ -53,11 +52,11 @@ export async function runStopFailureHook(): Promise<number> {
 
     let enforced: EnforcedLimit | null = null;
     if (limit && found && account) {
-      if (postSwapProof({ swapAt: limit.kind === "session" ? loadLastSeatChangeAt() : loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
+      if (postSwapProof({ swapAt: loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
         const stamp = await recordEnforcedLimit({ limit, account, now });
         log("stopfailure.enforced", { kind: limit.kind, family: limit.kind === "model" ? limit.family : undefined, outcome: stamp.outcome, resetsAt: stamp.resetsAt, subagent: !mainLoop });
         if (stamp.outcome !== "account-moved") {
-          enforced = { account, kind: limit.kind, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
+          enforced = { account, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
         }
       } else {
         log("stopfailure.unproven", { kind: limit.kind });
@@ -72,20 +71,18 @@ export async function runStopFailureHook(): Promise<number> {
     }
 
     const decision = await evaluateAndMaybeSwap(now, canPause && enforced != null, enforced);
-    const reset = decision.reset === true;
-    if (enforced && canPause && pinnedSid && decision.account && (decision.swapped || decision.waitUntil !== undefined || reset)) {
+    if (enforced && canPause && pinnedSid && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       const marker = join(paths.respawnDir, pinnedSid);
       const payload = RespawnMarkerSchema.parse({
         account: decision.account.label,
         ts: Date.now(),
         waitUntil: decision.waitUntil ?? now,
         sessionId: stdinSid ?? pinnedSid,
-        prompt: reset ? RETRIGGER_RESET_PROMPT : RETRIGGER_PROMPT,
+        prompt: RETRIGGER_PROMPT,
         ...(launchedAt != null ? { launchedAt } : {}),
-        ...(reset ? { reset } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));
-      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.accountUuid.slice(0, 8), waitUntil: payload.waitUntil, reset });
+      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.accountUuid.slice(0, 8), waitUntil: payload.waitUntil });
     } else {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
     }

package/src/entries/stophook.ts

@@ -25,7 +25,6 @@ export async function runStopHook(): Promise<number> {
   try {
     const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null;
     const decision = await evaluateAndMaybeSwap(Date.now(), canPause);
-    if (decision.reset && decision.account) log("stop.reset", { account: decision.account.accountUuid.slice(0, 8) });
     if (decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       log(decision.swapped ? "stop.swapped" : "stop.wait", { account: decision.account.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
       if (decision.waitUntil !== undefined && canPause && pinnedSid) {

package/src/entries/supervisor.ts

@@ -286,8 +286,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       respawns++;
       if (m.waitUntil > Date.now()) {
         if (await countdownWait(m.account, m.waitUntil)) overriddenUntil = m.waitUntil;
-      } else if (m.reset) process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: reset the session limit on ${m.account} - resuming...\x1b[0m\n`);
-      else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
+      } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
       saveSessionFlags(m.sessionId, persistable, process.cwd());
       launchArgs = ["--resume", m.sessionId, ...persistable, ...(m.prompt ? ["--", m.prompt] : [])];
       continue;

package/src/lib/codexdecide.ts

@@ -11,7 +11,6 @@ import { performCodexSwap } from "./codexswap.ts";
 import { CodexInvalidGrantError, refreshCodexAuth } from "./codexoauth.ts";
 import { fetchCodexUsage } from "./codexusage.ts";
 import { codexIdentityOf, isCodexAccessExpiring, readLiveCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
-import { codexBankedResetVerdict, consumeLiveCodexBankedReset } from "./codexreset.ts";
 import { liveCodexAccountId } from "./codexsample.ts";
 import { livingCodexPresences, presentCodexAccountIds, targetableCodexAccounts } from "./codexpresence.ts";
 import { terminalBars } from "./picker.ts";
@@ -22,7 +21,6 @@ const CodexSwapDecisionSchema = z.object({
   swapped: z.boolean(),
   account: CodexAccountSchema.nullable(),
   reason: z.string(),
-  reset: z.boolean().optional(),
 });
 export type CodexSwapDecision = z.infer<typeof CodexSwapDecisionSchema>;
 
@@ -53,7 +51,7 @@ async function sampleLiveOntoOwner(input: { now: number }): Promise<string | nul
     writeParkedCodexAuth({ credFile: owner.credFile, auth: live });
   }
   const usage = await fetchCodexUsage({ auth: live });
-  owner.lastUsage = { aggregate: usage.aggregate, perLimit: usage.perLimit, resetCredits: usage.resetCredits, reachedType: usage.reachedType };
+  owner.lastUsage = { aggregate: usage.aggregate, perLimit: usage.perLimit };
   owner.lastUsageAt = now;
   if (usage.email != null) owner.email = usage.email;
   if (usage.planType != null) owner.planType = usage.planType;
@@ -139,28 +137,6 @@ export async function evaluateAndMaybeSwapCodex(input: { now?: number }): Promis
       isCodexExhausted({ account: active, thresholds: bars, now });
     if (!engaged) return { swapped: false, account: null, reason: "under-threshold-or-stale" };
 
-    if (cfg.policy.preferToUseBankedReset.includes("codex") && active.needsReauth !== true) {
-      const seat = active;
-      const verdict = codexBankedResetVerdict({ account: seat, thresholds: bars, now, pollTtlMs: cfg.policy.usagePollTtlMs });
-      if (verdict === "hold") {
-        log("codexdecide.banked_reset_hold", { account: seat.accountId.slice(0, 8) });
-        return { swapped: false, account: seat, reason: "banked-reset-hold" };
-      }
-      if (verdict === "claim") {
-        const claim = await consumeLiveCodexBankedReset({ account: seat, now });
-        if (claim === "reset") {
-          try {
-            await sampleLiveOntoOwner({ now: Date.now() });
-          } catch (e) {
-            log("codexdecide.resample_failed", { err: e instanceof Error ? e.message : String(e) });
-          }
-          const fresh = loadCodexAccounts().accounts.find((account) => account.accountId === activeId) ?? seat;
-          if (fresh.lastUsage) postSwapResweep({ liveAccountId: activeId, bars, now });
-          return { swapped: false, account: fresh, reason: "banked-reset", reset: true };
-        }
-      }
-    }
-
     if (!isCodexExhausted({ account: active, thresholds: bars, now })) {
       while (true) {
         const current = loadCodexAccounts();

package/src/lib/codexpick.ts

@@ -3,20 +3,20 @@ import { nextWeeklyReset } from "./picker.ts";
 import { isSessionWindow, weeklyWindowOf } from "./codexusage.ts";
 import type { CodexAccount, CodexWindow, Thresholds } from "./types.ts";
 
-export function liveUsed(input: { window: CodexWindow; now: number; sampledAt: number | null }): number {
+function liveUsed(input: { window: CodexWindow; now: number; sampledAt: number | null }): number {
   const { window, now, sampledAt } = input;
   if (window.resetsAt != null) return window.resetsAt <= now ? 0 : window.usedPercentage;
   if (sampledAt != null && window.windowSeconds != null && now >= sampledAt + window.windowSeconds * 1000) return 0;
   return window.usedPercentage;
 }
 
-export function allWindows(account: CodexAccount): CodexWindow[] {
+function allWindows(account: CodexAccount): CodexWindow[] {
   const usage = account.lastUsage;
   if (!usage) return [];
   return [...usage.aggregate, ...Object.values(usage.perLimit).flat()];
 }
 
-export function barFor(input: { window: CodexWindow; thresholds: Thresholds }): number {
+function barFor(input: { window: CodexWindow; thresholds: Thresholds }): number {
   return isSessionWindow({ window: input.window }) ? input.thresholds.session : input.thresholds.weekly;
 }
 

package/src/lib/codexusage.ts

@@ -25,8 +25,6 @@ const WireRateLimitSchema = z.looseObject({
   secondary_window: WireWindowSchema.nullish(),
 });
 
-const WireReachedTypeSchema = z.union([z.string(), z.looseObject({ type: z.string().nullish(), kind: z.string().nullish() })]).nullish().catch(null);
-
 const WireUsageSchema = z.looseObject({
   account_id: z.string(),
   email: z.string().nullish(),
@@ -35,8 +33,6 @@ const WireUsageSchema = z.looseObject({
   additional_rate_limits: z
     .array(z.looseObject({ limit_name: z.string(), rate_limit: WireRateLimitSchema.nullish() }))
     .nullish(),
-  rate_limit_reset_credits: z.looseObject({ available_count: z.number().int().nullish() }).nullish(),
-  rate_limit_reached_type: WireReachedTypeSchema,
 });
 
 function toWindows(rateLimit: z.infer<typeof WireRateLimitSchema> | null | undefined): CodexWindow[] {
@@ -96,11 +92,6 @@ export async function fetchCodexUsage(input: { auth: CodexAuthJson }): Promise<C
     planType: wire.plan_type ?? null,
     aggregate: toWindows(wire.rate_limit),
     perLimit,
-    resetCredits: wire.rate_limit_reset_credits?.available_count ?? null,
-    reachedType:
-      typeof wire.rate_limit_reached_type === "string"
-        ? wire.rate_limit_reached_type
-        : (wire.rate_limit_reached_type?.type ?? wire.rate_limit_reached_type?.kind ?? null),
   });
 }
 

package/src/lib/decide.ts

@@ -2,9 +2,8 @@ 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, measureFamilyWindow, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.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 { readOAuthAccount } from "./claudejson.ts";
-import { bankedResetBelievedAvailable, claimBankedReset } from "./bankedreset.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";
@@ -17,7 +16,6 @@ const SwapDecisionSchema = z.object({
   account: AccountSchema.nullable(),
   reason: z.string(),
   waitUntil: z.number().optional(),
-  reset: z.boolean().optional(),
 });
 export type SwapDecision = z.infer<typeof SwapDecisionSchema>;
 
@@ -40,17 +38,6 @@ function capForFamily(mu: ModelUsageState, family: string, now: number): UsageWi
   return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: mu.sampledAt ?? mu.ts, now }));
 }
 
-function familyCaps(perModel: Record<string, UsageWindow>, families: string[]): Record<string, number> {
-  return Object.fromEntries(
-    families.flatMap((family) => {
-      const rows = Object.entries(perModel)
-        .filter(([k]) => familyTokens(k).includes(family))
-        .map(([, w]) => w.usedPercentage);
-      return rows.length > 0 ? [[family, Math.max(...rows)] as const] : [];
-    }),
-  );
-}
-
 function overlayLive(accounts: Account[], u: UsageState | null, mu: ModelUsageState | null, account: string | null): Account[] {
   return accounts.map((a) => {
     if (account == null || a.accountUuid !== account) return a;
@@ -79,41 +66,6 @@ function needsPerModel(u: UsageState | null, cfg: Config): boolean {
   return u != null && gatedFamilies(u.model, cfg.policy.switchModels).length > 0;
 }
 
-const BankedVerdictSchema = z.enum(["hold", "claim", "pass"]);
-type BankedVerdict = z.infer<typeof BankedVerdictSchema>;
-
-function bankedResetVerdict(input: {
-  seat: Account;
-  u: UsageState | null;
-  mu: ModelUsageState | null;
-  enforced: EnforcedLimit | null;
-  cfg: Config;
-  bars: Thresholds;
-  switchFamilies: string[];
-  now: number;
-}): BankedVerdict {
-  const { seat, u, mu, enforced, cfg, bars, switchFamilies, now } = input;
-  if (enforced && enforced.kind !== "session") return "pass";
-  if (!u || u.account !== seat.accountUuid) return "pass";
-  if (!bankedResetBelievedAvailable(seat, now)) return "pass";
-  if (u.sampledAt == null || now - u.sampledAt > cfg.policy.usagePollTtlMs) return "pass";
-  const cost = u.sessionWindowWeeklyCost ?? seat.sessionWindowWeeklyCost;
-  if (cost == null) return "pass";
-  const weeklyUsed = liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now });
-  if (weeklyUsed + cost > bars.weekly) return "pass";
-  const muSame = mu && mu.account === seat.accountUuid && now - (mu.sampledAt ?? mu.ts) <= cfg.policy.usagePollTtlMs ? mu : null;
-  for (const family of switchFamilies) {
-    const cap = muSame ? capForFamily(muSame, family, now) : undefined;
-    if (!cap || !muSame) return "pass";
-    const familyCost = muSame.familyCosts?.[family];
-    if (familyCost == null) return "pass";
-    const capUsed = liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: muSame.sampledAt ?? muSame.ts, now });
-    if (capUsed + familyCost > bars.weekly) return "pass";
-  }
-  const atWall = enforced?.kind === "session" || liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= hardBars(cfg).session;
-  return atWall ? "claim" : "hold";
-}
-
 function isEngaged(u: UsageState | null, mu: ModelUsageState | null, account: string | null, bars: Thresholds, cfg: Config, now: number): boolean {
   if (!u || !account || u.account !== account) return false;
   return liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= cfg.policy.greedySessionFloor || isOver(u, mu, account, bars, cfg, now);
@@ -149,7 +101,6 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
   if (account && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
     const full = await probeUsage();
     const ts = Date.now();
-    const prevMu = mu;
     if (readOAuthAccount()?.accountUuid === account) {
       if (full) {
         const teed = loadUsageSnapshot();
@@ -161,7 +112,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           writeUsage(u);
           uAt = ts;
         }
-        mu = { perModel: full.perModel, account, ts, sampledAt: ts, ...measureFamilyWindow(prevMu, account, full.session, familyCaps(full.perModel, cfg.policy.switchModels)) };
+        mu = { perModel: full.perModel, account, ts, sampledAt: ts };
         saveModelUsage(mu);
         const expected = gatedFamilies(u?.model ?? null, cfg.policy.switchModels);
         const rows = Object.keys(full.perModel);
@@ -169,7 +120,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           log("usage.no_permodel_row", { families: expected.join(","), rows: rows.join(",") });
         }
       } else {
-        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined, ...measureFamilyWindow(prevMu, account, null, {}) };
+        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined };
         saveModelUsage(mu);
       }
     }
@@ -224,7 +175,6 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       if (tee && tee.state.account === account2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
         active.lastUsage = { fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay };
         active.lastUsageAt = tee.state.sampledAt ?? tee.at;
-        if (tee.state.sessionWindowWeeklyCost != null) active.sessionWindowWeeklyCost = tee.state.sessionWindowWeeklyCost;
         sampled = true;
       }
       if (mu2 && mu2.account === account2 && Object.keys(mu2.perModel).length > 0) {
@@ -322,26 +272,12 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
     };
     if (!enforced2 && !isOver(u2, mu2, account2, bars, cfg, now)) return greedy(cfg.policy.greedySwapMargin);
 
-    const resetPreferred = cfg.policy.preferToUseBankedReset.includes("claude");
-    let resetTried = false;
     while (true) {
       const cur = loadAccounts();
       const seat = seatOf(cur);
       const pool = usable(cur.accounts);
       const thresholds = barsOf(cur.accounts);
       if (!enforced2 && seat && !seat.needsReauth && !isExhausted(seat, { now, thresholds, currentAccountUuid: null, switchFamilies })) return greedy(0);
-      if (resetPreferred && !resetTried && seat && !seat.needsReauth) {
-        const verdict = bankedResetVerdict({ seat, u: u2, mu: mu2, enforced: enforced2, cfg, bars: thresholds, switchFamilies, now });
-        if (verdict === "hold") {
-          log("decide.banked_reset_hold", { account: seat.accountUuid.slice(0, 8), enforced: enforced2 != null });
-          return { swapped: false, account: seat, reason: "banked-reset-hold" };
-        }
-        if (verdict === "claim") {
-          resetTried = true;
-          const claim = await claimBankedReset({ account: seat });
-          if (claim === "reset") return { swapped: false, account: seat, reason: "banked-reset", reset: true };
-        }
-      }
       const ctx = { now, thresholds, currentAccountUuid: seat?.accountUuid ?? null, currentOrganizationUuid: seat?.organizationUuid ?? null, orgAffinityFloor: cfg.policy.greedySessionFloor, switchFamilies };
       const best = pickBest(pool, ctx);
       if (!best) break;
@@ -452,12 +388,11 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; account
         account: accountUuid,
         ts: now,
         sampledAt: resetsAt == null ? now : sampledAt ?? now,
-        ...measureFamilyWindow(muSame, accountUuid, null, {}),
       });
       log("usage.enforced_limit", { kind: limit.kind, family: limit.family, resetsAt });
       return { outcome: "stamped", resetsAt };
     }
-    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt, ...measureFamilyWindow(muSame, accountUuid, null, {}) });
+    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt });
     if (account && limit.resetsAt != null) {
       account.enforcedUntil = limit.resetsAt;
       saveAccounts(idx);

package/src/lib/paths.ts

@@ -19,7 +19,6 @@ export const paths = {
   usageJson: join(TM_HOME, "usage.json"),
   modelUsageJson: join(TM_HOME, "model-usage.json"),
   lastSwapJson: join(TM_HOME, "lastswap.json"),
-  lastResetJson: join(TM_HOME, "lastreset.json"),
   depletedJson: join(TM_HOME, "depleted.json"),
   nextCheckJson: join(TM_HOME, "nextcheck.json"),
   respawnDir: join(TM_HOME, "respawn"),