claude-usage-limits 1.6.0 → 1.6.1

package/.claude-plugin/plugin.json

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

@@ -473,6 +473,11 @@ Good enough to plan with, not a bill. The honest caveats:
   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.
+- What a point of a window costs is learned once from the best sample seen and
+  remembered, rather than re-derived each time from whatever slice is to hand.
+  A thin baseline prices a point badly and every correction built on it
+  inherits the error, which is how a window truly at 70 percent once came out
+  at 82.
 - 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
@@ -515,7 +520,7 @@ test/                             node --test, no dependencies
 node --test
 ```
 
-186 tests over the pricing, the window arithmetic, plan and credit detection,
+190 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.6.0",
+  "version": "1.6.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/scripts/usage.js

@@ -532,6 +532,43 @@ function shareOf(sessions, sessionId) {
   return mine.share > 0 ? mine.share : 1 / sessions.length;
 }
 
+// What a point of a window costs is a property of the plan, not of the moment,
+// so it should be learned once from a good sample rather than re-derived from
+// whatever slice happens to be to hand. A thin baseline prices a point badly
+// and every correction built on it inherits the error: a 24 minute old
+// snapshot once turned a window truly at 70 per cent into a confident 82.
+function calibrationFile() {
+  return path.join(configDir(), 'usage-limits-calibration.json');
+}
+
+function readCalibration() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(calibrationFile(), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch (err) {
+    return {};
+  }
+}
+
+function writeCalibration(all) {
+  try {
+    fs.mkdirSync(path.dirname(calibrationFile()), { recursive: true });
+    fs.writeFileSync(calibrationFile(), JSON.stringify(all), 'utf8');
+  } catch (err) {
+    // Losing it costs accuracy on the next thin baseline, nothing more.
+  }
+}
+
+// A sample is better when it rests on more turns. Percentages read in whole
+// numbers, so a bigger percentage also divides more precisely.
+function betterCalibration(current, candidate) {
+  if (!candidate || !Number.isFinite(candidate.usdPerPercent) || candidate.usdPerPercent <= 0) {
+    return current || null;
+  }
+  if (!current || !Number.isFinite(current.turns)) return candidate;
+  return candidate.turns > current.turns ? candidate : current;
+}
+
 // Everything the report needs about one limit window.
 function buildWindow(spec, snapshot, events, now, options) {
   const extra = options || {};
@@ -584,6 +621,8 @@ function buildWindow(spec, snapshot, events, now, options) {
     pointsSinceSnapshot: 0,
     // Set when spend since the snapshot could not be priced sensibly.
     correctionUnreliable: false,
+    // The price-per-point this window derived from its own baseline.
+    calibration: null,
     verdict: 'unknown',
   };
 
@@ -618,7 +657,13 @@ function buildWindow(spec, snapshot, events, now, options) {
     // divided by that, which is how a window truly at 55% got corrected all the
     // way to a confident 100.
     if (upTo.cost > 0 && after.cost > 0 && upTo.turns >= MIN_BASELINE_TURNS) {
-      const pricePerPoint = upTo.cost / rawPercent;
+      const mine = { usdPerPercent: upTo.cost / rawPercent, turns: upTo.turns, percent: rawPercent };
+      const known = extra.knownCalibration;
+      // Trust the better-sampled of the two, whichever that is.
+      const chosen =
+        known && Number.isFinite(known.turns) && known.turns > upTo.turns ? known : mine;
+      window.calibration = mine;
+      const pricePerPoint = chosen.usdPerPercent;
       sinceSnapshot = after.cost / pricePerPoint;
 
       // Same rule as a rebuild: past this it is the calibration that is full,
@@ -887,14 +932,17 @@ function reconstructWindow(spec, snapshot, events, now) {
 
 // No snapshot at all means no windows, which is what tells the report to
 // explain itself rather than print a table of dashes.
-function buildWindows(utilization, events, now, fetchedAt) {
+function buildWindows(utilization, events, now, fetchedAt, learned) {
   if (!utilization) return [];
   return WINDOWS.map((spec) => {
     const snapshot = utilization[spec.key];
     // The per-model weekly windows only exist on some plans.
     if (spec.key !== 'five_hour' && spec.key !== 'seven_day' && !snapshot) return null;
 
-    const window = buildWindow(spec, snapshot, events, now, { fetchedAt });
+    const window = buildWindow(spec, snapshot, events, now, {
+      fetchedAt,
+      knownCalibration: learned ? learned[spec.key] : null,
+    });
     if (!window.stale) return window;
 
     // Rolled over. Rebuild from local history rather than going blind on it.
@@ -934,7 +982,27 @@ async function report(now, options) {
   const earliest = now - 8 * DAY;
   const events = await readEvents(earliest);
 
-  const windows = buildWindows(base.utilization, events, now, base.snapshotFetchedAt);
+  const learned = readCalibration();
+  const windows = buildWindows(
+    base.utilization,
+    events,
+    now,
+    base.snapshotFetchedAt,
+    learned
+  );
+
+  // Keep the best sample seen so far, so a thin baseline never has to guess.
+  const updated = Object.assign({}, learned);
+  let changed = false;
+  for (const window of windows) {
+    if (!window.calibration) continue;
+    const best = betterCalibration(learned[window.key], window.calibration);
+    if (best && best !== learned[window.key]) {
+      updated[window.key] = best;
+      changed = true;
+    }
+  }
+  if (changed) writeCalibration(updated);
 
   const recentEvents = events.filter((event) => event.at >= now - HOUR);
   const recent = totals(recentEvents);
@@ -1359,6 +1427,8 @@ module.exports = {
   buildWindows,
   bindingWindow,
   criticalOthers,
+  betterCalibration,
+  calibrationFile,
   CRITICAL_PERCENT,
   dominantEffort,
   typicalTurnCost,