claude-usage-limits 1.39.6 → 1.40.1

package/.claude-plugin/plugin.json

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

@@ -350,6 +350,106 @@ The skill also requires Claude to say up front when a job will not fit in what
 is left, name what it is doing now, what it is leaving, and when the rest can
 happen, rather than starting and stopping halfway through an edit.
 
+## /low-priority, and Claude Code's own features at the wall
+
+Claude Code has grown its own machinery for the moment the 5-hour limit is hit.
+Some of it a hook can read and some of it cannot, and the whole of this
+section is about keeping that line straight — a plugin that guesses at the half
+it cannot see is worse at this than one that says nothing.
+
+**`/low-priority`** is a hidden toggle the CLI offers when the session (5-hour)
+limit is reached. It keeps the session working at reduced priority and spends
+your **weekly** limit, plus a separate weekly lower-priority allowance. Replies
+can pause while it waits for spare capacity. It appears in no changelog and in
+no documentation — there are zero mentions across all 405 versions of the
+bundled changelog back to 0.2.21 — and it is declared `isHidden: true`, so the
+only way anyone learns of it is the offer line at the wall.
+
+What the plugin can read is whether **your account is provisioned** for it, from
+one field in the same `~/.claude.json` it already parses for the meter:
+`cachedGrowthBookFeatures.tengu_toasty_breeze`. That costs no extra I/O, and it
+is re-read on every prompt rather than remembered, because the grant can be
+withdrawn mid-week.
+
+What the plugin **cannot** read is whether it is on right now. That state lives
+in the CLI's process memory and is written to no file — not `~/.claude.json`,
+not `~/.claude/state`, and no hook payload or status-line field carries it. So
+there are three states and never a fourth:
+
+| state | how it is known |
+| --- | --- |
+| **absent** | the account is not provisioned, and the plugin never mentions the command |
+| **offered** | provisioned, so the brief says it exists at the wall — as a possibility |
+| **acknowledged** | **you** said you switched it on: `mode --low-priority on` |
+
+Two further gates sit in front of the offer that nothing here will ever see: the
+experiment arm arrives in a response header, and the CLI withholds the offer
+during a cooloff and once the weekly allowance is spent. So the brief says "if
+the wall offers it", never "you can run it". And it never says the plugin or the
+model can switch it on: Claude cannot type a slash command, and the command is
+declared `supportsNonInteractive: false`, so it is unusable in a headless or
+relayed run either.
+
+At the wall with weekly headroom, the line looks like this:
+
+```
+If the wall offers it, /low-priority carries this session past the 5-hour limit
+at lower priority instead of stopping: it spends the weekly limit, which is at
+45% and so has room, and replies may pause while it waits for spare capacity -
+the wait and its ceiling are set by the server per request. It is a toggle: you
+type it yourself and run it again to stop, and nothing here can switch it on
+for you.
+```
+
+**The recommendation has a number behind it.** It is offered only while the
+weekly is at or below **80 per cent** and the 5-hour window is the binding wall.
+Above that the brief actively says not to, and cites the figure: low-priority
+spends the weekly *and* draws on a weekly allowance whose size is exposed to no
+hook and no file, and a real user measured it emptying most of a week in a
+couple of hours. No wait time is ever printed, because the retry and the ceiling
+come from `lowPriorityRetryAfterSeconds` and `lowPriorityMaxWaitSeconds` on each
+response — any fixed "20 seconds, 20 minutes" would be invented.
+
+Once you acknowledge it, three things change. The brief brakes on the **weekly**
+window instead of the 5-hour one, because that is the only brake left. It stops
+telling you to wind down at the 5-hour wall. And the relay **will not book a
+wake for the 5-hour reset** — this session carries straight past it, so a wake
+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.
+
+**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"`
+and `"next-steps"` and maps everything else to `"off"`. When it is on, this
+plugin stands down and says who is speaking, because two agents telling the
+model to wind down in different words is worse than one. When it is off, the
+plugin's own instruction stands. It is read, not assumed, so the right thing
+happens whichever way the flag is set. (The near-limit variant is a separate
+flag, `tengu_vellum_anchor`.)
+
+**`autoContinueAtUsageLimit`.** Since 2.1.234 Claude Code waits out the reset
+and continues the same open session by itself, and the setting is **on by
+default**. In place, with the context intact, that is better than any scheduled
+wake. So when a resume relay is armed and this is on, the brief says so: the
+wake is the route for a session that will be **closed** at the reset, and both
+firing for the same reset would start the work twice and spend the weekly twice.
+
+**`/limit-reset`**, the once-weekly manual session reset, is detected but not
+built on: this account holds no grant (`tengu_cedar_ember` absent,
+`cachedUsageUtilization.cedar_ember` null), so a feature resting on it would be
+untestable. If a grant appears, the brief names it at the wall, says it only
+works while you are actually at a limit, and says the work it unlocks still
+spends the weekly. It never reports how many are left — `resets_left` comes from
+a live endpoint and appears in no file a hook can read.
+
+**Grace is not weekly spend.** The allowance the wall gives you is metered in
+its own per-window meters (`anthropic-ratelimit-unified-grace-5h-utilization`
+and `-grace-7d-utilization`, with a `rateLimitGraceZone` naming which window it
+belongs to), not billed to the 7-day window. Its size arrives in response
+headers and appears in no hook payload, no status-line field and no file, so the
+plugin says nothing about how much of it is left rather than estimating.
+
 ## The relay: carrying a project across the reset
 
 The handoff has always had the same flaw. It gets written, and then it sits in
@@ -1170,7 +1270,8 @@ skills/usage-limits/scripts/      usage.js, brief.js, pulse.js, stop.js,
                                   recommend.js, panel.js, feed.js,
                                   statusline.js, live.js, view.js, bars.js,
                                   activity.js, reading.js, drift.js,
-                                  mode.js, voice.js, relay.js, wake.js
+                                  mode.js, voice.js, relay.js, wake.js,
+                                  lowpri.js
 skills/usage-limits/references/   the longer notes
 hooks/hooks.json                  runs brief.js before each prompt, pulse.js
                                   during long turns, stop.js after each reply
@@ -1182,6 +1283,7 @@ commands/statusline.md            the /usage-limits:statusline command
 commands/usage-mode.md            the /usage-mode command
 bin/cli.js                        the npx entry point
 tools/sync-version.js             keeps the manifest version in step
+tools/test-tempdirs.js            temp directories the suite deletes on exit
 vscode/                           the VS Code extension; build.js copies the
                                   scripts into vscode/lib and makes the vsix
 test/                             node --test, no dependencies
