claude-usage-limits 1.9.0 → 1.9.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "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.1",
   "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.1",
   "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

@@ -130,7 +130,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 +178,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/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.
@@ -184,7 +200,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 +215,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) {