claude-usage-limits 1.9.0 → 1.9.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Puts your remaining Claude Code usage limit into Claude's context before every prompt, so it opens with what fits in the budget instead of starting work that gets cut off. Reports headroom as turns rather than percentages, prices a job before you start it, and detects your plan tier.",
   "author": {
     "name": "Ridelink",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "usage-limits",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Reports how much of your Codex usage limit is left as turns of work rather than a percentage, prices a job before you start it, and counts the other agents sharing the same budget.",
   "author": {
     "name": "Ridelink",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-usage-limits",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Puts your remaining Claude Code usage limit into Claude's context before every prompt, so it opens with what fits in the budget instead of starting work that gets cut off. Reports headroom as turns rather than percentages, prices a job before you start it, and detects your plan tier.",
   "keywords": [
     "claude",

package/skills/usage-limits/references/how-it-works.md

@@ -118,6 +118,14 @@ really somewhere in 1.5 to 2.5. At low readings the projection can be off by
 a quarter or more in either direction. The report flags this below 5 percent.
 Above about 20 percent it tightens up considerably.
 
+**Two files can claim to be the account state.** The meter lives in
+`~/.claude.json`, but a Claude Code migration also writes a small
+`~/.claude/.claude.json` holding machine ids and no meter at all. Whichever
+one actually carries `cachedUsageUtilization` is the one read. Choosing on
+existence alone found the stub, concluded there was no Claude snapshot, and
+sent host detection off to Codex, which reported that agent's meter inside a
+Claude session.
+
 **One machine only.** Transcripts are local. Usage from another machine, from
 claude.ai, or from a cloud session counts against the same limit but leaves no
 local record. The percentages stay correct; the calibration reads low, which
@@ -130,7 +138,17 @@ calculation.
 **List prices are a proxy.** The rate table is first-party API pricing. How a
 subscription plan actually meters usage is not published, and the weighting
 almost certainly is not exactly this. It is close enough for ratios, which is
-all it is used for.
+all it is used for. No published or community source shows the meter weighting
+models differently from their dollar prices, so calibrating dollars against
+your own meter remains the best method anyone outside Anthropic has.
+
+**The snapshot is slow by design.** The percentages come from Claude Code's
+own cache of the account meter, which refreshes on its own schedule - roughly
+hourly in practice, because the endpoint behind it rate-limits aggressive
+polling. Between refreshes every figure here is the last real reading plus
+arithmetic. That is why an old snapshot is reported as a floor with its age
+attached rather than dressed up as a current percentage, and why `/usage` is
+the one way to force a fresh reading.
 
 **A reset time can be in the past.** The cache refreshes when Claude Code
 talks to the API, so an idle spell leaves it behind. A window whose `resets_at`
@@ -168,6 +186,13 @@ immediately. Re-run the report if the shape of the work changes.
 The rate table in `scripts/usage.js` is a plain object at the top of the file.
 When new models ship, add a row.
 
+A bracketed suffix on a model id (`claude-sonnet-5[1m]`) is stripped before
+the lookup: it marks a context-window variant of the same model, not a new
+one. Cache reads price at a tenth of the input rate unless a row carries a
+`cacheRead` figure of its own - Fable and Mythos 5.1 price reads outright at
+$0.25 per million, far under the tenth rule, and reads are the dominant input
+in exactly the long sessions where the difference matters.
+
 Until someone does, a model this table has not seen is priced at the average of
 the family its name contains: an unreleased `claude-opus-5-2` is charged at the
 mean of every Opus rate on record. Averaging assumes nothing about which

package/skills/usage-limits/scripts/host.js

@@ -38,15 +38,28 @@ function exists(file) {
 
 // Claude Code only writes this once it has talked to the API, so its presence
 // is a stronger signal than the directory existing.
-function claudeHasSnapshot() {
+//
+// Look in both places rather than stopping at whichever exists. A migration
+// leaves a small ~/.claude/.claude.json carrying machine ids and no meter,
+// while the account state stays in the home directory file; stopping at the
+// stub answered "no Claude snapshot" on a machine plainly running Claude Code,
+// and detection then fell through to Codex and reported its meter instead.
+function claudeSnapshotFile() {
   const scoped = path.join(claudeConfigDir(), '.claude.json');
-  const file = exists(scoped) ? scoped : path.join(os.homedir(), '.claude.json');
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return Boolean(parsed && parsed.cachedUsageUtilization);
-  } catch (err) {
-    return false;
+  const home = path.join(os.homedir(), '.claude.json');
+  for (const file of scoped === home ? [home] : [scoped, home]) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (parsed && parsed.cachedUsageUtilization) return file;
+    } catch (err) {
+      // Missing or unreadable is just "not this one".
+    }
   }
+  return null;
+}
+
+function claudeHasSnapshot() {
+  return claudeSnapshotFile() !== null;
 }
 
 function codexHasSessions() {
@@ -91,6 +104,7 @@ module.exports = {
   codexHome,
   claudeConfigDir,
   claudeHasSnapshot,
+  claudeSnapshotFile,
   codexHasSessions,
   exists,
 };

package/skills/usage-limits/scripts/usage.js

@@ -47,8 +47,12 @@ const MINUTE = 60 * 1000;
 const HOUR = 60 * MINUTE;
 const DAY = 24 * HOUR;
 
-// USD per million tokens, first-party API rates.
+// USD per million tokens, first-party API rates. `cacheRead` is an absolute
+// $/MTok override for the few models that price reads outright instead of at
+// a tenth of input; everything else uses the CACHE_READ multiplier below.
 const RATES = {
+  'claude-fable-5-1': { input: 10, output: 50, cacheRead: 0.25 },
+  'claude-mythos-5-1': { input: 10, output: 50, cacheRead: 0.25 },
   'claude-fable-5': { input: 10, output: 50 },
   'claude-mythos-5': { input: 10, output: 50 },
   'claude-opus-5': { input: 5, output: 25 },
@@ -91,9 +95,21 @@ function familyAverage(family, table) {
   return { input: input / members.length, output: output / members.length };
 }
 
+// Claude Code aliases and some transcript records carry a bracketed variant
+// suffix - "fable[1m]" is the 1M-context toggle on the same model, not a
+// different one. Left in place it misses the exact rate lookup and lands on
+// the family average, which is wrong whenever a family's members price
+// differently (sonnet 5 at $2 against sonnet 4.6 at $3).
+function normalizeModel(model) {
+  return String(model || '')
+    .toLowerCase()
+    .replace(/\[[^\]]*\]\s*$/, '')
+    .trim();
+}
+
 // Whether the price came from the table or from an assumption.
 function isKnownModel(model) {
-  return Object.prototype.hasOwnProperty.call(RATES, String(model || '').toLowerCase());
+  return Object.prototype.hasOwnProperty.call(RATES, normalizeModel(model));
 }
 
 // Cache traffic is priced as a multiple of the input rate.
@@ -169,10 +185,35 @@ function configDir() {
 
 // The CLI keeps its account state in ~/.claude.json, or next to the config
 // directory when CLAUDE_CONFIG_DIR moves it.
-function accountFile() {
+//
+// Both can exist at once, and the one in the config directory is not
+// necessarily the one with the meter in it: a Claude Code migration writes a
+// small ~/.claude/.claude.json holding machine ids and migration flags while
+// the account state, including cachedUsageUtilization, stays in the home
+// directory file. Picking on existence alone found that stub, reported no
+// snapshot, and sent host detection off to Codex - which is how a Claude
+// session ends up quoting another agent's meter entirely. So choose the file
+// that actually carries a snapshot, and only fall back to existence.
+function accountFiles() {
   const scoped = path.join(configDir(), '.claude.json');
-  if (fs.existsSync(scoped)) return scoped;
-  return path.join(os.homedir(), '.claude.json');
+  const home = path.join(os.homedir(), '.claude.json');
+  return scoped === home ? [home] : [scoped, home];
+}
+
+function hasSnapshot(file) {
+  const parsed = readJson(file);
+  return Boolean(parsed && parsed.cachedUsageUtilization);
+}
+
+function accountFile() {
+  const candidates = accountFiles();
+  for (const file of candidates) {
+    if (hasSnapshot(file)) return file;
+  }
+  for (const file of candidates) {
+    if (fs.existsSync(file)) return file;
+  }
+  return candidates[candidates.length - 1];
 }
 
 function readJson(file) {
@@ -184,7 +225,7 @@ function readJson(file) {
 }
 
 function rateFor(model) {
-  const id = String(model || '').toLowerCase();
+  const id = normalizeModel(model);
   if (RATES[id]) return RATES[id];
   return familyAverage(familyOf(id)) || FALLBACK_RATE;
 }
@@ -199,16 +240,26 @@ function costOf(usage, model) {
 
   let writeUnits = write5m * CACHE_WRITE_5M + write1h * CACHE_WRITE_1H;
   if (writeUnits === 0) {
-    // Older records only carry the undifferentiated total.
+    // Older records only carry the undifferentiated total. Five minutes is
+    // the default TTL, so that is the assumption; an old-format one-hour
+    // session is under-priced by it, but assuming 2x would overcharge the
+    // common case to be right about the rare one.
     writeUnits = (usage.cache_creation_input_tokens || 0) * CACHE_WRITE_5M;
   }
 
-  const inputUnits =
-    (usage.input_tokens || 0) +
-    (usage.cache_read_input_tokens || 0) * CACHE_READ +
-    writeUnits;
+  // Reads price at a tenth of the input rate unless the model prices them
+  // outright. The distinction matters most exactly where reads dominate: a
+  // long session re-reads its whole context every turn, and pricing Fable
+  // 5.1's $0.25 reads by the tenth rule would overstate that spend fourfold.
+  const readTokens = usage.cache_read_input_tokens || 0;
+  const readCost = Number.isFinite(rate.cacheRead)
+    ? readTokens * rate.cacheRead
+    : readTokens * CACHE_READ * rate.input;
 
-  return (inputUnits * rate.input + (usage.output_tokens || 0) * rate.output) / 1e6;
+  const inputUnits = (usage.input_tokens || 0) + writeUnits;
+  return (
+    (inputUnits * rate.input + readCost + (usage.output_tokens || 0) * rate.output) / 1e6
+  );
 }
 
 function tokensOf(usage) {
@@ -1749,6 +1800,25 @@ function statusLine(collected) {
       unreported: snapshot.utilization === 0 && !Number.isFinite(resetsAt),
     });
   }
+
+  // The per-model weeklies are not bucket keys, they are entries in the
+  // account's own `limits` list, so a loop over the bucket table never saw
+  // them. On a plan where the Fable weekly is the limit that actually binds,
+  // that meant the status line quoting the shared weekly at 24% while the
+  // window about to stop the work sat at 76, which is the wrong number in the
+  // most convincing possible place.
+  for (const limit of limitWindows(utilization)) {
+    if (!limit.family) continue;
+    const msToReset = Number.isFinite(limit.resetsAt) ? limit.resetsAt - now : null;
+    parts.push({
+      label: limit.family,
+      percent: limit.percent,
+      msToReset,
+      stale: msToReset !== null && msToReset <= 0,
+      unreported: false,
+    });
+  }
+
   if (!parts.length) return '';
 
   const trusted = parts.filter((part) => !part.stale && !part.unreported);
@@ -2350,6 +2420,7 @@ module.exports = {
   SATURATION_LIMIT,
   MIN_BASELINE_TURNS,
   MIN_BASELINE_PERCENT,
+  accountFile,
   buildWindows,
   limitWindows,
   lastRejections,