claude-usage-limits 1.40.1 → 1.40.3

package/.claude-plugin/plugin.json

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

@@ -418,6 +418,13 @@ would fire into a session that never stopped. A weekly wall still arms. The
 acknowledgement lapses by itself when the 5-hour window it was made against
 resets.
 
+A deferral is different from a wake, and is treated differently. `defer` is a
+time **you** named, so it is always scheduled — but if you defer to `reset` while
+low-priority is acknowledged, the confirmation says that this session carries
+past the 5-hour reset and waiting for it buys nothing. The mid-turn pulse follows
+the brief onto the weekly too, out of the same function, so the two can never
+report different windows.
+
 **The graceful wrap-up note.** Claude Code can inject its own "finish up"
 instruction at the wall. The mechanism is real, and the gate is
 `tengu_lantern_wick_mode` — the bundle's own normalizer keeps only `"wrap-up"`
@@ -1295,7 +1302,7 @@ test/                             node --test, no dependencies
 node --test
 ```
 
-895 tests over the pricing, the window arithmetic, plan and credit detection,
+901 tests over the pricing, the window arithmetic, plan and credit detection,
 the status line, the before-prompt line, the mid-turn pulse, the after-reply tally and the session history, job forecasting,
 per-project attribution, the Codex reader and its installer, the CLI,
 packaging, the settings save/restore, and what Claude Code's own wall-time

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-usage-limits",
-  "version": "1.40.1",
+  "version": "1.40.3",
   "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/brief.js

@@ -1454,7 +1454,7 @@ function relayState(now, hookInput, binding, sessionId) {
       return { enabled: true, armed: mine, config, last: recent };
     }
     const work = relay.detectWork(hookInput && hookInput.transcript_path, {});
-    const able = relay.armable({ config, binding, sessionId, work });
+    const able = relay.armable({ config, binding, sessionId, work, hostName: usage.currentHost() });
     if (!able.ok) return { enabled: true, why: able.why, config, last: recent, work };
     // Registering a scheduled task measured 936 ms, and this hook has ten
     // seconds of which the live reading may take four and the scan five. A
@@ -1500,8 +1500,19 @@ function relayState(now, hookInput, binding, sessionId) {
 // usage-mode --low-priority on, and that record lapses at the reset of the
 // window it was recorded against. Whether low-priority is really running is in
 // the CLI's process memory and readable nowhere; see lowpri.js.
-function wallFeatures(now, binding, windows) {
+// Claude Code only, and settled before a single file is read.
+//
+// Every one of these features is Claude Code's: /low-priority and /limit-reset
+// are its slash commands, the wrap-up note is its injection, and
+// autoContinueAtUsageLimit is its setting. None of them exist in Codex or in
+// Antigravity, and ~/.claude.json describes an account neither of them is
+// running on. Reading it from inside another host would put a Claude Code
+// command in front of an agent that cannot type it, against a window it is not
+// spending - the same mistake as naming /effort in Codex, which this plugin is
+// otherwise careful never to make.
+function wallFeatures(now, binding, windows, hostName) {
   const out = { binding, lowPriority: null, hostWrapsUp: false, swapped: false };
+  if (hostName !== host.CLAUDE) return out;
   try {
     const account = lowpri.snapshot();
     const info = lowpri.forBrief({ account, now, binding, windows });
@@ -1776,7 +1787,7 @@ async function run(now, hookInput, opts) {
 
   // Settled before the pressure, the relay and the line are decided, so all
   // three describe the same window.
-  const wall = wallFeatures(now, view.binding, view.windows);
+  const wall = wallFeatures(now, view.binding, view.windows, usage.currentHost());
   const binding = wall.binding;
   // The turn count belongs to whichever window is now binding. Carrying the
   // 5-hour count onto a weekly window would put two budgets in one sentence.
@@ -2000,7 +2011,7 @@ function withBugcheck(text) {
   return text;
 }
 
-module.exports = { sweepDebris, withBugcheck, sayOnce, shapeOf, saidFile, REPEAT_MS, staleVersionFor, relayNewsFor, installedVersion, runningVersion,
+module.exports = { wallFeatures, sweepDebris, withBugcheck, sayOnce, shapeOf, saidFile, REPEAT_MS, staleVersionFor, relayNewsFor, installedVersion, runningVersion,
   readSaid, standingSaid, markStanding, standingShortFor, STANDING_SHORT, cacheMissWhyFor, missReason, MISS_RECENT_MS,
   DEFAULTS,
   HOOK_BUDGET_MS,

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

@@ -140,7 +140,10 @@ function confirmation(parts) {
   const tail = [];
   tail.push('Nothing has been started');
   if (parts.items) tail.push(parts.items + ' saved');
-  if (parts.resetNote) tail.push(parts.resetNote);
+  // Every note, not only the first: two can apply at once.
+  for (const note of parts.notes && parts.notes.length ? parts.notes : [parts.resetNote]) {
+    if (note) tail.push(note);
+  }
   return line + tail.join('; ') + '. Run "defer cancel" to call it off.';
 }
 
@@ -154,7 +157,7 @@ function bindingReset(now) {
     usage.setHost(host.detect(process.argv.slice(2), process.env));
     const collected = usage.collect(now);
     const utilization = collected && collected.utilization;
-    if (!utilization) return { resetsAt: null, percent: null };
+    if (!utilization) return { resetsAt: null, percent: null, windowKey: null };
     let worst = null;
     for (const key of Object.keys(utilization)) {
       const window = utilization[key];
@@ -163,12 +166,24 @@ function bindingReset(now) {
       if (!Number.isFinite(percent)) continue;
       const resets = Date.parse(window.resets_at);
       if (!worst || percent > worst.percent) {
-        worst = { percent, resetsAt: Number.isFinite(resets) ? resets : null };
+        worst = { percent, resetsAt: Number.isFinite(resets) ? resets : null, windowKey: key };
       }
     }
     return worst || { resetsAt: null, percent: null };
   } catch (err) {
-    return { resetsAt: null, percent: null };
+    return { resetsAt: null, percent: null, windowKey: null };
+  }
+}
+
+// Claude Code only, like every other reader of this fact: /low-priority is its
+// slash command against its account, and Codex files a five-hour window under the
+// same key.
+function lowPriorityAcknowledged(now) {
+  try {
+    if (host.detect(process.argv.slice(2), process.env) !== host.CLAUDE) return false;
+    return Boolean(require('./lowpri.js').readAck(now));
+  } catch (err) {
+    return false;
   }
 }
 
@@ -198,13 +213,29 @@ function plan(options) {
       notes.push('note: that is before the window resets at ' + formatClock(binding.resetsAt));
     }
   }
+  // A deferral is a time the user named, so it is honoured whatever else is
+  // true - unlike an automatic relay wake, which the acknowledgement refuses.
+  // But waiting for a 5-hour reset this session carries straight past is
+  // waiting for nothing, and that is worth one line before the task is
+  // registered rather than after it fires.
+  if (options.lowPriorityAck && binding.windowKey === 'five_hour') {
+    notes.push(
+      'note: you have said /low-priority is on, so this session carries past the 5-hour reset ' +
+        'and waiting for it buys nothing - the weekly is the window that still stops work'
+    );
+  }
   return {
     ok: true,
     at: when.at,
     label: when.label,
     clock: formatClock(when.at),
     in: when.at - now,
+    // resetNote is the first of them, kept because the confirmation and the
+    // tests have always read that field. `notes` is all of them, because there
+    // can now be two and dropping the second would have hidden the one fact
+    // worth printing: that waiting for this reset buys nothing.
     resetNote: notes[0] || null,
+    notes,
   };
 }
 
@@ -256,7 +287,7 @@ function main(argv, now) {
   }
 
   const binding = bindingReset(at);
-  const decided = plan({ now: at, when: first, binding });
+  const decided = plan({ now: at, when: first, binding, lowPriorityAck: lowPriorityAcknowledged(at) });
   if (!decided.ok) return decided.error;
 
   const id = sessionId(args, process.env);
@@ -304,6 +335,7 @@ function main(argv, now) {
     in: decided.in,
     items,
     resetNote: decided.resetNote,
+    notes: decided.notes,
   });
 }
 
@@ -317,4 +349,4 @@ if (require.main === module) {
   }
 }
 
-module.exports = { parseWhen, formatClock, formatSpan, confirmation, plan, status, cancel, main, MINUTE, HOUR };
+module.exports = { lowPriorityAcknowledged, parseWhen, formatClock, formatSpan, confirmation, plan, status, cancel, main, MINUTE, HOUR };

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

@@ -1473,6 +1473,16 @@ function main(argv) {
   // Nothing else may write this. The model cannot type a slash command, so it
   // cannot have turned low-priority on, so it has nothing to acknowledge.
   if (flag('--low-priority')) {
+    // Claude Code only, said plainly rather than by doing nothing. /low-priority
+    // is a Claude Code slash command against a Claude account; recording it under
+    // Codex or Antigravity would write a fact about the wrong agent's budget into
+    // the wrong agent's config directory.
+    const hostHere = host.detect(process.argv.slice(2), process.env);
+    if (hostHere !== host.CLAUDE) {
+      return '/low-priority is a Claude Code command and does not exist in ' +
+        (hostHere === host.CODEX ? 'Codex' : 'Antigravity') +
+        ', so there is nothing to record here. Use that host\'s own controls for the task in hand.';
+    }
     const asked = String(value('--low-priority') || '').trim().toLowerCase();
     const account = lowpri.snapshot();
     const provisioned = lowpri.offer(account);

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

@@ -342,11 +342,17 @@ async function run(now, hookInput) {
   if (quiet) return '';
 
   const data = await usage.report(now, { sessionId, budgetMs: SCAN_BUDGET_MS });
-  const binding = data.binding;
-  if (!binding) return '';
+  if (!data.binding) return '';
+  // The same swap the brief makes, out of the same function so the two can never
+  // disagree: once the user has said /low-priority is on, the weekly is the only
+  // brake left, and a mid-turn line still counting down the 5-hour window would
+  // undo the brief on every tool call. Claude Code only; see brief.wallFeatures.
+  const wall = brief.wallFeatures(now, data.binding, data.windows || [], usage.currentHost());
+  const binding = wall.binding;
   // This turn paid for the scan, so leave the corrected figure where the
-  // status line and --status can read it without paying for one.
-  reading.recordAll(data.windows || [binding], now, usage.isCodex() ? require('./codex.js').homeDir() : null);
+  // status line and --status can read it without paying for one. Every window,
+  // not the one that happens to be binding after the swap.
+  reading.recordAll(data.windows || [data.binding], now, usage.isCodex() ? require('./codex.js').homeDir() : null);
 
   // The same count and the same split as the brief, so the two lines never
   // disagree about how many sessions there are or how much of the budget is

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

@@ -1185,7 +1185,14 @@ function armable(input) {
   // This reads the plugin's own acknowledgement, never a guess. Whether
   // low-priority is actually running lives in the CLI's process memory and is
   // readable nowhere; see lowpri.js.
-  if (binding.key === 'five_hour') {
+  //
+  // Claude Code only. Codex files a five-hour window under the same key, and
+  // /low-priority is a Claude Code slash command against a Claude account, so an
+  // acknowledgement made there must not refuse a Codex relay. The host is taken
+  // from the caller where it knows, and detected otherwise - the Codex and
+  // Antigravity hooks both pass --host.
+  const hostHere = options.hostName || host.detect(process.argv.slice(2), process.env);
+  if (binding.key === 'five_hour' && hostHere === host.CLAUDE) {
     let ack = null;
     try {
       ack = lowpri.readAck(options.now);

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

@@ -87,7 +87,7 @@ function armAtCompletion(now, hookInput, sessionId) {
   const binding = bindingFromCollect(usage.collect(now), now);
   if (!binding) return null;
 
-  const able = relay.armable({ config, binding, sessionId, work, atCompletion: true });
+  const able = relay.armable({ config, binding, sessionId, work, atCompletion: true, hostName: usage.currentHost() });
   if (!able.ok) return null;
 
   const armed = relay.arm({