@@ -1193,10 +1295,11 @@ test/                             node --test, no dependencies
 node --test
 ```
 
-712 tests over the pricing, the window arithmetic, plan and credit detection,
+895 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, and the settings save/restore.
+packaging, the settings save/restore, and what Claude Code's own wall-time
+features are readable as (/low-priority, the wrap-up note, autoContinueAtUsageLimit).
 
 The budget modes are checked as rules rather than examples: the whole stopping
 matrix is walked in every mode (640 lines), `off` must inject nothing at any

package/commands/usage-mode.md

@@ -55,6 +55,29 @@ Commands:
   the last one, naming it first.
 - `--ledger` - measured turns and cost per turn, per mode, from what replies
   actually cost.
+- `--low-priority` / `--low-priority on` / `--low-priority off` - whether YOU
+  have switched Claude Code's `/low-priority` on. With no argument it reports
+  what is recorded, whether this account is provisioned for the command at all,
+  whether Claude Code will inject its own wrap-up note at the wall on this
+  machine, and whether the CLI's own continue-after-reset is on.
+
+  **This is a record of something the user did, never a reading.** Claude Code
+  keeps the live low-priority state in process memory and writes it to no file:
+  not `~/.claude.json`, not `~/.claude/state`, and no hook payload or
+  status-line field carries it. So the plugin knows three things and not a
+  fourth - the account is provisioned (`tengu_toasty_breeze.enabled`), the user
+  has said it is on, or neither. It never claims it is running.
+
+  `on` changes three behaviours: the brief brakes on the **weekly** window
+  instead of the 5-hour one, it stops telling you to wind down at the 5-hour
+  wall, and the relay will not book a wake for the 5-hour reset - that reset is
+  no longer a wall this session stops at. The record lapses on its own when the
+  5-hour window it was made against resets, because that is when low-priority
+  ends. Say `off` if it ends sooner.
+
+  The model cannot type a slash command, and `/low-priority` is declared
+  `supportsNonInteractive: false`, so it is also unusable in a headless or
+  relayed run. Nothing here can switch it on.
 
 Two rules that hold in every mode:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-usage-limits",
-  "version": "1.39.6",
+  "version": "1.40.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/SKILL.md

@@ -591,6 +591,49 @@ was not caution; it was quitting with a reason that sounded like one.
 Only when the switch is genuinely unavailable - no other window has room, or the
 user has ruled it out - does the checkpoint below apply.
 
+### /low-priority: the user's lever, never yours
+
+Claude Code has a hidden toggle, `/low-priority`, offered when the 5-hour session
+limit is reached. It keeps the session working at reduced priority and spends the
+**weekly** limit, plus a separate weekly lower-priority allowance; replies can
+pause while it waits for spare capacity.
+
+**You cannot switch it on.** You cannot type a slash command, and the command is
+declared `supportsNonInteractive: false`, so it does not work in a headless or
+relayed run either. What you may do is say, in one line, that it exists and what
+it costs - and only when the budget line has already said so, because the line is
+the only thing that knows whether this account is provisioned for it at all.
+Never volunteer it otherwise: telling a user to run a command their account does
+not have is worse than saying nothing.
+
+Three rules when the line does mention it:
+
+- **Word it as a possibility.** The offer is gated on an experiment arm that
+  arrives in a response header, and the CLI also withholds it during a cooloff
+  and once the weekly allowance is spent. "If the wall offers it", not "run it".
+- **Never invent a wait time.** The retry interval and its ceiling come from the
+  server on each response. There is no fixed number.
+- **If the line says not to, say not to, and why.** Above 80 per cent weekly it
+  is the wrong move: it spends the window that takes days to come back in order
+  to save one that comes back in hours.
+
+If the user tells you they have switched it on, the honest answer is to record
+it: `node scripts/mode.js --low-priority on`. From then the budget line brakes on
+the weekly instead of the 5-hour window, stops telling you to wind down at the
+5-hour wall, and the relay stops booking a wake for a reset this session no
+longer stops at. **Record it only when they said so.** Whether it is running is
+in the CLI's process memory and readable nowhere, so nothing here may infer it,
+and `mode --low-priority off` is how it is taken back.
+
+The same applies to `/limit-reset`, the once-weekly manual session reset: the
+line names it only if a grant is actually readable, it only works while you are
+at a limit, the work it unlocks still spends the weekly, and how many are left is
+not knowable from here.
+
+And if the budget line says Claude Code is injecting its own wrap-up note at this
+wall, follow that note: it is more specific than anything here, and two
+instructions to wind down in different words is worse than one.
+
 ## 6. Checkpoint before the wall
 
 When the binding window is under roughly 10 percent, or under about ten turns
@@ -865,7 +908,7 @@ stop.
 | `scripts/host.js` | Works out which agent this is running inside, so one host's percentages are never reported against the other's turns. |
 | `scripts/codex.js` | The Codex reader: the meter and the pace out of `~/.codex/sessions`, plus the live `--refresh` call. |
 | `scripts/install-codex-hook.js` | `status`, `on`, `off`. Installs the Codex-side instruction, which Claude Code does not need. |
-| `scripts/mode.js` | The budget mode: no arguments to report it, `max`/`high`/`standard`/`off` to set it, `auto`, `off --guard 95`, `--list`, `--explain <name>`, `--floor`/`--ceiling`/`--pin`, `--baseline`, `--advice`/`--no-advice`, `--history`, `undo`, `--ledger`. Reads settings.json and never writes it. |
+| `scripts/mode.js` | The budget mode: no arguments to report it, `max`/`high`/`standard`/`off` to set it, `auto`, `off --guard 95`, `--list`, `--explain <name>`, `--floor`/`--ceiling`/`--pin`, `--baseline`, `--advice`/`--no-advice`, `--history`, `undo`, `--ledger`, `--low-priority [on|off]`. Reads settings.json and never writes it. |
 | `scripts/lowpower.js` | `status`, `on`, `off`. Restores what it replaced. Claude Code only. |
 | `scripts/recommend.js` | The chooser behind `usage.js --recommend`: posture, then the effort and model commands for each lever. Not meant to be called by hand. |
 | `references/tactics.md` | Every lever that lowers cost, and why it works. |
@@ -879,6 +922,7 @@ stop.
 | `scripts/net.js` | Can this machine reach the API, and was a failed run the network's fault. Three probes, TLS-interception detection, and the backoff the offline retries use. |
 | `scripts/wake.js` | What the scheduler runs after the reset: re-checks the meter, then notifies or resumes. Never called by hand. |
 | `scripts/voice.js` | The local writing profile: `show`, `card`, `set "<instruction>"`, `clear`, `off`/`on`, `forget`. |
+| `scripts/lowpri.js` | What Claude Code's own features at the wall are readable as: whether this account is provisioned for `/low-priority`, whether a manual session reset grant exists, whether the CLI injects its own wrap-up note here, whether usage credits are available, whether `autoContinueAtUsageLimit` is on, and the record of the user saying they switched low-priority on. Reads only; never writes anything but that one record. |
 | `references/how-it-works.md` | Where the numbers come from and where they are soft. |
 
 ## Codex controls

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

@@ -24,6 +24,7 @@ const reading = require('./reading.js');
 const voice = require('./voice.js');
 const mode = require('./mode.js');
 const feed = require('./feed.js');
+const lowpri = require('./lowpri.js');
 
 const SECOND = 1000;
 const DAY = 24 * 60 * 60 * 1000;
@@ -511,6 +512,11 @@ const CACHED_BINDING_FIELDS = [
   'msToReset',
   'refusedAt',
   'refusedResetsAt',
+  // What the room that is left buys, per window. Needed because the binding
+  // window can be swapped for the weekly once low-priority is acknowledged, and
+  // a swapped window with the old window's turn count would be the brief
+  // quoting two different budgets in one sentence.
+  'turnsLeft',
 ];
 
 function cacheableBinding(binding) {
@@ -1003,6 +1009,74 @@ function briefText(input) {
       );
     }
   }
+  // /low-priority: the other thing that is not stopping.
+  //
+  // Three rules this block exists to keep. It says nothing at all unless the
+  // account is provisioned for the command, because advertising a slash command
+  // an account does not have is worse than silence. It never implies that the
+  // plugin or the model can switch it on - Claude cannot type a slash command,
+  // and the command is declared supportsNonInteractive:false, so it is unusable
+  // in a headless or relayed run as well. And it words the offer as a
+  // possibility, because the real gate is an experiment arm in a response
+  // header that nothing here will ever see.
+  //
+  // No wait time is printed. The retry and the ceiling come from
+  // lowPriorityRetryAfterSeconds and lowPriorityMaxWaitSeconds on each
+  // response, so any fixed number would be invented.
+  // Kept in a variable as well as pushed, for the same reason as the escape: it
+  // is the difference between stopping at the 5-hour wall and not, and the terse
+  // style drops only what reads the same every turn. This does not.
+  const lp = parts.lowPriority || null;
+  let lowPrioritySentence = null;
+  if (lp && lp.state === 'acknowledged') {
+    lowPrioritySentence = (
+      'You have said /low-priority is on, so the brake is the weekly window and not the 5-hour one: ' +
+        (Number.isFinite(lp.fiveHourPercent)
+          ? 'the 5-hour limit is at ' + lp.fiveHourPercent + '% and no longer stops this session, '
+          : 'the 5-hour limit no longer stops this session, ') +
+        'the figures above are the weekly, and replies may pause while lower priority waits for spare ' +
+        'capacity. Whether it is still on cannot be read from here, so if it has ended say so with ' +
+        'usage-mode --low-priority off and the 5-hour wall counts again. It also draws on a separate ' +
+        'weekly lower-priority allowance that is exposed to no hook and no file, so nothing here can ' +
+        'track how much of that is left.'
+    );
+  } else if (lp && lp.advise && lp.advise.kind === 'offer') {
+    lowPrioritySentence = (
+      'If the wall offers it, /low-priority carries this session past the 5-hour limit at lower ' +
+        'priority instead of stopping: it spends the weekly limit, which is at ' +
+        lp.advise.weeklyPercent + '% and so has room, and replies may pause while it waits for spare ' +
+        'capacity - the wait and its ceiling are set by the server per request. It is a toggle: you ' +
+        'type it yourself and run it again to stop, and nothing here can switch it on for you. Say ' +
+        'in one line that it is there; if it is taken, usage-mode --low-priority on is what makes ' +
+        'this line brake on the weekly instead.'
+    );
+  } else if (lp && lp.advise && lp.advise.kind === 'hold') {
+    lowPrioritySentence = (
+      'The wall may offer /low-priority here, and it is not worth taking: it spends the weekly limit, ' +
+        'which is already at ' + lp.advise.weeklyPercent + '% - past the ' + lp.advise.threshold +
+        ' per cent this plugin will recommend it at - and it draws on a weekly lower-priority ' +
+        'allowance as well, which has been measured emptying most of a week in a couple of hours. ' +
+        'Say in one line that the answer is no and why; waiting out the 5-hour reset is the cheaper move.'
+    );
+  }
+  if (lowPrioritySentence) sentences.push(lowPrioritySentence);
+  // A manual session reset, if this account ever gets one.
+  //
+  // /limit-reset refills the 5-hour window, works only AT a limit, and is once a
+  // week - and the work it unlocks still spends the weekly, which is the part
+  // worth saying out loud. This account holds no grant today
+  // (tengu_cedar_ember absent, cachedUsageUtilization.cedar_ember null), so the
+  // sentence is a detector rather than a feature: nothing is claimed about how
+  // many resets are left, because resets_left is served by a live endpoint and
+  // appears in no file a hook can read.
+  if (lp && lp.resetGrant && (parts.pressure === 'tight' || parts.pressure === 'gone')) {
+    sentences.push(
+      'A once-weekly manual session reset appears to be available on this account (/limit-reset). It ' +
+        'only works while you are actually AT a limit, and the work it unlocks still spends the weekly, ' +
+        'so it moves the 5-hour wall rather than adding budget. How many are left is not readable from ' +
+        'here - the CLI asks the server for that. It is yours to type, like /low-priority.'
+    );
+  }
   if (parts.session) {
     sentences.push(
       'This session: ' + parts.session.turns + ' turns, ' +
@@ -1102,6 +1176,23 @@ function briefText(input) {
       );
     }
   }
+  // The relay was built for a CLI that stopped dead at the wall. Since 2.1.234
+  // Claude Code waits out the reset and continues the same open session by
+  // itself, and the setting that does it is ON BY DEFAULT
+  // (autoContinueAtUsageLimit, code.claude.com/docs/en/settings-reference). In
+  // place, with the context intact, that is strictly better than a wake: no
+  // hand-off file to re-read and nothing lost. So the wake is the route for a
+  // session that will be CLOSED, and saying so is what stops both firing for the
+  // same reset - which would run the work twice and spend the weekly twice.
+  if (carry && carry.armed && carry.armed.mode === 'resume' && parts.autoContinue && parts.autoContinue.value) {
+    relaySentences.push(
+      'Claude Code\'s own "Continue automatically at usage limit" is on (' + parts.autoContinue.source +
+        '), so if this terminal is still open at the reset the CLI carries THIS session across by ' +
+        'itself, in place, with its context intact - better than any wake. The wake is the route for a ' +
+        'session that is closed by then. Both firing for the same reset would start the work twice and ' +
+        'spend the weekly twice, so if the terminal is staying open, one of the two is worth standing down.'
+    );
+  }
   if (carry && carry.last) {
     relaySentences.push(
       'The last relay ' +
@@ -1124,7 +1215,25 @@ function briefText(input) {
   // near the wall is to make being cut off cheap - order the work, save as you
   // go, keep a note of where things stand - not to shrink the work until it is
   // guaranteed to fit.
-  const instruction =
+  // Whether Claude Code itself is giving the wrap-up instruction at this wall.
+  //
+  // Confirmed mechanism, gated on a flag this plugin reads rather than assumed:
+  // the CLI injects its own "finish up" note when tengu_lantern_wick_mode is
+  // "wrap-up" or "next-steps". On this machine that flag reads "off", so the
+  // plugin's own instruction stands and nothing changes. When it flips, two
+  // agents telling the model to wind down in different words is worse than one,
+  // so this line stands down and says who is speaking instead.
+  //
+  // Not when an escape is live: the escape says the budget is still there, and
+  // deferring to a note that says the opposite would be the plugin handing over
+  // at the one moment it disagrees.
+  const hostWrapsUpNow =
+    Boolean(parts.hostWrapsUp) && !escapeText && (parts.pressure === 'tight' || parts.pressure === 'gone');
+  const instruction = hostWrapsUpNow
+    ? 'Claude Code is injecting its own wrap-up note at this wall, so it gives the instruction and this ' +
+      'line does not repeat it. Follow that note; the figures above are the ones to quote, and the ' +
+      'session total below is what to close with.'
+    :
     // The escape outranks everything below it. A session that stops while a
     // command would have carried it on has not been careful, it has quit - and
     // that is a real session: the Fable weekly hit 89 per cent, the line said
@@ -1252,6 +1361,7 @@ function briefText(input) {
     return (
       sentences[0] + caveat + (parts.tier ? ' ' + parts.tier : '') + (bounded ? ' ' + bounded : '') + adviceText +
       (escapeSentence ? ' ' + escapeSentence : '') +
+      (lowPrioritySentence ? ' ' + lowPrioritySentence : '') +
       (parts.pressure !== 'roomy' && relaySentences.length ? ' ' + relaySentences.join(' ') : '') +
       '\n' + instruction + directive
     );
@@ -1377,6 +1487,41 @@ function relayState(now, hookInput, binding, sessionId) {
   }
 }
 
+// What Claude Code's own wall-time features change about this brief.
+//
+// Only one of them changes a number. An acknowledged /low-priority retires the
+// 5-hour wall - the session carries straight past that reset at lower priority,
+// spending the weekly - so the window that actually stops the work becomes the
+// weekly, and the brief has to brake on that one instead. The swap happens here,
+// once, so the pressure, the relay and the sentence all describe the same
+// window; doing it in three places is how they come to describe two.
+//
+// Never on a guess. `acknowledged` means the user said so through
+// 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) {
+  const out = { binding, lowPriority: null, hostWrapsUp: false, swapped: false };
+  try {
+    const account = lowpri.snapshot();
+    const info = lowpri.forBrief({ account, now, binding, windows });
+    out.lowPriority = info;
+    out.hostWrapsUp = lowpri.wrapUp(account).hostWrapsUp;
+    out.autoContinue = info.autoContinue;
+    if (info.state === 'acknowledged' && binding && binding.key === 'five_hour') {
+      const weekly = lowpri.weeklyOf(windows);
+      if (weekly && Number.isFinite(weekly.percentUsed) && !weekly.stale && Number.isFinite(weekly.resetsAt)) {
+        out.binding = weekly;
+        out.swapped = true;
+        out.lowPriority = Object.assign({}, info, { weeklyBinding: true });
+      }
+    }
+  } catch (err) {
+    // Nothing about these features is worth a failed prompt.
+  }
+  return out;
+}
+
 // The one line `off` will ever say, and only when it has been asked for.
 //
 // `off` means off, including at 100 per cent: that is what was asked and it is
@@ -1629,10 +1774,35 @@ async function run(now, hookInput, opts) {
     writeCache(mergeCache(all, sessionId, view, KEEP_SESSIONS));
   }
 
-  const binding = view.binding;
+  // 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 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.
+  const turnsLeftNow = wall.swapped
+    ? (Number.isFinite(binding.turnsLeft) ? binding.turnsLeft : null)
+    : view.turnsLeft;
+  const othersSummaryNow = wall.swapped
+    ? summariseOthers(view.windows || [], binding.key)
+    : view.othersSummary;
+  // Everything derived from the window that WAS binding has to go with it.
+  //
+  // The escape route was worked out for the 5-hour window - "this window is
+  // scoped to one model, so switching model retires it" - and the sentence that
+  // prints it is gated on the binding window's percentage. Left in place after
+  // the swap it would describe one window while the figures beside it described
+  // another, which is the exact confusion the binding window exists to prevent.
+  // Same for the critical list, which excludes whichever window was binding: the
+  // weekly would otherwise be both the binding window and a "note that" warning
+  // about itself.
+  const escapeNow = wall.swapped ? null : view.escape || null;
+  const criticalNow = wall.swapped
+    ? (view.critical || []).filter((other) => other.label !== binding.label)
+    : view.critical || [];
   const { active, share } = activeShare(view.sessions, all, now, sessionId);
-  const yourTurnsLeft = Number.isFinite(view.turnsLeft)
-    ? Math.max(1, Math.round(view.turnsLeft * share))
+  const yourTurnsLeft = Number.isFinite(turnsLeftNow)
+    ? Math.max(1, Math.round(turnsLeftNow * share))
     : null;
   // Only a short runway is worth saying. Quoting it when there are hours left
   // would make the line longer without making it more useful.
@@ -1681,7 +1851,7 @@ async function run(now, hookInput, opts) {
   const offering = advice.ok && !advice.alreadyOffered;
   if (offering) mode.adviceOffer(advice.id, sessionId, now);
 
-  const pressureNow = pressure(binding, now, config, Number.isFinite(yourTurnsLeft) ? yourTurnsLeft : view.turnsLeft);
+  const pressureNow = pressure(binding, now, config, Number.isFinite(yourTurnsLeft) ? yourTurnsLeft : turnsLeftNow);
   // Fast mode changes what the window's figures mean, so a toggle is a change
   // worth saying even when nothing else has moved.
   const fastMode = fastModeFor(sessionId);
@@ -1696,12 +1866,17 @@ async function run(now, hookInput, opts) {
     budget.name,
     pressureNow,
     binding && Number.isFinite(binding.percentUsed) ? Math.round(binding.percentUsed / 5) * 5 : 'x',
-    view.escape ? view.escape.kind : '-',
+    escapeNow ? escapeNow.kind : '-',
     tier || '-',
     active > 1 ? 'shared' : 'solo',
     carry && carry.armed ? 'relay' : '-',
     offering ? 'advice' : '-',
     fastMode ? 'fast' : '-',
+    // An acknowledgement, or the wall starting to offer the toggle, changes what
+    // the line says and which window it brakes on. Leaving it out of the digest
+    // would let `max` swallow exactly the prompt on which that changed.
+    wall.lowPriority ? wall.lowPriority.state + (wall.lowPriority.advise ? ':' + wall.lowPriority.advise.kind : '') : '-',
+    wall.hostWrapsUp ? 'wrapup' : '-',
   ].join('|');
   if (!budget.policy.briefWhenUnchanged && pressureNow === 'roomy') {
     const slots = readCache();
@@ -1741,10 +1916,10 @@ async function run(now, hookInput, opts) {
       binding && binding.family && Number.isFinite(binding.percentUsed) && binding.percentUsed >= HALF_SPENT
         ? familyLabel(binding.family)
         : null,
-    othersSummary: view.othersSummary,
-    escape: view.escape || null,
+    othersSummary: othersSummaryNow,
+    escape: escapeNow,
     host: usage.currentHost(),
-    turnsLeft: view.turnsLeft,
+    turnsLeft: turnsLeftNow,
     effortWarning: view.effortWarning || null,
     // Once per setting, and once per session, and never after a decline: the
     // advice rules above decide, and the sentence itself is unchanged.
@@ -1760,13 +1935,17 @@ async function run(now, hookInput, opts) {
     rebuilt: Boolean(binding && binding.estimated),
     staleWindows: view.staleWindows || 0,
     planChanged: Boolean(view.planChanged),
-    critical: view.critical || [],
+    critical: criticalNow,
     pointsSinceSnapshot: (binding && binding.pointsSinceSnapshot) || 0,
     correctionUnreliable: Boolean(binding && binding.correctionUnreliable),
     pointsBeyondSnapshot: (binding && binding.pointsBeyondSnapshot) || 0,
     snapshotAge: view.snapshotAge,
     snapshotStale: Number.isFinite(view.snapshotAgeMs) && view.snapshotAgeMs >= SNAPSHOT_TRUST_MS,
     fastMode,
+    // Claude Code's own wall-time features, as far as they are readable.
+    lowPriority: wall.lowPriority,
+    hostWrapsUp: wall.hostWrapsUp,
+    autoContinue: wall.autoContinue || null,
     // The turn count that matters for this session is its share of a shared
     // budget, not the whole window's. Escalating on the whole window meant a
     // count that looked comfortable while the part actually available here was

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

@@ -0,0 +1,423 @@
+'use strict';
+
+// Claude Code's own features at the usage wall, as far as a hook can read them.
+//
+// There are five of them and they are not equally knowable, so this module
+// exists mostly to keep the difference straight. Everything here was verified
+// against the installed CLI on 2026-09-25 (@anthropic-ai/claude-code 2.1.283,
+// C:/Users/OWNER/AppData/Roaming/npm/node_modules/@anthropic-ai/claude-code).
+//
+//   /low-priority - a hidden toggle offered when the 5-hour session limit is
+//   reached: it keeps the session running at lower priority and spends the
+//   WEEKLY limit, plus a separate weekly lower-priority allowance. Whether the
+//   account is PROVISIONED for it is readable, from one field in the same
+//   ~/.claude.json this plugin already parses:
+//     cachedGrowthBookFeatures.tengu_toasty_breeze
+//   In the bundle: Cj="tengu_toasty_breeze", AKe()=Au().enabled===!0, and the
+//   command declares isEnabled:()=>pt()&&(WL()||AKe()).
+//
+//   Whether it is ON is NOT readable. The state lives in process memory only -
+//   WL()=mr().state.phase==="active", phases idle/armed/active/stale - and is
+//   written to no file. ~/.claude/state holds only mcp-discover-verdicts.json
+//   and skill-runs.jsonl; ~/.claude/usage-limits is empty; the documented hook
+//   payload (code.claude.com/docs/en/hooks) carries no usage field on any
+//   event; the statusLine payload has no low_priority field. So this module
+//   offers three states and never a fourth: absent, offered, and acknowledged
+//   by the user in their own words. activeKnown is false in all of them.
+//
+//   Two further gates sit in front of the offer that nothing here can see: the
+//   experiment arm arrives in a response header (ZIe() requires
+//   lowPriorityOffer==="treatment"), and the CLI withholds the offer during a
+//   cooloff and once the weekly allowance is spent. So every sentence built
+//   from this is a possibility, never a promise - and the grant can be
+//   withdrawn mid-week (github.com/anthropics/claude-code/issues/95470), which
+//   is why the flag is re-read on every brief instead of remembered.
+//
+//   The wait and retry are per-request, from lowPriorityRetryAfterSeconds and
+//   lowPriorityMaxWaitSeconds on the response headers. There is no client-side
+//   constant, so no number is printed for them. ($Fn=1800000 in the bundle is a
+//   30-minute freshness cutoff on cached window readings, nothing to do with
+//   this.)
+//
+//   /limit-reset - a once-weekly manual refill of the 5-hour window, usable
+//   only AT a limit, whose work still spends the weekly. Gated on
+//   tengu_cedar_ember, which is ABSENT from this account's feature cache, with
+//   cachedUsageUtilization.utilization.cedar_ember null. So there is nothing to
+//   spend here and nothing is built on it: only a detector that starts
+//   reporting if a grant ever appears. resets_left is served by a live
+//   endpoint, never a file, so the count is never claimed.
+//
+//   The graceful wrap-up note - the CLI injecting "finish up" at the wall. The
+//   mechanism is real and the treatment TEXT is provisioned on this machine
+//   (tengu_lantern_wick_text), but the gate is the MODE flag, and the bundle's
+//   own normalizer keeps only "wrap-up" and "next-steps" and maps everything
+//   else to "off":
+//     function kuo(e){let n=typeof e==="string"?e.trim().toLowerCase():e;
+//       return n==="wrap-up"||n==="next-steps"?n:"off"}
+//   tengu_lantern_wick_mode reads "off" here, so the note does not fire on this
+//   machine today and the plugin's own near-wall instruction must stay. When
+//   the flag flips, hostWrapsUp goes true and the plugin stands down rather
+//   than telling the model to wrap up in different words. (tengu_lantern_wick
+//   is in the cache but is not a string this build contains at all, so it reads
+//   nothing; the near-limit note is a separate flag, tengu_vellum_anchor,
+//   T1()=x("tengu_vellum_anchor",!1), which reads false here.)
+//
+//   Usage credits - blocked at the org level on this account
+//   (cachedExtraUsageDisabledReason "org_level_disabled", extra_usage
+//   is_enabled false), so nothing should offer /usage-credits here.
+//
+//   autoContinueAtUsageLimit - documented at
+//   code.claude.com/docs/en/settings-reference, shipped in 2.1.234, and
+//   DEFAULTED TO TRUE in the bundle (value:r?.autoContinueAtUsageLimit??!0). It
+//   waits out the reset and continues the same open session. That is better
+//   than a scheduled wake when the terminal stays open, and it is why the relay
+//   has to say so rather than presenting its wake as the only route.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const atomic = require('./atomic.js');
+
+const FLAG = 'tengu_toasty_breeze';
+const RESET_FLAG = 'tengu_cedar_ember';
+const WRAPUP_MODE_FLAG = 'tengu_lantern_wick_mode';
+const WRAPUP_TEXT_FLAG = 'tengu_lantern_wick_text';
+const NEAR_WALL_FLAG = 'tengu_vellum_anchor';
+
+// The only two mode values the CLI's own normalizer keeps.
+const WRAPUP_MODES = new Set(['wrap-up', 'next-steps']);
+
+// The client default in the bundle (xj=10), clamped there to 1440 minutes.
+const DEFAULT_COOLOFF_MINUTES = 10;
+const MAX_COOLOFF_MINUTES = 1440;
+
+// The recommendation rule, in one number so it can be argued with.
+//
+// /low-priority spends the weekly and draws on a weekly allowance whose size is
+// exposed nowhere a hook can read, and a real user measured it burning "almost
+// a week of usage in a couple hours"
+// (github.com/anthropics/claude-code/issues/92544). So it is worth naming only
+// while the weekly still has real room. At or below this it is offered; above
+// it the brief says not to, and says why.
+const WEEKLY_HEADROOM_MAX = 80;
+
+// Past this the 5-hour window is the wall, which is the only place the CLI
+// offers the toggle at all.
+const WALL_PERCENT = 90;
+
+function configDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function stateFile() {
+  return path.join(configDir(), 'usage-limits-lowpri.json');
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (err) {
+    return null;
+  }
+}
+
+// The same choice usage.js and host.js make, for the same reason: a migration
+// leaves a small ~/.claude/.claude.json with machine ids and no meter while the
+// account state stays in the home file, so pick the one that carries a
+// snapshot and only fall back to existence.
+function accountFiles() {
+  const scoped = path.join(configDir(), '.claude.json');
+  const home = path.join(os.homedir(), '.claude.json');
+  return scoped === home ? [home] : [scoped, home];
+}
+
+function snapshot() {
+  const files = accountFiles();
+  let fallback = null;
+  for (const file of files) {
+    const parsed = readJson(file);
+    if (!parsed) continue;
+    if (parsed.cachedUsageUtilization) return parsed;
+    if (!fallback) fallback = parsed;
+  }
+  return fallback;
+}
+
+function features(account) {
+  return account && account.cachedGrowthBookFeatures && typeof account.cachedGrowthBookFeatures === 'object'
+    ? account.cachedGrowthBookFeatures
+    : null;
+}
+
+function utilization(account) {
+  const cache = account && account.cachedUsageUtilization;
+  return cache && cache.utilization && typeof cache.utilization === 'object' ? cache.utilization : null;
+}
+
+// A string the server sent, or null. Never a default: the wording is
+// Anthropic's and it can change, so a sentence built on a made-up version of it
+// would be quoting the plugin to itself.
+function copy(value) {
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+// Whether this ACCOUNT is provisioned for /low-priority, plus the copy the
+// server shipped with it.
+//
+// A missing key is "not offered" and known:false - it is the absence of a fact,
+// not the fact of an absence, and the difference decides whether the docs can
+// say anything about this machine at all.
+function offer(account) {
+  const gb = features(account);
+  const raw = gb && Object.prototype.hasOwnProperty.call(gb, FLAG) ? gb[FLAG] : undefined;
+  if (raw === undefined) {
+    return {
+      known: false,
+      offered: false,
+      version: null,
+      label: null,
+      noticeLine: null,
+      statusLine: null,
+      allowanceNote: null,
+      waitBanner: null,
+      budgetExhaustedCopy: null,
+      cooloffMinutes: DEFAULT_COOLOFF_MINUTES,
+    };
+  }
+  const flag = raw && typeof raw === 'object' ? raw : {};
+  const cooloff = Number(flag.cooloffMinutes);
+  return {
+    known: true,
+    offered: flag.enabled === true,
+    version: Number.isFinite(Number(flag.version)) ? Number(flag.version) : null,
+    label: copy(flag.label),
+    noticeLine: copy(flag.noticeLine),
+    statusLine: copy(flag.statusLine),
+    allowanceNote: copy(flag.allowanceNote),
+    waitBanner: copy(flag.waitBanner),
+    budgetExhaustedCopy: copy(flag.budgetExhaustedCopy),
+    cooloffMinutes: Number.isFinite(cooloff)
+      ? Math.round(Math.min(MAX_COOLOFF_MINUTES, Math.max(0, cooloff)))
+      : DEFAULT_COOLOFF_MINUTES,
+  };
+}
+
+// The manual session reset. Detected, never spent: this account holds no grant,
+// so a feature built on it would be untestable here.
+function sessionReset(account) {
+  const gb = features(account);
+  const util = utilization(account);
+  const flagged = Boolean(gb && Object.prototype.hasOwnProperty.call(gb, RESET_FLAG) && gb[RESET_FLAG]);
+  const grant = util && util.cedar_ember ? util.cedar_ember : null;
+  return {
+    known: Boolean(gb || util),
+    present: Boolean(flagged || grant),
+    // resets_left is served from /api/organizations/<uuid>/reset_rate_limits,
+    // not from any file a hook can read, so it stays unreported.
+    resetsLeft: null,
+  };
+}
+
+// Whether the CLI itself will tell the model to wrap up at the wall.
+function wrapUp(account) {
+  const gb = features(account);
+  const rawMode = gb ? gb[WRAPUP_MODE_FLAG] : undefined;
+  const normalised = typeof rawMode === 'string' ? rawMode.trim().toLowerCase() : rawMode;
+  const mode = WRAPUP_MODES.has(normalised) ? normalised : 'off';
+  return {
+    known: Boolean(gb && (Object.prototype.hasOwnProperty.call(gb, WRAPUP_MODE_FLAG) || Object.prototype.hasOwnProperty.call(gb, WRAPUP_TEXT_FLAG))),
+    mode,
+    hostWrapsUp: mode !== 'off',
+    textProvisioned: Boolean(gb && copy(gb[WRAPUP_TEXT_FLAG])),
+    nearWallNote: Boolean(gb && gb[NEAR_WALL_FLAG] === true),
+  };
+}
+
+// Whether usage credits are a lever on this account at all.
+function credits(account) {
+  const util = utilization(account);
+  const extra = util && util.extra_usage ? util.extra_usage : null;
+  const reason =
+    account && typeof account.cachedExtraUsageDisabledReason === 'string'
+      ? account.cachedExtraUsageDisabledReason
+      : (extra && typeof extra.disabled_reason === 'string' ? extra.disabled_reason : null);
+  if (!extra) return { available: null, reason: reason };
+  if (extra.is_enabled === true) return { available: true, reason: null };
+  if (extra.is_enabled === false) return { available: false, reason: reason };
+  return { available: null, reason: reason };
+}
+
+function settingsFiles() {
+  return [path.join(configDir(), 'settings.local.json'), path.join(configDir(), 'settings.json')];
+}
+
+// The CLI's own wait-and-continue. Documented as user-or-managed scope, and the
+// bundle defaults it to true, so an absent key is TRUE - the one reading a
+// relay must not get wrong, because it decides whether the wake is the only
+// route across the reset or a second one.
+function autoContinue() {
+  for (const file of settingsFiles()) {
+    const parsed = readJson(file);
+    if (parsed && typeof parsed.autoContinueAtUsageLimit === 'boolean') {
+      return { value: parsed.autoContinueAtUsageLimit, source: path.basename(file) };
+    }
+  }
+  return { value: true, source: 'default' };
+}
+
+// ---------------------------------------------------------------------------
+// The acknowledgement. The plugin's own record that the USER said he turned
+// low-priority on, because nothing else can tell it.
+//
+// It carries the window it belongs to and that window's reset, and it lapses at
+// that reset: low-priority ends when the limit does, so a fact that outlived
+// its window would go on redirecting the headroom maths at the weekly in a
+// session where the 5-hour wall is real again.
+// ---------------------------------------------------------------------------
+
+function readState() {
+  const parsed = readJson(stateFile());
+  return parsed && typeof parsed === 'object' ? parsed : {};
+}
+
+function writeState(state) {
+  try {
+    atomic.writeFileAtomic(stateFile(), JSON.stringify(state, null, 2) + '\n');
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function acknowledge(input) {
+  const options = input || {};
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  if (!options.on) {
+    const state = readState();
+    delete state.ack;
+    writeState(state);
+    return { on: false, at: now };
+  }
+  const record = {
+    on: true,
+    at: now,
+    windowKey: options.windowKey || null,
+    resetsAt: Number.isFinite(options.resetsAt) ? options.resetsAt : null,
+  };
+  const state = readState();
+  state.ack = record;
+  writeState(state);
+  return record;
+}
+
+function readAck(now) {
+  const at = Number.isFinite(now) ? now : Date.now();
+  const state = readState();
+  const ack = state.ack;
+  if (!ack || ack.on !== true) return null;
+  // Past the reset of the window it was recorded against, the fact is spent.
+  if (Number.isFinite(ack.resetsAt) && at >= ack.resetsAt) return null;
+  return ack;
+}
+
+// Exactly three states, and activeKnown is false in every one of them.
+function stateOf(input) {
+  const options = input || {};
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const account = options.account !== undefined ? options.account : snapshot();
+  const provisioned = offer(account);
+  const ack = readAck(now);
+  return {
+    state: ack ? 'acknowledged' : provisioned.offered ? 'offered' : 'absent',
+    offered: provisioned.offered,
+    known: provisioned.known,
+    ack,
+    // Never readable. Said out loud here so no caller can talk itself into it.
+    activeKnown: false,
+    offer: provisioned,
+  };
+}
+
+function weeklyOf(windows) {
+  return (windows || []).find((w) => w && w.key === 'seven_day') || null;
+}
+
+// Whether to say anything about /low-priority on this prompt, and which way.
+//
+// Null unless the account is provisioned, the 5-hour window is the binding one,
+// it is at the wall, and there is a weekly reading to judge against. A guess at
+// any of those would be the plugin recommending a spend it cannot price.
+function advise(input) {
+  const options = input || {};
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const account = options.account !== undefined ? options.account : snapshot();
+  if (!offer(account).offered) return null;
+  const binding = options.binding;
+  if (!binding || binding.key !== 'five_hour') return null;
+  if (binding.stale) return null;
+  if (!Number.isFinite(binding.percentUsed) || binding.percentUsed < WALL_PERCENT) return null;
+  const weekly = weeklyOf(options.windows);
+  if (!weekly || !Number.isFinite(weekly.percentUsed) || weekly.stale) return null;
+  const percent = Math.round(weekly.percentUsed);
+  return {
+    kind: percent <= WEEKLY_HEADROOM_MAX ? 'offer' : 'hold',
+    weeklyPercent: percent,
+    threshold: WEEKLY_HEADROOM_MAX,
+    weeklyLabel: weekly.label || 'weekly',
+    now,
+  };
+}
+
+// Everything the brief needs, in one read of one file.
+function forBrief(input) {
+  const options = input || {};
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const account = options.account !== undefined ? options.account : snapshot();
+  const state = stateOf({ account, now });
+  const weekly = weeklyOf(options.windows);
+  const five = (options.windows || []).find((w) => w && w.key === 'five_hour') || null;
+  return {
+    state: state.state,
+    activeKnown: false,
+    advise: advise({ account, now, binding: options.binding, windows: options.windows }),
+    notice: state.offer.noticeLine,
+    cooloffMinutes: state.offer.cooloffMinutes,
+    budgetExhaustedCopy: state.offer.budgetExhaustedCopy,
+    weeklyLabel: weekly ? weekly.label || 'weekly' : 'weekly',
+    weeklyPercent: weekly && Number.isFinite(weekly.percentUsed) ? Math.round(weekly.percentUsed) : null,
+    fiveHourPercent: five && Number.isFinite(five.percentUsed) ? Math.round(five.percentUsed) : null,
+    resetGrant: sessionReset(account).present,
+    credits: credits(account),
+    autoContinue: autoContinue(),
+  };
+}
+
+module.exports = {
+  FLAG,
+  RESET_FLAG,
+  WRAPUP_MODE_FLAG,
+  WRAPUP_TEXT_FLAG,
+  NEAR_WALL_FLAG,
+  WRAPUP_MODES,
+  DEFAULT_COOLOFF_MINUTES,
+  MAX_COOLOFF_MINUTES,
+  WEEKLY_HEADROOM_MAX,
+  WALL_PERCENT,
+  configDir,
+  stateFile,
+  accountFiles,
+  snapshot,
+  offer,
+  sessionReset,
+  wrapUp,
+  credits,
+  autoContinue,
+  acknowledge,
+  readAck,
+  readState,
+  stateOf,
+  advise,
+  forBrief,
+  weeklyOf,
+};

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

@@ -34,6 +34,7 @@ const path = require('path');
 const atomic = require('./atomic.js');
 const host = require('./host.js');
 const codex = require('./codex.js');
+const lowpri = require('./lowpri.js');
 
 // ---------------------------------------------------------------------------
 // The policy table
@@ -1460,6 +1461,103 @@ function main(argv) {
     logChange({ plane: 'mode', key: 'advice', from: 'off', to: 'on', by: 'user', reason: null }, now);
     return 'Recommendations are back on, capped at one per session and never repeated once declined.';
   }
+  // Whether the user has switched /low-priority on.
+  //
+  // This is a RECORD of something the user said, not a reading. Claude Code
+  // keeps the live state in process memory and writes it nowhere - not to
+  // ~/.claude.json, not to ~/.claude/state, and no hook payload or status-line
+  // field carries it - so the plugin cannot know. What it can do is take the
+  // user's word, stamp it with the window it belongs to, and let it lapse at
+  // that window's reset, which is when low-priority ends anyway.
+  //
+  // 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')) {
+    const asked = String(value('--low-priority') || '').trim().toLowerCase();
+    const account = lowpri.snapshot();
+    const provisioned = lowpri.offer(account);
+    const detail = provisioned.offered
+      ? 'This account is provisioned for it (' + lowpri.FLAG + ' enabled' +
+        (provisioned.version ? ', config version ' + provisioned.version : '') + '), though the ' +
+        'offer itself also depends on an experiment arm that arrives in a response header, so it ' +
+        'is not guaranteed to appear at every wall.'
+      : provisioned.known
+        ? 'This account is NOT provisioned for it right now (' + lowpri.FLAG + ' is present and disabled), ' +
+          'so the wall will not offer it.'
+        : 'Whether this account is provisioned for it is unknown: ' + lowpri.FLAG + ' has never been ' +
+          'seen in the feature cache, which is the absence of a fact rather than the fact of an absence.';
+    if (asked === 'on' || asked === 'yes' || asked === 'true') {
+      // Stamp it with the 5-hour window it belongs to, so the fact lapses when
+      // that window resets instead of steering the headroom maths for ever.
+      let windowKey = null;
+      let resetsAt = null;
+      try {
+        const usage = require('./usage.js');
+        const windows = usage.snapshotWindows(usage.collect(now), now, null) || [];
+        const five = windows.find((w) => w && w.key === 'five_hour');
+        if (five && Number.isFinite(five.resetsAt)) {
+          windowKey = 'five_hour';
+          resetsAt = five.resetsAt;
+        }
+      } catch (err) {
+        // No reading is not a reason to refuse the user's own statement; the
+        // record simply has no expiry to hang on.
+      }
+      lowpri.acknowledge({ on: true, windowKey, resetsAt, now });
+      logChange({ plane: 'mode', key: 'low-priority', from: 'unknown', to: 'on', by: 'user', reason: null }, now);
+      return [
+        'Recorded: you have switched /low-priority on.',
+        '',
+        'From here the brief brakes on your WEEKLY window rather than the 5-hour one, stops telling ' +
+          'you to wind down at the 5-hour wall, says replies may pause while lower priority waits for ' +
+          'spare capacity, and will not book a relay wake for the 5-hour reset - that reset is no ' +
+          'longer a wall this session stops at.',
+        '',
+        'What it costs, in Anthropic\'s own words: it uses your weekly limit, and it draws on a ' +
+          'separate weekly lower-priority allowance whose size is exposed to no hook and no file, so ' +
+          'the plugin cannot track it. Nothing here can tell whether it is still on, so when you ' +
+          'turn it off: mode --low-priority off',
+        '',
+        resetsAt
+          ? 'This lapses on its own at ' + new Date(resetsAt).toLocaleString() + ', when the 5-hour window resets.'
+          : 'No 5-hour reset time was readable, so this has no expiry: clear it by hand when it ends.',
+        '',
+        detail,
+      ].join('\n');
+    }
+    if (asked === 'off' || asked === 'no' || asked === 'false') {
+      const had = lowpri.readAck(now);
+      lowpri.acknowledge({ on: false, now });
+      logChange({ plane: 'mode', key: 'low-priority', from: had ? 'on' : 'unknown', to: 'off', by: 'user', reason: null }, now);
+      return had
+        ? 'Cleared: low-priority is off again, so the 5-hour window counts as a wall from the next prompt.'
+        : 'Nothing was recorded, so there was nothing to clear. Low-priority is off as far as this plugin knows.';
+    }
+    if (asked) {
+      return 'mode --low-priority takes "on" or "off". Say which; this is a record of what YOU did, so it is never guessed.';
+    }
+    const ack = lowpri.readAck(now);
+    const wrap = lowpri.wrapUp(account);
+    const auto = lowpri.autoContinue();
+    return [
+      ack
+        ? 'You have acknowledged low-priority ON, at ' + new Date(ack.at).toLocaleString() +
+          (Number.isFinite(ack.resetsAt) ? ', lapsing at ' + new Date(ack.resetsAt).toLocaleString() : ', with no expiry') + '.'
+        : 'Low-priority has not been acknowledged, so the plugin treats the 5-hour window as a real wall.',
+      '',
+      'It is a toggle you type yourself. The model cannot run a slash command, and /low-priority is ' +
+        'declared supportsNonInteractive:false, so it is unusable in a headless or relayed run as well.',
+      '',
+      detail,
+      '',
+      'Claude Code will ' + (wrap.hostWrapsUp ? '' : 'NOT ') + 'inject its own wrap-up note at the wall on ' +
+        'this machine (' + lowpri.WRAPUP_MODE_FLAG + ' is "' + wrap.mode + '")' +
+        (wrap.textProvisioned && !wrap.hostWrapsUp ? ', although the note text is provisioned' : '') + '.',
+      'Claude Code\'s own continue-after-reset is ' + (auto.value ? 'ON' : 'OFF') + ' (' + auto.source + ').',
+      '',
+      'To set it: mode --low-priority on   /   mode --low-priority off',
+    ].join('\n');
+  }
   if (flag('--pin') || flag('--no-pin')) {
     const state = read();
     const before = state.pin;

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

@@ -37,6 +37,7 @@ const { spawn, spawnSync } = require('child_process');
 const atomic = require('./atomic.js');
 const host = require('./host.js');
 const voice = require('./voice.js');
+const lowpri = require('./lowpri.js');
 
 const MINUTE = 60 * 1000;
 
@@ -1173,6 +1174,34 @@ function armable(input) {
   const raw = binding.percentUsed - Math.max(0, beyond);
   if (raw < config.at) return { ok: false, why: 'the account reads ' + Math.round(raw) + ' per cent; only the local estimate (' + Math.round(binding.percentUsed) + ') is past ' + config.at };
   if (!Number.isFinite(binding.resetsAt)) return { ok: false, why: 'the window has no known reset time' };
+  // /low-priority retires the 5-hour wall while it is on: the session carries
+  // straight past that reset at lower priority, spending the weekly. A wake
+  // booked for that reset would fire into a session that was never stopped -
+  // and with Claude Code's own autoContinueAtUsageLimit on by default, two
+  // things starting the same work is the one bug here that costs real weekly
+  // budget. So it is refused, in plain words, and only for that window: the
+  // weekly is a different wall and still arms.
+  //
+  // 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') {
+    let ack = null;
+    try {
+      ack = lowpri.readAck(options.now);
+    } catch (err) {
+      ack = null;
+    }
+    if (ack) {
+      return {
+        ok: false,
+        why:
+          'low-priority is acknowledged on, so the 5-hour reset is not a wall to wake after - ' +
+          'this session carries past it and spends the weekly instead. Only the weekly window ' +
+          'would be worth a wake; say so with usage-mode --low-priority off if it has been switched back off',
+      };
+    }
+  }
   if (!options.sessionId) return { ok: false, why: 'no session id' };
   const work = workWithContinuation(options.work, options.sessionId);
   if (!work.hasWork) return { ok: false, why: 'no plan or unfinished todo list to carry, and no saved continuation' };