claude-usage-limits 1.3.0 → 1.4.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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/README.md

@@ -428,6 +428,13 @@ Good enough to plan with, not a bill. The honest caveats:
 - A model released after this table was written is priced at its family's
   average rate, and the report marks those rows with an asterisk rather than
   passing the guess off as a published price.
+- Time of day is not modelled. Anthropic used to shrink the five-hour limit
+  during peak hours, but removed that on 6 May 2026 for Pro and Max while
+  doubling the limits. If demand-based limits ever return, the numbers here
+  follow automatically, because they are calibrated from what your traffic did
+  to the meter rather than from an assumption about the clock.
+- The turn cost behind "turns of headroom" is a median over at least five
+  turns, so one compaction cannot define your pace.
 - The cache only refreshes when Claude Code talks to the API, so after a gap it
   can be hours old and its 5-hour window long since rolled over. Dropping that
   window would hide the limit that actually stops short work, so it gets rebuilt
@@ -464,7 +471,7 @@ test/                             node --test, no dependencies
 node --test
 ```
 
-142 tests over the pricing, the window arithmetic, plan and credit detection,
+148 tests over the pricing, the window arithmetic, plan and credit detection,
 the status line, the before-prompt line, job forecasting, per-project
 attribution, the CLI, packaging, and the settings save/restore.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-usage-limits",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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

@@ -124,6 +124,26 @@ window that no longer exists. Those are marked stale, excluded from the
 binding choice, and never used for projections, because treating one as
 current would report an empty budget at the exact moment the budget came back.
 
+**Time of day is not modelled, and does not need to be.** Anthropic used to
+shrink the Claude Code five-hour limit during peak hours, so the same work cost
+more of it in the afternoon. That ended on 6 May 2026, when the five-hour
+limits were doubled and, in Anthropic's words, they removed "the peak hours
+limit reduction on Claude Code for Pro and Max accounts". So there is no
+peak-hour penalty to model today.
+
+If one ever returns, nothing here needs changing. Every figure is calibrated
+from what your own traffic actually did to the meter, so if a point of budget
+starts costing more at four in the afternoon, the measured dollars-per-point
+moves with it and the headroom follows. That is the advantage of measuring
+rather than assuming: the tool does not need to know why a point got dearer.
+
+**One turn is not a pace.** The turn cost behind "turns of headroom" is the
+median of a sample, not the mean, and never from fewer than five turns. A
+compaction or a large file read can cost ten times an ordinary turn, and one of
+those landing in a thin sample once put a window that was 13 percent full at
+nine turns remaining. Thin samples widen to the whole window, and then to
+everything on record.
+
 **Pace is not a promise.** Turns left assumes the next turns look like the last
 hour's. A debugging spiral or a large file read breaks that assumption
 immediately. Re-run the report if the shape of the work changes.

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

@@ -355,6 +355,36 @@ function byModel(events) {
   return list;
 }
 
+const MIN_PACE_SAMPLE = 5;
+
+// The middle turn, not the mean, and never from a sample so small that one
+// turn defines the pace. A compaction or a big file read can cost ten times an
+// ordinary turn, and treating that as "the" turn cost sends the headroom
+// estimate swinging: a single $7 turn once put a 13% full window at nine turns
+// left. Too few recent turns to be sure, so widen to the whole window.
+function typicalTurnCost(recentEvents, windowEvents, allEvents, minSample) {
+  const floor = Number.isFinite(minSample) ? minSample : MIN_PACE_SAMPLE;
+
+  // What a turn costs is a fact about how you work, not about which budget it
+  // is being measured against, so a thin window borrows from a wider sample
+  // rather than inventing a figure from two turns.
+  const tiers = [recentEvents, windowEvents, allEvents];
+  let pool = [];
+  for (const tier of tiers) {
+    if (tier && tier.length >= floor) {
+      pool = tier;
+      break;
+    }
+    if (tier && tier.length > pool.length) pool = tier;
+  }
+  const costs = pool
+    .map((event) => event.cost)
+    .filter((cost) => Number.isFinite(cost) && cost > 0)
+    .sort((a, b) => a - b);
+  if (!costs.length) return null;
+  return costs[Math.floor(costs.length / 2)];
+}
+
 function dominantEffort(events) {
   const counts = new Map();
   for (const event of events) {
@@ -527,12 +557,11 @@ function buildWindow(spec, snapshot, events, now, options) {
     // The API reports whole numbers, so a low reading is a wide bracket.
     window.coarse = percent < 5;
 
-    const perTurn = recent.turns
-      ? recent.cost / recent.turns
-      : spent.cost / Math.max(spent.turns, 1);
-    window.percentPerTurn = perTurn / window.usdPerPercent;
+    const perTurn = typicalTurnCost(recentEvents, inWindow, events, MIN_PACE_SAMPLE);
+    window.percentPerTurn = perTurn === null ? null : perTurn / window.usdPerPercent;
+    window.typicalTurnUSD = perTurn;
     window.percentPerHour = window.recentUSDPerHour / window.usdPerPercent;
-    if (window.percentPerTurn > 0) {
+    if (window.percentPerTurn !== null && window.percentPerTurn > 0) {
       window.turnsLeft = Math.floor(window.percentLeft / window.percentPerTurn);
     }
     if (window.percentPerHour > 0) {
@@ -1151,6 +1180,8 @@ module.exports = {
   buildWindows,
   bindingWindow,
   dominantEffort,
+  typicalTurnCost,
+  MIN_PACE_SAMPLE,
   formatDuration,
   formatUSD,
   formatCount,