claude-usage-limits 1.24.0 → 1.25.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.24.0",
+  "version": "1.25.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/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "usage-limits",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "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.24.0",
+  "version": "1.25.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/scripts/relay.js

@@ -643,7 +643,11 @@ function schedulePosix(when, argv, name, cwd) {
       encoding: 'utf8',
       timeout: 20000,
     });
-    if (run.status === 0) return { ok: true, how: 'at' };
+    // macOS ships `at` but launchd leaves atrun DISABLED by default, so the
+    // command succeeds, prints a job id, and the wake never fires. Reporting
+    // ok for that is worse than not having it: it is a silent no-op that looks
+    // like a scheduled wake. Fall through to the sleeper, which at least runs.
+    if (run.status === 0 && process.platform !== 'darwin') return { ok: true, how: 'at' };
   }
   try {
     const child = spawn('sh', ['-c', 'sleep ' + seconds + ' && ' + command], {
@@ -767,16 +771,41 @@ function arm(input) {
         }
       : null,
   };
-  if (state.armed && state.armed.id !== id && state.armed.task) cancelSchedule(state.armed.task);
+  // Displacing somebody else's live relay is legitimate - one machine, one
+  // relay - but it must not be silent. A wake still in the future belonged to
+  // work that somebody expected to be picked up.
+  if (state.armed && state.armed.id !== id) {
+    if (Number.isFinite(state.armed.wakeAt) && state.armed.wakeAt > now) {
+      note('displacing the relay armed for ' + state.armed.id + ' (was due ' + new Date(state.armed.wakeAt).toISOString() + ')', now);
+    }
+    if (state.armed.task) cancelSchedule(state.armed.task);
+  }
   state.armed = record;
   write(state);
   note('armed ' + id + ' for ' + new Date(when).toISOString() + ' via ' + scheduled.how, now);
   return { ok: true, record };
 }
 
-function disarm(reason, now) {
+// `id` is optional, and when it is given it is a guard rather than a lookup:
+// clear the relay only if the thing armed is the thing the caller means.
+//
+// Without it, disarm clears whatever happens to be armed, and that is not
+// hypothetical. Measured 2026-09-14: a second process armed a throwaway
+// session at 04:57:04 and cleaned it up four seconds later, and the cleanup
+// took a live relay for an unrelated session - armed seven seconds earlier,
+// due to wake five hours later - with it. Nothing reported that, because from
+// disarm's point of view it did exactly what it was asked.
+//
+// A person typing `relay cancel` means "whatever is armed", so the CLI passes
+// no id and the old behaviour stands. Anything that knows which session it is
+// tidying up should say so.
+function disarm(reason, now, id) {
   const state = read();
   if (!state.armed) return { ok: true, changed: false };
+  if (id && state.armed.id !== id) {
+    note('refused to disarm ' + state.armed.id + ' on behalf of ' + id, Number.isFinite(now) ? now : Date.now());
+    return { ok: true, changed: false, refused: true, armed: state.armed.id };
+  }
   const record = state.armed;
   if (record.task) cancelSchedule(record.task);
   state.history.push(Object.assign({}, record, { endedAt: Number.isFinite(now) ? now : Date.now(), outcome: reason || 'cancelled' }));

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

@@ -146,6 +146,10 @@ function userIsPresent(cli) {
 function claudeArgs(record, prompt, config, fallback) {
   const args = fallback ? ['--continue', '-p', prompt] : ['--resume', record.id, '-p', prompt];
   if (config.permissionMode) args.push('--permission-mode', config.permissionMode);
+  // Nobody is awake to answer a prompt. Deny it rather than stall on it: a
+  // resumed run that sits waiting for a keystroke burns its whole timeout and
+  // reports nothing.
+  args.push('--permission-prompts', 'none');
   if (!fallback && config.model) args.push('--model', config.model);
   return args;
 }
@@ -186,12 +190,29 @@ function deliverClaude(record, prompt, config, cli, runs) {
   const run = appendRun(runs, 'claude --resume', spawnSync(cli, args, options));
   if (run.status === 0) return { ok: true, how: 'claude --resume' };
   const detail = ((run.stderr || run.stdout || '') + '').trim().split('\n')[0];
-  // A session id that no longer resolves is the one failure worth a second
-  // attempt: the work still needs doing, only the thread is gone.
+  // A session id that no longer resolves used to fall back to `--continue`,
+  // on the reasoning that the work still needs doing and only the thread is
+  // gone. That fallback is removed, because of what `--continue` actually
+  // selects.
+  //
+  // `--continue` normally SKIPS sessions created by `claude -p`, the SDK and
+  // /loop - but `claude -p --continue`, which is exactly what this ran,
+  // INCLUDES them. So the most recent session it could land on is a previous
+  // relay's own headless run, not the user's work. Resuming that, unattended,
+  // at four in the morning, with permissionMode bypassPermissions, means an
+  // agent continuing a conversation nobody chose, in a directory it was not
+  // asked about.
+  //
+  // The plan is on disk either way. A wake that stops and says the thread is
+  // gone loses nothing; a wake that resumes the wrong conversation can.
   if (/No conversation found/i.test(detail)) {
-    const second = appendRun(runs, 'claude --continue', spawnSync(cli, claudeArgs(record, prompt, config, true), options));
-    if (second.status === 0) return { ok: true, how: 'claude --continue' };
-    return { ok: false, error: ((second.stderr || second.stdout || '') + '').trim().split('\n')[0] || detail };
+    return {
+      ok: false,
+      error:
+        'the session ' + String(record.id).slice(0, 8) + ' no longer exists, so there was nothing to resume. ' +
+        'The plan is still on disk: run "claude" in ' + record.cwd + ' and paste it in.',
+      permanent: true,
+    };
   }
   return { ok: false, error: detail || 'claude exited ' + run.status };
 }